Abseil Code Review · 46/79

Abseil Mocking Random — 테스트 결정성

2026년 6월 11일 · Hawk · 2분 읽기

#random 테스트의 두 가지 함정

랜덤이 들어간 코드를 테스트하는 두 가지 흔한 시도가 있고 둘 다 좋지 않다.

1
// 함정 1 — 시드 고정
2
absl::BitGen bg(absl::SeedSeq{42});
3
int x = absl::Uniform(bg, 0, 100);
4
EXPECT_EQ(x, 73);   // ❌ Abseil 버전 업그레이드 시 깨짐

absl::BitGen의 정확한 출력 시퀀스는 ABI가 아니다. 라이브러리 버전이 바뀌면 같은 시드도 다른 값을 낸다.

1
// 함정 2 — 통계적 검증
2
for (int i = 0; i < 1000; ++i) total += absl::Uniform(bg, 0, 100);
3
EXPECT_NEAR(total / 1000.0, 50.0, 1.0);   // ⚠️ 가끔 깨짐

평균 검증은 언젠가 깨진다. flaky test의 단골이다.

#MockingBitGen — 분포별 결과 강제

Abseil은 분포 호출 자체를 mock할 수 있는 인터페이스를 제공한다.

1
#include "absl/random/mocking_bit_gen.h"
2
#include "absl/random/mock_distributions.h"
3

4
TEST(MyClassTest, RetriesOnRare) {
5
    absl::MockingBitGen bg;
6

7
    // 다음 호출에서 Bernoulli(0.01)을 true로 강제
8
    EXPECT_CALL(absl::MockBernoulli(), Call(bg, 0.01))
9
        .WillOnce(testing::Return(true));
10

11
    MyClass m(&bg);
12
    m.MaybeRetry();   // 내부적으로 Bernoulli(bg, 0.01) 호출
13
}

MockingBitGen은 URBG 컨셉을 만족하지만, Uniform/Bernoulli/Gaussian 호출이 들어오면 gmock matcher로 가로챈다.

#분포별 Mock 매크로

각 분포마다 짝지어진 Mock 클래스가 있다.

분포	Mock
`Uniform`	`MockUniform<T>()`
`Bernoulli`	`MockBernoulli()`
`Gaussian`	`MockGaussian<T>()`
`Exponential`	`MockExponential<T>()`
`Poisson`	`MockPoisson<T>()`
`Zipf`	`MockZipf<T>()`
`LogUniform`	`MockLogUniform<T>()`
`Beta`	`MockBeta<T>()`

사용 패턴은 동일하다.

1
absl::MockingBitGen bg;
2

3
EXPECT_CALL(absl::MockUniform<int>(), Call(bg, 0, 100))
4
    .WillOnce(testing::Return(42));
5

6
int x = absl::Uniform(bg, 0, 100);
7
EXPECT_EQ(x, 42);

#ON_CALL vs EXPECT_CALL

EXPECT_CALL은 호출이 반드시 일어남을 검증. ON_CALL은 호출이 일어나면 이렇게 답한다는 행동 정의(검증 없음).

1
// 호출 보장 + 응답
2
EXPECT_CALL(absl::MockBernoulli(), Call(bg, 0.01))
3
    .WillOnce(testing::Return(true));
4

5
// 호출 여부 무관, 호출되면 응답
6
ON_CALL(absl::MockBernoulli(), Call(bg, testing::_))
7
    .WillByDefault(testing::Return(false));

코드 리뷰에서 자주 보는 패턴:

핵심 분기를 결정짓는 호출 → EXPECT_CALL
기본 행동만 정의(호출 횟수 무관) → ON_CALL

#Matcher로 인자 캡처

분포 파라미터에 matcher를 쓸 수 있다.

1
// p가 무엇이든 true 반환
2
EXPECT_CALL(absl::MockBernoulli(), Call(bg, testing::_))
3
    .WillRepeatedly(testing::Return(true));
4

