timedmap_test.go

package timedmap

import (
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

const (
	dCleanupTick = 10 * time.Millisecond
)

func TestNew(t *testing.T) {
	tm := New[int, int](dCleanupTick)

	assert.NotNil(t, tm)
	assert.EqualValues(t, 0, len(tm.container))
	time.Sleep(10 * time.Millisecond)
	assert.True(t, tm.cleanerRunning.Load())
}

func TestFromMap(t *testing.T) {
	t.Run("map-string-string", func(t *testing.T) {
		tm, err := FromMap(
			map[string]string{"foo": "bar", "baz": "fuzz"},
			200*time.Millisecond, 10*time.Millisecond)
		assert.Nil(t, err)

		v, ok := tm.GetValue("foo")
		assert.True(t, ok)
		assert.EqualValues(t, "bar", v)

		v, ok = tm.GetValue("baz")
		assert.True(t, ok)
		assert.EqualValues(t, "fuzz", v)

		time.Sleep(500 * time.Millisecond)

		assert.False(t, tm.Contains("foo"))
		assert.False(t, tm.Contains("baz"))
	})

	t.Run("map-int-interface", func(t *testing.T) {
		tm, err := FromMap(
			map[int]interface{}{1: "foo", 2: 3.456},
			200*time.Millisecond, 10*time.Millisecond)
		assert.Nil(t, err)

		v, ok := tm.GetValue(1)
		assert.True(t, ok)
		assert.EqualValues(t, "foo", v)

		v, ok = tm.GetValue(2)
		assert.True(t, ok)
		assert.EqualValues(t, 3.456, v)

		time.Sleep(500 * time.Millisecond)

		assert.False(t, tm.Contains(1))
		assert.False(t, tm.Contains(2))
	})
}

func TestFlush(t *testing.T) {
	tm := New[int, int](dCleanupTick)

	for i := 0; i < 10; i++ {
		tm.set(i, 1, time.Hour)
	}
	assert.EqualValues(t, 10, len(tm.container))
	tm.Flush()
	assert.EqualValues(t, 0, len(tm.container))
}

func TestSet(t *testing.T) {
	const key = "tKeySet"
	const val = "tValSet"

	tm := New[string, string](dCleanupTick)

	tm.Set(key, val, 20*time.Millisecond)
	if v := tm.get(key); v == nil {
		t.Fatal("key was not set")
	} else if v.value != val {
		t.Fatal("value was not like set")
	}
	assert.Equal(t, val, tm.get(key).value)

	time.Sleep(40 * time.Millisecond)
	assert.Nil(t, tm.get(key))
}

func TestGetValue(t *testing.T) {
	const key = "tKeyGetVal"
	const val = "tValGetVal"

	tm := New[string, string](dCleanupTick)

	tm.Set(key, val, 50*time.Millisecond)
	_, ok := tm.GetValue("keyNotExists")
	assert.False(t, ok)

	v, ok := tm.GetValue(key)
	assert.True(t, ok)
	assert.Equal(t, val, v)

	time.Sleep(60 * time.Millisecond)

	_, ok = tm.GetValue(key)
	assert.False(t, ok)

	tm.Set(key, val, 1*time.Microsecond)
	time.Sleep(2 * time.Millisecond)

	_, ok = tm.GetValue(key)
	assert.False(t, ok)
}

func TestGetExpire(t *testing.T) {
	const key = "tKeyGetExp"
	const val = "tValGetExp"

	tm := New[string, string](dCleanupTick)

	tm.Set(key, val, 50*time.Millisecond)
	ct := time.Now().Add(50 * time.Millisecond)

	_, err := tm.GetExpires("keyNotExists")
	assert.ErrorIs(t, err, ErrKeyNotFound)

	exp, err := tm.GetExpires(key)
	assert.Nil(t, err)
	assert.Less(t, ct.Sub(exp), 1*time.Millisecond)
}

func TestSetExpires(t *testing.T) {
	const key = "tKeyRef"

	tm := New[string, int](dCleanupTick)

	err := tm.Refresh("keyNotExists", time.Hour)
	assert.ErrorIs(t, err, ErrKeyNotFound)

	err = tm.SetExpires("notExistentKey", 1*time.Second)
	assert.ErrorIs(t, err, ErrKeyNotFound)

	tm.Set(key, 1, 12*time.Millisecond)
	err = tm.SetExpires(key, 50*time.Millisecond)
	assert.Nil(t, err)

	time.Sleep(30 * time.Millisecond)
	assert.NotNil(t, tm.get(key))

	time.Sleep(52 * time.Millisecond)
	assert.Nil(t, tm.get(key))
}

func TestContains(t *testing.T) {
	const key = "tKeyCont"

	tm := New[string, int](dCleanupTick)

	tm.Set(key, 1, 30*time.Millisecond)

	assert.False(t, tm.Contains("keyNotExists"))
	assert.True(t, tm.Contains(key))

	time.Sleep(50 * time.Millisecond)
	assert.False(t, tm.Contains(key))
}

func TestRemove(t *testing.T) {
	const key = "tKeyRem"

	tm := New[string, int](dCleanupTick)

	tm.Set(key, 1, time.Hour)
	tm.Remove(key)

	assert.Nil(t, tm.get(key))
}

func TestRefresh(t *testing.T) {
	const key = "tKeyRef"

	tm := New[string, int](dCleanupTick)

	err := tm.Refresh("keyNotExists", time.Hour)
	assert.ErrorIs(t, err, ErrKeyNotFound)

	tm.Set(key, 1, 12*time.Millisecond)
	assert.Nil(t, tm.Refresh(key, 50*time.Millisecond))

	time.Sleep(30 * time.Millisecond)
	assert.NotNil(t, tm.get(key))

	time.Sleep(100 * time.Millisecond)
	assert.Nil(t, tm.get(key))
}

func TestSize(t *testing.T) {
	tm := New[int, int](dCleanupTick)

	for i := 0; i < 25; i++ {
		tm.Set(i, 1, 50*time.Millisecond)
	}
	assert.EqualValues(t, 25, tm.Size())
}

func TestCallback(t *testing.T) {
	cb := new(CB[int])
	cb.On("Cb").Return()

	tm := New[int, int](dCleanupTick)

	tm.Set(1, 3, 25*time.Millisecond, cb.Cb)

	time.Sleep(50 * time.Millisecond)
	assert.Nil(t, tm.get(1))
	cb.AssertCalled(t, "Cb")
	assert.EqualValues(t, 3, cb.TestData().Get("v").Int())
}

func TestStopCleaner(t *testing.T) {
	tm := New[string, int](dCleanupTick)

	time.Sleep(10 * time.Millisecond)
	tm.StopCleaner()
	time.Sleep(10 * time.Millisecond)
	assert.False(t, tm.cleanerRunning.Load())

	assert.NotPanics(t, func() {
		tm.StopCleaner()
	})
}

func TestStartCleanerInternal(t *testing.T) {
	// Test functionality
	{
		tm := New[int, int](0)
		time.Sleep(10 * time.Millisecond)

		assert.False(t, tm.cleanerRunning.Load())

		// Ensure cleanup timer is not running
		tm.set(1, 1, 0)
		time.Sleep(100 * time.Millisecond)
		assert.EqualValues(t, 1, tm.getRaw(1).value)

		tm.StartCleanerInternal(dCleanupTick)
		time.Sleep(10 * time.Millisecond)
		assert.True(t, tm.cleanerRunning.Load())

		// Ensure cleanup timer is running
		tm.set(1, 0, 1)
		time.Sleep(100 * time.Millisecond)
		assert.Nil(t, tm.getRaw(1))
	}

	// Test ticker overwrite and cleaner stop
	{
		tm := New[int, int](dCleanupTick)
		time.Sleep(10 * time.Millisecond)

		oldTicker := tm.cleanerTicker

		tm.StartCleanerInternal(2 * dCleanupTick)
		assert.NotEqual(t, oldTicker, tm.cleanerTicker)
	}
}

func TestStartCleanerExternal(t *testing.T) {
	// Test functionality
	{
		tm := New[int, int](0)
		time.Sleep(10 * time.Millisecond)

		assert.False(t, tm.cleanerRunning.Load())

		// Ensure cleanup timer is not running
		tm.set(1, 1, 0)
		time.Sleep(100 * time.Millisecond)
		assert.EqualValues(t, 1, tm.getRaw(1).value)

		c := make(chan time.Time)

		tm.StartCleanerExternal(c)
		time.Sleep(10 * time.Millisecond)
		assert.True(t, tm.cleanerRunning.Load())

		// Ensure cleanup is controlled by c
		tm.set(1, 0, 1)
		time.Sleep(100 * time.Millisecond)
		assert.NotNil(t, tm.getRaw(1))

		// Ensure cleanup is controlled by c
		c <- time.Now()
		time.Sleep(10 * time.Millisecond)
		assert.Nil(t, tm.getRaw(1))
	}

	// Ensure timer overwrite
	{
		tm := New[int, int](dCleanupTick)
		time.Sleep(10 * time.Millisecond)

		assert.True(t, tm.cleanerRunning.Load())
		assert.NotNil(t, tm.cleanerTicker)

		c := make(chan time.Time)
		tm.StartCleanerExternal(c)

		// Ensure cleanup is controlled by c
		tm.set(1, 0, 1)
		time.Sleep(100 * time.Millisecond)
		assert.NotNil(t, tm.getRaw(1))
	}
}

func TestSnapshot(t *testing.T) {
	tm := New[int, int](1 * time.Minute)

	for i := 0; i < 10; i++ {
		tm.set(i, i, 1*time.Minute)
	}

	m := tm.Snapshot()

	assert.Len(t, m, 10)
	for i := 0; i < 10; i++ {
		assert.EqualValues(t, i, m[i])
	}
}

func TestConcurrentReadWrite(t *testing.T) {
	tm := New[int, int](dCleanupTick)

	go func() {
		for {
			for i := 0; i < 100; i++ {
				tm.Set(i, i, 2*time.Second)
			}
		}
	}()

	// Wait 10 mills before read cycle starts so that
	// it does not start before the first values are
	// set to the map.
	time.Sleep(10 * time.Millisecond)
	go func() {
		for {
			for i := 0; i < 100; i++ {
				v, ok := tm.GetValue(i)
				assert.True(t, ok)
				assert.EqualValues(t, i, v)
			}
		}
	}()

	time.Sleep(1 * time.Second)
}

func TestGetExpiredConcurrent(t *testing.T) {
	tm := New[int, int](dCleanupTick)

	wg := sync.WaitGroup{}
	for i := 0; i < 50000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			tm.Set(1, 1, 0)
		}()

		wg.Add(1)
		go func() {
			defer wg.Done()
			tm.GetValue(1)
		}()
	}

	wg.Wait()
}

