absl::Time mocking — 테스트 친화 시간

1
// 회피 — 테스트 불가
2
class Cache {
3
public:
4
    void Put(const Key& k, Value v) {
5
        entries_[k] = {std::move(v), absl::Now() + ttl_};  // ❌
6
    }
7
};

1
// Good — clock 주입
2
class Cache {
3
public:
4
    using Clock = std::function<absl::Time()>;
5

6
    explicit Cache(absl::Duration ttl, Clock clock = absl::Now)
7
        : ttl_(ttl), clock_(std::move(clock)) {}
8

9
    void Put(const Key& k, Value v) {
10
        entries_[k] = {std::move(v), clock_() + ttl_};
11
    }
12

13
    absl::optional<Value> Get(const Key& k) {
14
        auto it = entries_.find(k);
15
        if (it == entries_.end()) return absl::nullopt;
16
        if (it->second.expiry < clock_()) {
17
            entries_.erase(it);
18
            return absl::nullopt;
19
        }
20
        return it->second.value;
21
    }
22

23
private:
24
    absl::Duration ttl_;
25
    Clock clock_;
26
    struct Entry { Value value; absl::Time expiry; };
27
    absl::flat_hash_map<Key, Entry> entries_;
28
};

1
TEST(CacheTest, EntryExpiresAfterTtl) {
2
    absl::Time now = absl::FromUnixSeconds(1'000'000);
3
    Cache cache(absl::Seconds(10), [&now]() { return now; });
4

5
    cache.Put("k", "v");
6
    EXPECT_THAT(cache.Get("k"), Optional(std::string("v")));
7

8
    now += absl::Seconds(15);
9
    EXPECT_EQ(cache.Get("k"), absl::nullopt);
10
}

1
class SimulatedClock {
2
public:
3
    explicit SimulatedClock(absl::Time start = absl::UnixEpoch())
4
        : now_(start) {}
5

6
    absl::Time Now() const { return now_; }
7
    void Advance(absl::Duration d) { now_ += d; }
8
    void SetTime(absl::Time t) { now_ = t; }
9

10
    // std::function<absl::Time()>로 자동 변환
11
    operator std::function<absl::Time()>() const {
12
        return [this]() { return now_; };
13
    }
14

15
private:
16
    absl::Time now_;
17
};
18

19
TEST(CacheTest, EntryExpires) {
20
    SimulatedClock clock(absl::FromUnixSeconds(1'000'000));
21
    Cache cache(absl::Seconds(10), [&]() { return clock.Now(); });
22

23
    cache.Put("k", "v");
24
    clock.Advance(absl::Seconds(15));
25
    EXPECT_EQ(cache.Get("k"), absl::nullopt);
26
}

1
// 회피
2
absl::SleepFor(absl::Seconds(1));   // ❌ 테스트가 실제로 1초 잠
3

4
// Good — Sleeper 주입
5
class TokenBucket {
6
public:
7
    using Sleeper = std::function<void(absl::Duration)>;
8

9
    TokenBucket(int rate, Sleeper sleeper = &absl::SleepFor)
10
        : rate_(rate), sleeper_(std::move(sleeper)) {}
11

12
    void Acquire() {
13
        if (TryAcquire()) return;
14
        sleeper_(WaitTime());
15
    }
16
};
17

18
// 테스트
19
absl::Duration total_slept = absl::ZeroDuration();
20
TokenBucket tb(10, [&](absl::Duration d) { total_slept += d; });
21
tb.Acquire();
22
EXPECT_GT(total_slept, absl::ZeroDuration());

1
// 회피 — wall clock 차이
2
absl::Time start = absl::Now();
3
DoWork();
4
absl::Duration elapsed = absl::Now() - start;   // 음수 가능
5

6
// Good — 시작/끝 모두 monotonic
7
auto start = std::chrono::steady_clock::now();
8
DoWork();
9
auto elapsed = std::chrono::steady_clock::now() - start;

1
TEST(ExpiryTest, JustOver) {
2
    absl::Time t = absl::FromUnixSeconds(123);
3
    Expiry e(absl::Seconds(10), [&]() { return t; });
4

5
    EXPECT_FALSE(e.HasExpired());
6
    t += absl::Seconds(11);
7
    EXPECT_TRUE(e.HasExpired());
8
}

1
class RetryPolicy {
2
public:
3
    using Clock = std::function<absl::Time()>;
4
    using Sleeper = std::function<void(absl::Duration)>;
5

6
    RetryPolicy(int max_attempts, absl::Duration base,
7
                Clock clock = absl::Now, Sleeper sleeper = &absl::SleepFor)
8
        : max_attempts_(max_attempts), base_(base),
9
          clock_(std::move(clock)), sleeper_(std::move(sleeper)) {}
10

11
    template <typename Op>
12
    absl::Status Run(Op op) {
13
        absl::Time start = clock_();
14
        for (int attempt = 0; attempt < max_attempts_; ++attempt) {
15
            absl::Status s = op();
16
            if (s.ok()) return s;
17
            sleeper_(base_ * (1 << attempt));   // exponential
18
            if (clock_() - start > absl::Minutes(1)) {
19
                return absl::DeadlineExceededError("retry budget");
20
            }
21
        }
22
        return absl::DeadlineExceededError("max attempts");
23
    }
24
};
25

26
TEST(RetryPolicyTest, GivesUpAfterDeadline) {
27
    SimulatedClock clock;
28
    absl::Duration slept = absl::ZeroDuration();
29
    RetryPolicy p(100, absl::Seconds(1),
30
                  [&]() { return clock.Now(); },
31
                  [&](absl::Duration d) { slept += d; clock.Advance(d); });
32

33
    int calls = 0;
34
    auto s = p.Run([&]() { ++calls; return absl::UnknownError("nope"); });
35
    EXPECT_EQ(s.code(), absl::StatusCode::kDeadlineExceeded);
36
    EXPECT_LT(calls, 100);
37
    EXPECT_GT(slept, absl::Minutes(1));
38
}