scrabble-game/backend/internal/engine/reload_test.go

package engine

import (
	"errors"
	"io"
	"os"
	"path/filepath"
	"testing"
)

// copyDawg copies the committed DAWG for v from srcDir into dstDir (creating
// dstDir). It is the fixture builder for the dictionary-reload tests, which need
// real DAWG files laid out in temporary version directories.
func copyDawg(t *testing.T, srcDir, dstDir string, v Variant) {
	t.Helper()
	if err := os.MkdirAll(dstDir, 0o755); err != nil {
		t.Fatalf("mkdir %s: %v", dstDir, err)
	}
	name := dictFiles[v]
	src, err := os.Open(filepath.Join(srcDir, name))
	if err != nil {
		t.Fatalf("open source dawg %s: %v", name, err)
	}
	defer func() { _ = src.Close() }()
	dst, err := os.Create(filepath.Join(dstDir, name))
	if err != nil {
		t.Fatalf("create dest dawg %s: %v", name, err)
	}
	defer func() { _ = dst.Close() }()
	if _, err := io.Copy(dst, src); err != nil {
		t.Fatalf("copy dawg %s: %v", name, err)
	}
}

// TestLoadAvailableLoadsPresentSkipsAbsent verifies LoadAvailable registers only
// the variants whose DAWG is present in the directory, under the given version.
func TestLoadAvailableLoadsPresentSkipsAbsent(t *testing.T) {
	dir := t.TempDir()
	copyDawg(t, testDictDir(), dir, VariantEnglish) // only English present

	reg := NewRegistry()
	defer func() { _ = reg.Close() }()
	loaded, err := reg.LoadAvailable(dir, "v2")
	if err != nil {
		t.Fatalf("load available: %v", err)
	}
	if len(loaded) != 1 || loaded[0] != VariantEnglish {
		t.Fatalf("loaded = %v, want [english]", loaded)
	}
	if _, err := reg.Solver(VariantEnglish, "v2"); err != nil {
		t.Errorf("english v2 solver: %v", err)
	}
	if _, err := reg.Solver(VariantRussianScrabble, "v2"); !errors.Is(err, ErrUnknownVariant) {
		t.Errorf("russian v2 should be absent: got %v", err)
	}
}

// TestOpenWithVersionsScansSubdirs verifies the boot helper loads the flat boot
// version plus every version subdirectory, the subdir version becoming the
// variant's latest while the boot version stays resident.
func TestOpenWithVersionsScansSubdirs(t *testing.T) {
	dir := t.TempDir()
	for _, v := range Variants() { // flat boot version: all three variants
		copyDawg(t, testDictDir(), dir, v)
	}
	copyDawg(t, testDictDir(), filepath.Join(dir, "v2"), VariantEnglish) // v2 subdir: English only

	reg, err := OpenWithVersions(dir, "v1")
	if err != nil {
		t.Fatalf("open with versions: %v", err)
	}
	defer func() { _ = reg.Close() }()

	for _, v := range Variants() {
		if _, err := reg.Solver(v, "v1"); err != nil {
			t.Errorf("boot solver %s/v1: %v", v, err)
		}
	}
	if got := reg.Versions(VariantEnglish); len(got) != 2 {
		t.Errorf("english versions = %v, want two", got)
	}
	latest, _, err := reg.Latest(VariantEnglish)
	if err != nil {
		t.Fatalf("latest english: %v", err)
	}
	if latest != "v2" {
		t.Errorf("latest english = %q, want v2", latest)
	}
	if got := reg.Versions(VariantRussianScrabble); len(got) != 1 {
		t.Errorf("russian versions = %v, want one (no v2 file)", got)
	}
}

// TestReloadRegistersNewVersion verifies Load adds a second version to a variant
// already resident, moves the latest pointer and keeps the earlier version.
func TestReloadRegistersNewVersion(t *testing.T) {
	reg, err := Open(testDictDir(), "v1", VariantEnglish)
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer func() { _ = reg.Close() }()

	if err := reg.Load(VariantEnglish, "v2", testDictDir()); err != nil {
		t.Fatalf("reload v2: %v", err)
	}
	if got := reg.Versions(VariantEnglish); len(got) != 2 {
		t.Fatalf("versions = %v, want two", got)
	}
	latest, _, err := reg.Latest(VariantEnglish)
	if err != nil {
		t.Fatalf("latest: %v", err)
	}
	if latest != "v2" {
		t.Errorf("latest = %q, want v2", latest)
	}
	if _, err := reg.Solver(VariantEnglish, "v1"); err != nil {
		t.Errorf("v1 still resident: %v", err)
	}
}