timecache_test.go

// Copyright 2026 Byterio
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package timecache

import (
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
)

var timerTestMu sync.Mutex

func checkTimeStamp(tb testing.TB, expectedCurrent, actualCurrent uint32) {
	tb.Helper()
	// Test with buffer of ±2 seconds for CI environment tolerance.
	require.True(tb, actualCurrent >= expectedCurrent-2 && actualCurrent <= expectedCurrent+2,
		"Expected timestamp %d (±2s), got %d (diff: %d)", expectedCurrent, actualCurrent, int64(actualCurrent)-int64(expectedCurrent))
}

func Test_Updater(t *testing.T) {
	timerTestMu.Lock()
	defer timerTestMu.Unlock()

	f := New()
	f.Start()
	defer f.Stop()

	now := uint32(time.Now().Unix())

	time.Sleep(100 * time.Millisecond)

	ts := f.Timestamp()
	require.True(t, ts >= now-1 && ts <= now+1,
		"Initial timestamp should be within ±1 second of current time. Expected: %d±1, got: %d (diff: %d)",
		now, ts, int64(ts)-int64(now))

	time.Sleep(1100 * time.Millisecond)

	ts2 := f.Timestamp()
	require.Greater(t, ts2, ts,
		"Timestamp should have updated after 1+ seconds. Initial: %d, after 1s: %d",
		ts, ts2)

	currentTime := uint32(time.Now().Unix())
	require.True(t, ts2 >= now && ts2 <= currentTime+1,
		"Updated timestamp should be between test start (%d) and current time (%d), got: %d",
		now, currentTime, ts2)
}

func Test_StopUpdater(t *testing.T) {
	timerTestMu.Lock()
	defer timerTestMu.Unlock()

	f := New()
	f.Start()

	// Get initial timestamp.
	time.Sleep(100 * time.Millisecond)
	initial := f.Timestamp()

	f.Stop()

	// Verify it stops updating.
	time.Sleep(2 * time.Second)
	final := f.Timestamp()
	currentTime := uint32(time.Now().Unix())
	require.Equal(t, initial, final,
		"Timestamp should not change after stopping updater. Stopped at: %d, checked at: %d (wall time: %d)",
		initial, final, currentTime)
}

func Test_StartStopRepeat(t *testing.T) {
	timerTestMu.Lock()
	defer timerTestMu.Unlock()

	f := New()
	f.Start()
	f.Stop()
	f.Start()
	defer f.Stop()

	time.Sleep(50 * time.Millisecond)
	ts := f.Timestamp()
	require.NotZero(t, ts)
}

func Benchmark_CalculateTimestamp(b *testing.B) {
	timerTestMu.Lock()
	defer timerTestMu.Unlock()

	f := New()
	f.Start()
	defer f.Stop()

	b.Run("timecache", func(bb *testing.B) {
		bb.ReportAllocs()
		bb.ResetTimer()
		for n := 0; n < bb.N; n++ {
			_ = f.Timestamp()
		}
	})

	b.Run("default", func(bb *testing.B) {
		bb.ReportAllocs()
		bb.ResetTimer()
		for n := 0; n < bb.N; n++ {
			_ = uint32(time.Now().Unix())
		}
	})

	b.Run("timecache_asserted", func(bb *testing.B) {
		bb.ReportAllocs()
		bb.ResetTimer()
		for n := 0; n < bb.N; n++ {
			res := f.Timestamp()
			expected := uint32(time.Now().Unix())
			checkTimeStamp(bb, expected, res)
		}
	})

	b.Run("default_asserted", func(bb *testing.B) {
		bb.ReportAllocs()
		bb.ResetTimer()
		for n := 0; n < bb.N; n++ {
			expected := uint32(time.Now().Unix())
			res := uint32(time.Now().Unix())
			checkTimeStamp(bb, expected, res)
		}
	})
}