cache_test.go

package the_cachex

import (
	"context"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"sync"
	"testing"
	"time"

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

var httpClient http.Client

func FetchData(ctx context.Context, url string) ([]byte, error) {
	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return nil, err
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	// We assume that any status code which is not 200 is an error
	if resp.StatusCode != 200 {
		_ = resp.Body.Close()
		return nil, fmt.Errorf("unexpected status code %d", resp.StatusCode)
	}
	defer func(Body io.ReadCloser) {
		err := Body.Close()
		if err != nil {
			slog.Warn(fmt.Sprintf("failed to close response body for %s", url))
		}
	}(resp.Body)
	bytes, err := ReadAll(ctx, resp.Body)
	return bytes, err
}

// TestCache_Fetch ensures cache fetching works
func TestCache_Fetch(t *testing.T) {
	t.Run("test fetch caches entry", func(t *testing.T) {
		// Given
		serverCallCounter := 0
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
			serverCallCounter += 1
			_, _ = w.Write([]byte("Hello World"))
		}))
		defer server.Close()

		leCache := NewCache[[]byte](10 * time.Minute)

		// Then
		for range 100 {
			data, err := leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
				return FetchData(ctx2, server.URL)
			})
			assert.NoError(t, err)
			assert.Equal(t, "Hello World", string(data))
			assert.Equal(t, 1, serverCallCounter)
		}
	})
	t.Run("test fetch with context", func(t *testing.T) {
		// Given
		serverCallCounter := 0
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
			serverCallCounter += 1
			_, _ = w.Write([]byte("Hello World"))
		}))
		defer server.Close()

		leCache := NewCache[[]byte](10 * time.Minute)

		// Then
		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
		_, err := leCache.Cache(ctx, server.URL, func(ctx2 context.Context) ([]byte, error) {
			return FetchData(ctx2, server.URL)
		})
		assert.Error(t, err, "context deadline did not exceed")
		cancel()
	})
	t.Run("test fetch error not being cached", func(t *testing.T) {
		// Setup
		serverCallCounter := 0
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if serverCallCounter == 0 {
				w.WriteHeader(http.StatusInternalServerError)
			} else {
				w.WriteHeader(http.StatusOK)
			}
			serverCallCounter += 1
			_, _ = w.Write([]byte("Hello World"))
		}))
		defer server.Close()

		leCache := NewCache[[]byte](10 * time.Minute)

		// Test error is not cached
		data, err := leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
			return FetchData(ctx2, server.URL)
		})
		assert.Error(t, err)
		assert.Equal(t, "", string(data))
		assert.Equal(t, 1, serverCallCounter)

		// Test no error
		data, err = leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
			return FetchData(ctx2, server.URL)
		})
		assert.NoError(t, err)
		assert.Equal(t, "Hello World", string(data))
		assert.Equal(t, 2, serverCallCounter)
	})
}

// TestCache_Stats ensures cache stats reporting works.
func TestCache_Stats(t *testing.T) {
	// Setup
	serverCallCounter := 0
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		serverCallCounter += 1
		_, _ = w.Write([]byte("Hello world"))
	}))
	defer server.Close()

	leCache := NewCache[[]byte](10 * time.Minute)

	// Test
	var wg sync.WaitGroup
	for range 100 {
		wg.Add(1)
		go func() {
			_, err := leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
				return FetchData(ctx2, server.URL)
			})
			if err != nil {
				t.Errorf("Unknown error occured: %v", err)
			}
			wg.Done()
		}()
	}
	wg.Wait()
	hits, misses, entries := leCache.Stats()

	// Assert
	assert.Equal(t, 99, hits, "the number of hits differ")
	assert.Equal(t, 1, misses, "the number of misses differ")
	assert.Equal(t, 1, entries, "the number of entries differ")
	assert.Equal(t, 1, serverCallCounter, "the server calls differ")
}

