initial commit

internal/tokenengine/tokens_test.go

@@ -0,0 +1,251 @@
+package tokenengine
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/urpi/go-bananas/internal/domain"
+)
+
+// testTheme builds a minimal but complete theme for engine tests.
+func testTheme() *domain.Theme {
+	return &domain.Theme{
+		Slug:              "acme",
+		Name:              "Acme",
+		Status:            domain.StatusPublished,
+		DefaultAppearance: domain.AppearanceLight,
+		Version:           3,
+		Tokens: domain.TokenDoc{
+			"color": map[string]any{
+				"palette": map[string]any{
+					"brand": map[string]any{
+						"500": map[string]any{TypeKey: string(KindColor), ValueKey: "#4f46e5"},
+						"600": map[string]any{TypeKey: string(KindColor), ValueKey: "#4338ca"},
+					},
+				},
+				"semantic": map[string]any{
+					"background": map[string]any{TypeKey: string(KindColor), ValueKey: "#ffffff"},
+					"surface":    map[string]any{TypeKey: string(KindColor), ValueKey: "#f8fafc"},
+					"text":       map[string]any{TypeKey: string(KindColor), ValueKey: "#0f172a"},
+					"primary":    map[string]any{TypeKey: string(KindColor), ValueKey: "#4f46e5"},
+				},
+			},
+			"font": map[string]any{
+				"family": map[string]any{
+					"sans": map[string]any{TypeKey: string(KindFamilyAlias()), ValueKey: "Inter, sans-serif"},
+				},
+			},
+			"space": map[string]any{
+				"4": map[string]any{TypeKey: string(KindDimension), ValueKey: 1},
+			},
+		},
+	}
+}
+
+// KindFamilyAlias exists only so the fixture reads clearly; it resolves to the
+// canonical font-family kind.
+func KindFamilyAlias() Kind { return KindFontFamily }
+
+func TestResolveFlattensNestedTokens(t *testing.T) {
+	doc := Resolve(testTheme(), domain.AppearanceLight)
+
+	if got, ok := doc.Lookup("color.semantic.background"); !ok {
+		t.Fatalf("expected color.semantic.background to resolve, got %d tokens", len(doc.Tokens))
+	} else if got.CSS != "#ffffff" {
+		t.Errorf("background = %q, want #ffffff", got.CSS)
+	}
+
+	space, ok := doc.Lookup("space.4")
+	if !ok {
+		t.Fatal("expected space.4 to resolve")
+	}
+	// A bare number in a dimension group must pick up the px suffix.
+	if space.CSS != "1px" {
+		t.Errorf("space.4 = %q, want 1px", space.CSS)
+	}
+}
+
+func TestResolveIsDeterministic(t *testing.T) {
+	first := Resolve(testTheme(), domain.AppearanceLight)
+	second := Resolve(testTheme(), domain.AppearanceLight)
+
+	if len(first.Tokens) != len(second.Tokens) {
+		t.Fatalf("token count differs: %d vs %d", len(first.Tokens), len(second.Tokens))
+	}
+	for i := range first.Tokens {
+		if first.Tokens[i].Path != second.Tokens[i].Path {
+			t.Fatalf("token %d out of order: %q vs %q", i, first.Tokens[i].Path, second.Tokens[i].Path)
+		}
+	}
+}
+
+func TestAppearanceOverridesWinOverBase(t *testing.T) {
+	theme := testTheme()
+	theme.Tokens[AppearancesKey] = map[string]any{
+		"dark": map[string]any{
+			"color": map[string]any{
+				"semantic": map[string]any{
+					"background": map[string]any{TypeKey: string(KindColor), ValueKey: "#0b1220"},
+				},
+			},
+		},
+	}
+
+	light := Resolve(theme, domain.AppearanceLight)
+	dark := Resolve(theme, domain.AppearanceDark)
+
+	if got, _ := light.Lookup("color.semantic.background"); got.CSS != "#ffffff" {
+		t.Errorf("light background = %q, want the base value #ffffff", got.CSS)
+	}
+	if got, _ := dark.Lookup("color.semantic.background"); got.CSS != "#0b1220" {
+		t.Errorf("dark background = %q, want the override #0b1220", got.CSS)
+	}
+	// Tokens not overridden must fall through to the base value.
+	if got, _ := dark.Lookup("color.semantic.primary"); got.CSS != "#4f46e5" {
+		t.Errorf("dark primary = %q, want the base value #4f46e5", got.CSS)
+	}
+}
+
+func TestRenderEmitsScopedSelectorsAndDerivedTokens(t *testing.T) {
+	css := Render(testTheme(), RenderOptions{
+		Slug:       "acme",
+		Appearance: domain.AppearanceLight,
+		Derive:     DefaultDerive(),
+		Components: true,
+	})
+
+	for _, want := range []string{
+		`[data-bananas-theme="acme"]`,
+		`[data-bananas-theme="acme"][data-bananas-appearance=dark]`,
+		"--bn-color-semantic-background: #ffffff;",
+		// Derived foreground must pick white on a dark primary.
+		"--bn-color-on-semantic-primary: #ffffff;",
+		"--bn-color-semantic-primary-hover:",
+		"--bn-space-4: 1px;",
+		"@layer bananas",
+		".bn-btn",
+		`.dark [data-bananas-theme="acme"]`,
+	} {
+		if !strings.Contains(css, want) {
+			t.Errorf("rendered CSS missing %q\n---\n%s", want, css)
+		}
+	}
+}
+
+func TestRenderMinifiedOmitsCommentsAndWhitespace(t *testing.T) {
+	css := Render(testTheme(), RenderOptions{Slug: "acme", Minify: true, Derive: DefaultDerive()})
+
+	if strings.Contains(css, "/*") {
+		t.Error("minified CSS must not contain comments")
+	}
+	if strings.Contains(css, "\n\n") {
+		t.Error("minified CSS must not contain blank lines")
+	}
+}
+
+func TestValidateAcceptsACompleteTheme(t *testing.T) {
+	result := Validate(testTheme().Tokens)
+	for _, issue := range result.Errors() {
+		// The fixture is intentionally sparse; it must only trip the "unknown
+		// group" rule if the schema drifted, never on the tokens it defines.
+		if strings.Contains(issue.Message, "unknown token group") {
+			t.Errorf("unexpected schema error: %+v", issue)
+		}
+	}
+	if result.TokenCount != 8 {
+		t.Errorf("TokenCount = %d, want 8", result.TokenCount)
+	}
+}
+
+func TestValidateRejectsMalformedColour(t *testing.T) {
+	doc := testTheme().Tokens
+	doc["color"].(map[string]any)["semantic"].(map[string]any)["primary"] = map[string]any{
+		TypeKey: string(KindColor), ValueKey: "#nothex",
+	}
+
+	result := Validate(doc)
+	if result.Valid {
+		t.Fatal("expected validation to fail on a malformed colour")
+	}
+	found := false
+	for _, issue := range result.Issues {
+		if issue.Path == "color.semantic.primary" {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("expected an issue on color.semantic.primary, got %+v", result.Issues)
+	}
+}
+
+func TestValidateRejectsUnknownGroup(t *testing.T) {
+	doc := testTheme().Tokens
+	doc["colour"] = map[string]any{"typo": map[string]any{ValueKey: "#fff"}}
+
+	result := Validate(doc)
+	if result.Valid {
+		t.Fatal("expected validation to reject an unknown top-level group")
+	}
+}
+
+func TestVariableNameNormalisation(t *testing.T) {
+	cases := map[string]string{
+		"color.semantic.background": "--bn-color-semantic-background",
+		"space.4":                   "--bn-space-4",
+		"font.lineHeight.tight":     "--bn-font-line-height-tight",
+		"font.line height":          "--bn-font-line-height",
+		"weird.Name_Here":           "--bn-weird-name-here",
+	}
+	for path, want := range cases {
+		if got := VariableName(path); got != want {
+			t.Errorf("VariableName(%q) = %q, want %q", path, got, want)
+		}
+	}
+}
+
+func TestSetAndDeleteToken(t *testing.T) {
+	doc := testTheme().Tokens
+
+	if err := SetIn(doc, "space.6", 1.5, KindDimension, ""); err != nil {
+		t.Fatalf("SetIn: %v", err)
+	}
+	if got, err := LookupIn(doc, "space.6"); err != nil {
+		t.Fatalf("LookupIn: %v", err)
+	} else if got[ValueKey] != 1.5 {
+		t.Errorf("space.6 = %v, want 1.5", got[ValueKey])
+	}
+
+	deleted, err := DeleteIn(doc, "space.6")
+	if err != nil || !deleted {
+		t.Fatalf("DeleteIn = %v, %v; want true, nil", deleted, err)
+	}
+	if _, err := LookupIn(doc, "space.6"); err == nil {
+		t.Error("token should be gone after DeleteIn")
+	}
+}
+
+func TestSetInRejectsUnknownGroup(t *testing.T) {
+	doc := domain.TokenDoc{}
+	err := SetIn(doc, "colour.typo", "#fff", KindColor, "")
+	if err == nil {
+		t.Fatal("expected SetIn to reject an unknown group")
+	}
+}
+
+func TestJSONPayloadCarriesFlatAndNestedForms(t *testing.T) {
+	payload := JSONPayload(testTheme(), domain.AppearanceDark)
+
+	if payload.Theme.Slug != "acme" {
+		t.Errorf("slug = %q, want acme", payload.Theme.Slug)
+	}
+	if payload.Variable["--bn-color-semantic-primary"] != "#4f46e5" {
+		t.Errorf("flat map missing primary: %v", payload.Variable)
+	}
+	semantic, ok := payload.Tokens["color"].(map[string]any)
+	if !ok {
+		t.Fatal("nested tokens missing the color group")
+	}
+	if _, ok := semantic["semantic"]; !ok {
+		t.Error("nested tokens missing the semantic group")
+	}
+}