Tests for the path walk; test files named for the modules they exercise

path_test.go

@@ -0,0 +1,138 @@
+package fejkdata
+
+import (
+	"slices"
+	"strings"
+	"testing"
+)
+
+func TestWalkPathStopsAtAMissingSegment(t *testing.T) {
+	n := compiled(t, `{"format":"{a}","a":{"format":"{b}","b":"leaf"}}`)
+	var seen []string
+	walk := pathWalk{
+		level: func(tm *template, rest []string) error { seen = append(seen, "level:"+rest[0]); return nil },
+		leaf:  func(n node) error { seen = append(seen, "leaf"); return nil },
+	}
+	if err := walkPath(n, []string{"a", "b"}, walk); err != nil {
+		t.Fatalf("walkPath(a.b) = %v", err)
+	}
+	if want := []string{"level:a", "level:b", "leaf"}; !slices.Equal(seen, want) {
+		t.Errorf("walk visited %v, want %v", seen, want)
+	}
+	seen = nil
+	err := walkPath(n, []string{"a", "nope", "deeper"}, walk)
+	if err == nil || !strings.Contains(err.Error(), `no field "nope"`) {
+		t.Errorf("walkPath(a.nope.deeper) = %v, want the missing segment named", err)
+	}
+	if slices.Contains(seen, "leaf") {
+		t.Errorf("walk reached a leaf past a missing segment: %v", seen)
+	}
+}
+
+func TestWalkPathChoiceConsumesNoSegment(t *testing.T) {
+	n := compiled(t, `[{"format":"{f}","f":"1"},{"format":"{f}","f":"2"}]`)
+	var leaves []node
+	err := walkPath(n, []string{"f"}, pathWalk{
+		choice: func(c *choice, rest []string) ([]node, error) {
+			if len(rest) != 1 || rest[0] != "f" {
+				t.Errorf("choice saw rest %v, want [f]", rest)
+			}
+			return c.items, nil
+		},
+		leaf: func(n node) error { leaves = append(leaves, n); return nil },
+	})
+	if err != nil || len(leaves) != 2 {
+		t.Fatalf("walkPath through a choice = %v, %d leaves, want both variants' f", err, len(leaves))
+	}
+}
+
+func TestDeepDottedPath(t *testing.T) {
+	// A 5-segment path descends through alternating object/array nodes; choices
+	// on the path are single-variant, so it resolves deterministically.
+	f := engine(1)
+	f.categories = map[string]node{
+		"deep": compiled(t, `{"format":"{a}","a":{"format":"{b}","b":{"format":"{c}","c":{"format":"{d}","d":"leaf"}}}}`),
+	}
+	if got, err := f.Fake("deep.a.b.c.d"); err != nil || got != "leaf" {
+		t.Fatalf("Fake(deep.a.b.c.d) = %q, %v, want leaf", got, err)
+	}
+	// Rendering the whole tree resolves the same chain.
+	if got, err := f.Fake("deep"); err != nil || got != "leaf" {
+		t.Fatalf("Fake(deep) = %q, %v, want leaf", got, err)
+	}
+}
+
+func TestDescendIntoStringErrors(t *testing.T) {
+	f := engine(1)
+	f.categories = map[string]node{"greeting": compiled(t, `"hej"`)}
+	if _, err := f.Fake("greeting.extra"); err == nil || !strings.Contains(err.Error(), `no field "extra"`) {
+		t.Fatalf("Fake(greeting.extra) = %v, want a no-field error", err)
+	}
+}
+
+// TestPathThroughChoice pins the rule that keeps a dotted path from rendering on
+// one call and failing on the next: every variant must carry the rest of the path.
+func TestPathThroughChoice(t *testing.T) {
+	dir := writeData(t, map[string]string{
+		"every":  `[{"format":"{f}","f":"1"},{"format":"{f}","f":"2"}]`,
+		"notall": `[{"format":"{f}","f":"1"},"plain"]`,
+		"some":   `[{"format":"{f}","f":"1"},{"format":"{f}","f":"2","extra":"x"}]`,
+	})
+	f := newGenerator(t, dir, WithSeed(1))
+	for i := 0; i < 200; i++ {
+		if got := fake(t, f, "every.f"); got != "1" && got != "2" {
+			t.Fatalf("every.f = %q, want 1 or 2", got)
+		}
+	}
+	// A path only some variants carry is reported against what all of them carry.
+	if _, err := f.Fake("some.extra"); err == nil || !strings.Contains(err.Error(), "all carry [f]") {
+		t.Errorf("Fake(some.extra) = %v, want it to name what every variant carries", err)
+	}
+	var first string
+	for i := 0; i < 200; i++ {
+		_, err := f.Fake("notall.f")
+		if err == nil {
+			t.Fatal("notall.f = nil error, want the same failure every call")
+		}
+		if i == 0 {
+			first = err.Error()
+		} else if err.Error() != first {
+			t.Fatalf("notall.f error varies between calls:\n  %s\n  %s", first, err.Error())
+		}
+	}
+}
+
+// TestPathKeyIsUnambiguous pins that the one shape which could collide cannot be
+// written: a field literally named "a.b" and a field "a" holding "b" would both
+// spell "a.b", so a dotted field name is rejected at New and a dot means a path
+// wherever it appears.
+func TestPathKeyIsUnambiguous(t *testing.T) {
+	dir := writeData(t, map[string]string{
+		"cat": `[{"format":"{a.b}","a.b":"1"},{"format":"{a}","a":{"format":"{b}","b":"2"}}]`,
+	})
+	_, err := New(WithoutShippedData(), WithDataPath(dir))
+	if err == nil || !strings.Contains(err.Error(), `field "a.b" contains "."`) {
+		t.Fatalf("New = %v, want the dotted field name rejected", err)
+	}
+	// The same data without the dotted key is fine, and the path resolves.
+	f := newGenerator(t, writeData(t, map[string]string{
+		"cat": `{"format":"{a.b}","a":{"format":"{b}","b":"2"}}`,
+	}), WithSeed(1))
+	if !slices.Contains(f.List(), "cat.a.b") {
+		t.Error("List() omits cat.a.b, which the data carries")
+	}
+	if got := fake(t, f, "cat"); got != "2" {
+		t.Fatalf("cat = %q, want 2", got)
+	}
+}
+
+// TestMissingFieldNamesItself keeps the precise diagnosis for the ordinary typo: a
+// single-variant choice always picks the same item, so it needs no every-variant
+// guard and the error can name the field that is missing.
+func TestMissingFieldNamesItself(t *testing.T) {
+	f := newGenerator(t, "data/sv_SE", WithSeed(1))
+	_, err := f.Fake("person.typo")
+	if err == nil || !strings.Contains(err.Error(), `no field "typo"`) {
+		t.Errorf("Fake(person.typo) = %v, want it to name the missing field", err)
+	}
+}