Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

3.1 KB
Raw Blame
// Package cachetest provides reusable contract checks for cache providers.
package cachetest

import (
	"context"
	"sync"
	"sync/atomic"
	"testing"
	"time"

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

	"databasus-backend/internal/util/cache"
)

type StoreFactory func(t *testing.T) cache.Store

func RunStoreContract(t *testing.T, createStore StoreFactory) {
	t.Helper()

	t.Run("Test_Store_WhenPayloadMutates_CopiesValuesAndClearsEntries", func(t *testing.T) {
		store := createStore(t)
		sourcePayload := []byte("value")
		require.NoError(t, store.Set(t.Context(), cache.Entry{
			Key: "entry", Payload: sourcePayload, Lifetime: time.Minute,
		}))
		sourcePayload[0] = 'X'

		storedPayload, isFound, err := store.Get(t.Context(), "entry")
		require.NoError(t, err)
		require.True(t, isFound)
		assert.Equal(t, []byte("value"), storedPayload)
		storedPayload[0] = 'X'

		storedPayload, isFound, err = store.Get(t.Context(), "entry")
		require.NoError(t, err)
		require.True(t, isFound)
		assert.Equal(t, []byte("value"), storedPayload)

		require.NoError(t, store.Clear(t.Context()))
		_, isFound, err = store.Get(t.Context(), "entry")
		require.NoError(t, err)
		assert.False(t, isFound)
	})

	t.Run("Test_Store_WhenContextCanceled_ReturnsError", func(t *testing.T) {
		store := createStore(t)
		canceledContext, cancel := context.WithCancel(t.Context())
		cancel()

		err := store.Set(canceledContext, cache.Entry{
			Key: "entry", Payload: []byte("value"), Lifetime: time.Minute,
		})
		assert.ErrorIs(t, err, context.Canceled)
	})

	t.Run("Test_CreateIfAbsent_WithConcurrentCallers_ReservesOneCreator", func(t *testing.T) {
		store := createStore(t)
		const callerCount = 32
		var createdCount atomic.Int64
		operationErrors := make(chan error, callerCount)
		var waitGroup sync.WaitGroup
		for callerIndex := range callerCount {
			waitGroup.Go(func() {
				isCreated, err := store.CreateIfAbsent(t.Context(), cache.Entry{
					Key: "reservation", Payload: []byte{byte(callerIndex)}, Lifetime: time.Minute,
				})
				operationErrors <- err
				if isCreated {
					createdCount.Add(1)
				}
			})
		}
		waitGroup.Wait()
		close(operationErrors)
		for operationError := range operationErrors {
			require.NoError(t, operationError)
		}
		assert.Equal(t, int64(1), createdCount.Load())
	})

	t.Run("Test_ReadAndDelete_WithConcurrentConsumers_ReturnsOneValue", func(t *testing.T) {
		store := createStore(t)
		require.NoError(t, store.Set(t.Context(), cache.Entry{
			Key: "token", Payload: []byte("secret"), Lifetime: time.Minute,
		}))

		const callerCount = 32
		var consumedCount atomic.Int64
		operationErrors := make(chan error, callerCount)
		var waitGroup sync.WaitGroup
		for range callerCount {
			waitGroup.Go(func() {
				payload, isFound, err := store.ReadAndDelete(t.Context(), "token")
				operationErrors <- err
				if isFound {
					assert.Equal(t, []byte("secret"), payload)
					consumedCount.Add(1)
				}
			})
		}
		waitGroup.Wait()
		close(operationErrors)
		for operationError := range operationErrors {
			require.NoError(t, operationError)
		}
		assert.Equal(t, int64(1), consumedCount.Load())
	})
}