120 lines
3.7 KiB
Go
120 lines
3.7 KiB
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)
|
|
}
|
|
}
|