statement_cache_test.go

package dbx

import (
	"context"
	"errors"
	"regexp"
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
)

func TestStatementCacheGetOrPrepareAndEvict(t *testing.T) {
	sqlDB, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("sqlmock new: %v", err)
	}
	defer sqlDB.Close()

	c := newStatementCache(1)
	if c.max != 1 {
		t.Fatalf("expected normalized max=1, got %d", c.max)
	}

	q1 := "SELECT 1"
	mock.ExpectPrepare(regexp.QuoteMeta(q1))
	s1, err := c.GetOrPrepare(context.Background(), sqlDB, q1)
	if err != nil {
		t.Fatalf("prepare q1: %v", err)
	}
	if s1 == nil {
		t.Fatal("expected statement")
	}

	s1b, err := c.GetOrPrepare(context.Background(), sqlDB, q1)
	if err != nil {
		t.Fatalf("get cached q1: %v", err)
	}
	if s1b != s1 {
		t.Fatal("expected same cached statement")
	}

	q2 := "SELECT 2"
	mock.ExpectPrepare(regexp.QuoteMeta(q2))
	_, err = c.GetOrPrepare(nil, sqlDB, q2)
	if err != nil {
		t.Fatalf("prepare q2: %v", err)
	}

	if _, ok := c.items[q1]; ok {
		t.Fatal("expected q1 to be evicted")
	}
	if _, ok := c.items[q2]; !ok {
		t.Fatal("expected q2 in cache")
	}
	if len(c.order) != 1 || c.order[0] != q2 {
		t.Fatalf("unexpected order: %#v", c.order)
	}

	c.Close()
	if len(c.items) != 0 || len(c.order) != 0 {
		t.Fatal("expected empty cache after close")
	}

	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("unmet mock expectations: %v", err)
	}
}

func TestStatementCachePrepareError(t *testing.T) {
	sqlDB, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("sqlmock new: %v", err)
	}
	defer sqlDB.Close()

	c := newStatementCache(8)
	q := "SELECT bad"
	mock.ExpectPrepare(regexp.QuoteMeta(q)).WillReturnError(errors.New("prepare failed"))

	if _, err := c.GetOrPrepare(context.Background(), sqlDB, q); err == nil {
		t.Fatal("expected error")
	}
	if len(c.items) != 0 {
		t.Fatal("cache should remain empty on prepare failure")
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("unmet mock expectations: %v", err)
	}
}