Allow overriding time.Now

[AnatolyRugalev]

Hey, this is a very solid caching library, thanks for making it happen!

Here's one minor thing I would like to address or ask your opinion about.

What I like about the implementation is the fact that the library doesn't spin up any goroutines and provides full control over cache eviction. But there's one last piece of control I would like to have — the time.Now function. Right now it's hardcoded in a few places, which makes it difficult to write deterministic tests for TTL behavior without real sleeps, and also blocks use cases like wall-clock-aligned expiry.

Do you think we could pass a func() time.Time function as an option for the cache? Keeping time.Now as the default value, of course.

Thanks

UPD: I also see theres a PR that switches time.Now to runtime.nanotime #21, and having this option would allow users to plug in any time function they want. For perfomance reasons though, it might make sense to actually use func() int64, but I don't have any data to support this. Just a gut feeling and that PR that claims performance boost

[paskal]

Rather than adding a func() time.Time option to the cache, Go 1.24 introduced testing/synctest (stable since Go 1.25), which provides exactly what you need without any library changes.

synctest.Test runs your test inside an isolated "bubble" with a fake clock. Within the bubble, time.Now() returns fake time and time.Sleep() advances the fake clock instantly. Since this cache already uses time.Now() internally, it works with synctest automatically:

func TestCacheTTL(t *testing.T) {
    synctest.Test(t, func(t *testing.T) {
        lc := cache.NewCache[string, string]().WithTTL(time.Second * 5)
        lc.Set("key1", "val1", 0)

        // verify entry is present before expiration
        v, ok := lc.Get("key1")
        assert.True(t, ok)
        assert.Equal(t, "val1", v)

        // advance fake clock past TTL — instant, deterministic
        time.Sleep(time.Second * 10)

        // entry is now expired
        _, ok = lc.Get("key1")
        assert.False(t, ok)
    })
}

This approach has several advantages:

• No library changes needed — works with the cache as-is
• Deterministic and instant — no real wall-clock delays
• Standard Go tooling — no custom clock abstractions or dependencies

I've rewritten the library's own tests to use this pattern.

Regarding PR #21 (switching to runtime.nanotime()): that approach has been declined because //go:linkname to internal runtime functions is fragile, and using runtime.nanotime() instead of time.Now() would break compatibility with synctest's fake clock.