func TestExternalTicker(t *testing.T) {
	const key = "tKeySet"
	const val = "tValSet"

	ticker := time.NewTicker(dCleanupTick)
	tm := New[string, string](0, ticker.C)

	tm.Set(key, val, 20*time.Millisecond)
	assert.Equal(t, val, tm.get(key).value)

	time.Sleep(40 * time.Millisecond)
	assert.Nil(t, tm.get(key))
}

func TestBeforeCleanup(t *testing.T) {
	const key, value = 1, 2

	tm := New[int, int](1 * time.Hour)

	tm.Set(key, value, 5*time.Millisecond)

	time.Sleep(10 * time.Millisecond)

	_, ok := tm.GetValue(key)
	assert.False(t, ok)
}

// ----------------------------------------------------------
// --- BENCHMARKS ---

func BenchmarkSetValues(b *testing.B) {
	tm := New[int, int](1 * time.Minute)
	for n := 0; n < b.N; n++ {
		tm.Set(n, n, 1*time.Hour)
	}
}

func BenchmarkSetGetValues(b *testing.B) {
	tm := New[int, int](1 * time.Minute)
	for n := 0; n < b.N; n++ {
		tm.Set(n, n, 1*time.Hour)
		tm.GetValue(n)
	}
}

func BenchmarkSetGetRemoveValues(b *testing.B) {
	tm := New[int, int](1 * time.Minute)
	for n := 0; n < b.N; n++ {
		tm.Set(n, n, 1*time.Hour)
		tm.GetValue(n)
		tm.Remove(n)
	}
}

func BenchmarkSetGetSameKey(b *testing.B) {
	tm := New[int, int](1 * time.Minute)
	for n := 0; n < b.N; n++ {
		tm.Set(1, n, 1*time.Hour)
		tm.GetValue(1)
	}
}

// ----------------------------------------------------------
// --- UTILS ---

type CB[TVal any] struct {
	mock.Mock
}

func (cb *CB[TVal]) Cb(v TVal) {
	cb.TestData().Set("v", v)
	cb.Called()
}