5
// p가 특정 범위면 true
6
EXPECT_CALL(absl::MockBernoulli(),
7
            Call(bg, testing::Lt(0.5)))
8
    .WillOnce(testing::Return(true));

Sequence로 호출 순서를 지정하거나 Times로 횟수를 박을 수도 있다.

1
testing::InSequence seq;
2
EXPECT_CALL(absl::MockUniform<int>(), Call(bg, 0, 10))
3
    .Times(3)
4
    .WillRepeatedly(testing::Return(5));

#통과시키기 — DefaultBitGenRef

mock하지 않은 분포 호출은 진짜 random 으로 통과시키는 옵션도 있다.

1
EXPECT_CALL(absl::MockBernoulli(), Call(bg, 0.01))
2
    .WillOnce(testing::Return(true));
3

4
// Uniform 호출은 mock 안 함 → 실제 BitGen으로 fallback
5
int x = absl::Uniform(bg, 0, 10);

MockingBitGen은 내부적으로 실제 BitGen을 들고 있어 mock되지 않은 호출은 그쪽으로 보낸다.

#작은 예시 — A/B 테스트 분기

1
class FeatureFlag {
2
public:
3
    explicit FeatureFlag(absl::BitGenRef bg) : bg_(bg) {}
4

5
    bool IsEnabled(absl::string_view user_id) {
6
        // hash(user_id)를 [0, 1)로 매핑 — 결정적
7
        // 그 위에 1% 트래픽을 신기능에 라우팅
8
        double h = HashToUnit(user_id);
9
        if (h < 0.01) return true;
10
        return absl::Bernoulli(bg_, 0.5);   // 5050 분기
11
    }
12

13
private:
14
    absl::BitGenRef bg_;
15
};
16

17
TEST(FeatureFlagTest, RoutesBy5050) {
18
    absl::MockingBitGen bg;
19

20
    EXPECT_CALL(absl::MockBernoulli(), Call(bg, 0.5))
21
        .WillOnce(testing::Return(true))
22
        .WillOnce(testing::Return(false));
23

24
    FeatureFlag ff(bg);
25
    EXPECT_TRUE(ff.IsEnabled("user_a"));    // Bernoulli → true
26
    EXPECT_FALSE(ff.IsEnabled("user_b"));   // Bernoulli → false
27
}

#BitGenRef — 인터페이스 추상

absl::BitGenRef는 URBG 컨셉의 type-erased reference. mock과 실제 BitGen 모두 받는다.

1
class Sampler {
2
public:
3
    explicit Sampler(absl::BitGenRef bg) : bg_(bg) {}
4
    int Pick() { return absl::Uniform(bg_, 0, 100); }
5

6
private:
7
    absl::BitGenRef bg_;   // ref-like, 가벼움
8
};
9

10
// Production
11
absl::BitGen real;
12
Sampler s(real);
13

14
// Test
15
absl::MockingBitGen mock;
16
Sampler s_test(mock);

BitGenRef로 받으면 호출자 측에서 BitGen 종류를 자유롭게 바꾼다.

#회피 패턴

1
// 회피 — 시드 고정으로 출력 검증
2
absl::BitGen bg(absl::SeedSeq{42});
3
EXPECT_EQ(absl::Uniform(bg, 0, 100), 73);   // ❌ ABI 의존
4

5
// Good — Mocking으로 결과 강제
6
absl::MockingBitGen mbg;
7
EXPECT_CALL(absl::MockUniform<int>(), Call(mbg, 0, 100))
8
    .WillOnce(testing::Return(73));

1
// 회피 — random을 의존성으로 못 주입
2
class MyClass {
3
    absl::BitGen bg_;   // ❌ 내부 생성 — 테스트 불가
4
};
5

6
// Good — BitGenRef로 주입
7
class MyClass {
8
public:
9
    explicit MyClass(absl::BitGenRef bg) : bg_(bg) {}
10
private:
11
    absl::BitGenRef bg_;
12
};