// TestCache_Concurrency ensures cache behaves as expected in concurrent scenarios.
func TestCache_Concurrency(t *testing.T) {
	t.Run("test concurrency happy path", func(t *testing.T) {
		// Setup
		serverCallCounter := 0
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
			serverCallCounter += 1
			_, _ = w.Write([]byte("Hello world"))
		}))
		defer server.Close()

		leCache := NewCache[[]byte](5 * time.Second)

		// Test
		var wg sync.WaitGroup
		for range 200 {
			wg.Add(1)
			go func() {
				_, err := leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
					return FetchData(ctx2, server.URL)
				})
				if err != nil {
					t.Errorf("Unknown error occured: %v", err)
				}
				wg.Done()
			}()
		}
		wg.Wait()
		hits, misses, entries := leCache.Stats()

		// Assert
		assert.Equal(t, 199, hits, "the number of hits differ")
		assert.Equal(t, 1, misses, "the number of misses differ")
		assert.Equal(t, 1, entries, "the number of entries differ")
		assert.Equal(t, 1, serverCallCounter, "the server calls differ")
	})
	t.Run("test concurrency entry expires before being fetched", func(t *testing.T) {
		// Setup
		serverCallCounter := 0
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if serverCallCounter == 0 {
				time.Sleep(500 * time.Millisecond)
			}
			w.WriteHeader(http.StatusOK)
			serverCallCounter += 1
			_, _ = w.Write([]byte("Hello world"))
		}))
		defer server.Close()

		leCache := NewCache[[]byte](10 * time.Millisecond)

		// Test
		var wg sync.WaitGroup
		for range 200 {
			wg.Add(1)
			go func() {
				data, err := leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
					return FetchData(ctx2, server.URL)
				})
				assert.NoError(t, err)
				assert.Equal(t, string(data), "Hello world")
				wg.Done()
			}()
		}
		wg.Wait()
		hits, misses, entries := leCache.Stats()

		// Assert
		assert.Equal(t, 199, hits, "the number of hits differ")
		assert.Equal(t, 1, misses, "the number of misses differ")
		assert.Equal(t, 1, entries, "the number of cache entries differ")
		assert.Equal(t, 1, serverCallCounter, "the server call counter is different")
	})
	t.Run("test concurrency slow fetch", func(t *testing.T) {
		// Setup
		serverCallCounter := 0
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if serverCallCounter == 0 {
				time.Sleep(1000 * time.Millisecond)
			}
			w.WriteHeader(http.StatusOK)
			serverCallCounter += 1
			_, _ = w.Write([]byte("Hello world"))
		}))
		defer server.Close()

		leCache := NewCache[[]byte](10 * time.Minute)

		// Test
		var wg sync.WaitGroup
		for range 200 {
			wg.Add(1)
			go func() {
				data, err := leCache.Cache(context.Background(), server.URL, func(ctx2 context.Context) ([]byte, error) {
					return FetchData(ctx2, server.URL)
				})
				assert.NoError(t, err)
				assert.Equal(t, string(data), "Hello world")
				wg.Done()
			}()
		}
		wg.Wait()
		hits, misses, entries := leCache.Stats()

		// Assert
		assert.Equal(t, 199, hits, "the number of hits differ")
		assert.Equal(t, 1, misses, "the number of misses differ")
		assert.Equal(t, 1, entries, "the number of cache entries differ")
		assert.Equal(t, 1, serverCallCounter, "the server call counter is different")
	})
}

// TestCacheTTL ensures cache handles per entry TTL correctly.
func TestCacheTTL(t *testing.T) {
	serverCallCounter := 0
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		serverCallCounter += 1
		_, _ = fmt.Fprintf(w, "Hello world %d", serverCallCounter)
	}))
	defer server.Close()
	leCache := NewCache[[]byte](100 * time.Millisecond)

	cacheFunction := func(ctx2 context.Context) ([]byte, error) {
		return FetchData(ctx2, server.URL)
	}

	// Test first request, it should fetch the same URL as ttl is not expired
	serverUrl := server.URL
	data, err := leCache.Cache(context.Background(), serverUrl, cacheFunction)
	assert.NoError(t, err)
	assert.Equal(t, "Hello world 1", string(data))

	data, err = leCache.Cache(context.Background(), serverUrl, cacheFunction)
	assert.NoError(t, err)
	assert.Equal(t, "Hello world 1", string(data))
	assert.Equal(t, 1, serverCallCounter)

	time.Sleep(100 * time.Millisecond)

	// Test second fetch
	data, err = leCache.Cache(context.Background(), serverUrl, cacheFunction, 250*time.Millisecond)
	assert.NoError(t, err)
	assert.Equal(t, "Hello world 2", string(data))
	assert.Equal(t, 2, serverCallCounter)

	for range 100 {
		data, err = leCache.Cache(context.Background(), serverUrl, cacheFunction, 250*time.Millisecond)
		assert.NoError(t, err)
		assert.Equal(t, "Hello world 2", string(data))
		assert.Equal(t, 2, serverCallCounter)
	}
	// Sleep to pass TTL override time
	time.Sleep(100 * time.Millisecond)

	data, err = leCache.Cache(context.Background(), serverUrl, cacheFunction, 250*time.Millisecond)
	assert.NoError(t, err)
	assert.Equal(t, "Hello world 2", string(data))
	assert.Equal(t, 2, serverCallCounter)

	// Final result test
	time.Sleep(150 * time.Millisecond)
	data, err = leCache.Cache(context.Background(), serverUrl, cacheFunction, 250*time.Millisecond)
	assert.NoError(t, err)
	assert.Equal(t, "Hello world 3", string(data))
	assert.Equal(t, 3, serverCallCounter)

}