error_registry_test.go

package restapi

import (
	"errors"
	"net/http"
	"sync"
	"testing"
)

func mustRegistry(t testing.TB) *ErrorRegistry {
	t.Helper()
	fb := ErrorRegistryEntry{StatusCode: http.StatusInternalServerError, ErrorCode: CodeInternal, Message: "fallback"}
	r, err := NewErrorRegistry(fb)
	if err != nil {
		t.Fatalf("NewErrorRegistry: %v", err)
	}
	return r
}

func TestNewErrorRegistry_WithInitialEntries(t *testing.T) {
	t.Parallel()

	fb := ErrorRegistryEntry{StatusCode: 500, ErrorCode: CodeInternal, Message: "fb"}
	e := ErrorRegistryEntry{StatusCode: 400, ErrorCode: CodeBadRequest, Message: "bad"}
	r, err := NewErrorRegistry(fb, e)
	if err != nil {
		t.Fatalf("NewErrorRegistry: %v", err)
	}
	if !r.IsRegistered(CodeBadRequest) {
		t.Fatal("initial entry not registered")
	}
}

func TestNewErrorRegistry_DuplicateInInitialEntries(t *testing.T) {
	t.Parallel()

	fb := ErrorRegistryEntry{ErrorCode: CodeInternal}
	dup := ErrorRegistryEntry{ErrorCode: CodeBadRequest}
	_, err := NewErrorRegistry(fb, dup, dup)
	if !errors.Is(err, ErrCodeAlreadyRegistered) {
		t.Fatalf("got %v; want ErrCodeAlreadyRegistered", err)
	}
}

func TestNewErrorRegistry_FallbackCollisionInInitialEntries(t *testing.T) {
	t.Parallel()

	fb := ErrorRegistryEntry{ErrorCode: CodeInternal}
	collide := ErrorRegistryEntry{ErrorCode: CodeInternal}
	_, err := NewErrorRegistry(fb, collide)
	if !errors.Is(err, ErrFallbackErrorCodeRegistration) {
		t.Fatalf("got %v; want ErrFallbackErrorCodeRegistration", err)
	}
}

func TestRegistry_Register_EmptyBatch(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	if err := r.Register(); err != nil {
		t.Fatalf("empty Register must succeed; got %v", err)
	}
}

func TestRegistry_Register_DuplicateAgainstExisting(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	entry := ErrorRegistryEntry{ErrorCode: CodeBadRequest}
	if err := r.Register(entry); err != nil {
		t.Fatalf("first Register: %v", err)
	}
	err := r.Register(entry)
	if !errors.Is(err, ErrCodeAlreadyRegistered) {
		t.Fatalf("got %v; want ErrCodeAlreadyRegistered", err)
	}
}

func TestRegistry_Register_DuplicateWithinBatch(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	e := ErrorRegistryEntry{ErrorCode: CodeBadRequest}
	err := r.Register(e, e)
	if !errors.Is(err, ErrCodeAlreadyRegistered) {
		t.Fatalf("got %v; want ErrCodeAlreadyRegistered", err)
	}
	if r.IsRegistered(CodeBadRequest) {
		t.Fatal("atomicity violated: first entry of failing batch was persisted")
	}
}

func TestRegistry_Register_FallbackCollision(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	err := r.Register(ErrorRegistryEntry{ErrorCode: CodeInternal})
	if !errors.Is(err, ErrFallbackErrorCodeRegistration) {
		t.Fatalf("got %v; want ErrFallbackErrorCodeRegistration", err)
	}
}

func TestRegistry_Register_Atomicity(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	prior := ErrorRegistryEntry{ErrorCode: CodeNotFound, StatusCode: 404, Message: "nf"}
	if err := r.Register(prior); err != nil {
		t.Fatalf("prior: %v", err)
	}
	good := ErrorRegistryEntry{ErrorCode: CodeBadRequest, StatusCode: 400}
	bad := prior // duplicate
	err := r.Register(good, bad)
	if !errors.Is(err, ErrCodeAlreadyRegistered) {
		t.Fatalf("got %v; want ErrCodeAlreadyRegistered", err)
	}
	if r.IsRegistered(CodeBadRequest) {
		t.Fatal("atomicity violated: 'good' entry was persisted despite batch failure")
	}
}

func TestRegistry_Lookup_HitAndMiss(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	e := ErrorRegistryEntry{ErrorCode: CodeBadRequest, StatusCode: 400, Message: "bad"}
	if err := r.Register(e); err != nil {
		t.Fatalf("Register: %v", err)
	}

	hit, ok := r.Lookup(CodeBadRequest)
	if !ok || hit != e {
		t.Fatalf("Lookup hit: got %+v, ok=%v", hit, ok)
	}

	miss, ok := r.Lookup(99999)
	if ok {
		t.Fatal("Lookup miss returned ok=true")
	}
	if miss != r.Fallback() {
		t.Fatalf("Lookup miss = %+v; want fallback %+v", miss, r.Fallback())
	}
}

func TestRegistry_MustLookup_Miss(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	_, err := r.MustLookup(12345)
	if !errors.Is(err, ErrUnknownErrorCode) {
		t.Fatalf("got %v; want ErrUnknownErrorCode", err)
	}
}

func TestRegistry_MustLookup_Hit(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	e := ErrorRegistryEntry{ErrorCode: CodeBadRequest}
	if err := r.Register(e); err != nil {
		t.Fatalf("Register: %v", err)
	}
	got, err := r.MustLookup(CodeBadRequest)
	if err != nil || got != e {
		t.Fatalf("MustLookup: %+v, %v", got, err)
	}
}

func TestRegistry_MustRegister_Panic(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	defer func() {
		if recover() == nil {
			t.Fatal("MustRegister on fallback collision must panic")
		}
	}()
	r.MustRegister(ErrorRegistryEntry{ErrorCode: CodeInternal})
}

func TestRegistry_Concurrency(t *testing.T) {
	t.Parallel()

	r := mustRegistry(t)
	const workers = 100
	var wg sync.WaitGroup
	wg.Add(workers * 2)

	for i := 0; i < workers; i++ {
		go func(code int) {
			defer wg.Done()
			_ = r.Register(ErrorRegistryEntry{ErrorCode: code, StatusCode: 400, Message: "x"})
		}(2000 + i)
	}
	for i := 0; i < workers; i++ {
		go func(code int) {
			defer wg.Done()
			_, _ = r.Lookup(code)
		}(2000 + i)
	}
	wg.Wait()

	// Every distinct code must be registered exactly once.
	for i := 0; i < workers; i++ {
		if !r.IsRegistered(2000 + i) {
			t.Fatalf("code %d not registered after concurrent Register", 2000+i)
		}
	}
}

func TestRegistry_Fallback(t *testing.T) {
	t.Parallel()

	fb := ErrorRegistryEntry{StatusCode: 418, ErrorCode: 777, Message: "teapot"}
	r, err := NewErrorRegistry(fb)
	if err != nil {
		t.Fatalf("NewErrorRegistry: %v", err)
	}
	if got := r.Fallback(); got != fb {
		t.Fatalf("Fallback() = %+v; want %+v", got, fb)
	}
}