refac: missing mutation tests, spa specs, checks shown to pass, touch targets, catalogue entry, production code

test/localization_rules_test.go

@@ -0,0 +1,125 @@
+package test
+
+import (
+	"RenewCMS/internal/domain/localization"
+	"errors"
+	"testing"
+)
+
+func socialLocale(value string) *string {
+	return &value
+}
+
+func TestLocalizationRowEquality(t *testing.T) {
+	base := localization.Row{Tag: "fr", IsDefault: true, Enabled: true, Confirmed: true, SocialLocale: socialLocale("fr_FR")}
+	differing := map[string]localization.Row{
+		"tag":                {Tag: "de", IsDefault: true, Enabled: true, Confirmed: true, SocialLocale: socialLocale("fr_FR")},
+		"default":            {Tag: "fr", IsDefault: false, Enabled: true, Confirmed: true, SocialLocale: socialLocale("fr_FR")},
+		"enabled":            {Tag: "fr", IsDefault: true, Enabled: false, Confirmed: true, SocialLocale: socialLocale("fr_FR")},
+		"confirmed":          {Tag: "fr", IsDefault: true, Enabled: true, Confirmed: false, SocialLocale: socialLocale("fr_FR")},
+		"social locale":      {Tag: "fr", IsDefault: true, Enabled: true, Confirmed: true, SocialLocale: socialLocale("fr_CA")},
+		"missing social":     {Tag: "fr", IsDefault: true, Enabled: true, Confirmed: true},
+		"same row":           base,
+		"same social copied": {Tag: "fr", IsDefault: true, Enabled: true, Confirmed: true, SocialLocale: socialLocale("fr_FR")},
+	}
+	for name, other := range differing {
+		t.Run(name, func(t *testing.T) {
+			want := name == "same row" || name == "same social copied"
+			if base.Equal(other) != want || other.Equal(base) != want {
+				t.Fatalf("Equal = %v, want %v", base.Equal(other), want)
+			}
+		})
+	}
+	t.Run("two rows without a social locale are equal", func(t *testing.T) {
+		plain := localization.Row{Tag: "en", Enabled: true}
+		if !plain.Equal(localization.Row{Tag: "en", Enabled: true}) {
+			t.Fatal("rows without social locale differ")
+		}
+	})
+}
+
+func TestLocalizationRevisionTracksEveryField(t *testing.T) {
+	rows := []localization.Row{{Tag: "en", IsDefault: true, Enabled: true}, {Tag: "fr", Enabled: true, SocialLocale: socialLocale("fr_FR")}}
+	changed := [][]localization.Row{
+		{{Tag: "en", IsDefault: false, Enabled: true}, {Tag: "fr", IsDefault: true, Enabled: true, SocialLocale: socialLocale("fr_FR")}},
+		{{Tag: "en", IsDefault: true, Enabled: true}, {Tag: "fr", Enabled: false, SocialLocale: socialLocale("fr_FR")}},
+		{{Tag: "en", IsDefault: true, Enabled: true}, {Tag: "fr", Enabled: true}},
+	}
+	for _, other := range changed {
+		if localization.SameRows(rows, other) {
+			t.Errorf("%+v has the revision of %+v", other, rows)
+		}
+	}
+	reordered := []localization.Row{rows[1], rows[0]}
+	if !localization.SameRows(rows, reordered) {
+		t.Error("the order of the rows changed the revision")
+	}
+}
+
+func TestLocalizationSocialLocaleState(t *testing.T) {
+	cases := []struct {
+		name       string
+		row        localization.Row
+		siteLocale *string
+		want       string
+	}{
+		{"an explicit social locale is set", localization.Row{Tag: "fr", SocialLocale: socialLocale("fr_FR")}, nil, localization.SocialLocaleSet},
+		{"a regional tag derives one", localization.Row{Tag: "fr-CA"}, nil, localization.SocialLocaleDerived},
+		{"the site locale lends one", localization.Row{Tag: "fr"}, socialLocale("fr-BE"), localization.SocialLocaleDerived},
+		{"nothing to derive from", localization.Row{Tag: "fr"}, socialLocale("de-DE"), localization.SocialLocaleNotSet},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := localization.SocialLocaleState(c.row, c.siteLocale); got != c.want {
+				t.Fatalf("state = %q, want %q", got, c.want)
+			}
+		})
+	}
+}
+
+func TestLocalizationPlanKeepsLanguagesInUse(t *testing.T) {
+	current := []localization.Row{{Tag: "en", IsDefault: true, Enabled: true, Confirmed: true}, {Tag: "fr", Enabled: true}}
+	keepEnglishOnly := localization.Change{Default: "en", Languages: []localization.Entry{{Tag: "en", Enabled: true}}}
+	cases := []struct {
+		name   string
+		counts map[string]localization.VersionCount
+		want   error
+	}{
+		{"a removed language with live versions is refused", map[string]localization.VersionCount{"fr": {Total: 1}}, localization.ErrLanguageInUse},
+		{"a removed language with only trashed versions is refused", map[string]localization.VersionCount{"fr": {Trashed: 1}}, localization.ErrLanguageInUse},
+		{"a removed language without versions is dropped", map[string]localization.VersionCount{"en": {Total: 4}}, nil},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			rows, err := localization.Plan(current, c.counts, keepEnglishOnly)
+			if !errors.Is(err, c.want) {
+				t.Fatalf("err = %v, want %v", err, c.want)
+			}
+			if c.want == nil && (len(rows) != 1 || rows[0].Tag != "en" || !rows[0].IsDefault) {
+				t.Fatalf("rows = %+v", rows)
+			}
+		})
+	}
+	t.Run("a kept language with versions stays", func(t *testing.T) {
+		keepBoth := localization.Change{Default: "en", Languages: []localization.Entry{{Tag: "en", Enabled: true}, {Tag: "fr", Enabled: false}}}
+		rows, err := localization.Plan(current, map[string]localization.VersionCount{"fr": {Total: 2}}, keepBoth)
+		if err != nil || len(rows) != 2 {
+			t.Fatalf("rows = %+v, err = %v", rows, err)
+		}
+	})
+}
+
+func TestLocalizationRowLookups(t *testing.T) {
+	rows := []localization.Row{{Tag: "en", IsDefault: true, Enabled: true}, {Tag: "fr", Enabled: false}}
+	t.Run("HasRow finds a disabled row and nothing else", func(t *testing.T) {
+		if !localization.HasRow(rows, "fr") || !localization.HasRow(rows, "en") || localization.HasRow(rows, "de") {
+			t.Fatal("HasRow answered wrongly")
+		}
+	})
+	t.Run("MissingTags lists each tag that is not enabled once, sorted, never the unassigned tag", func(t *testing.T) {
+		missing := localization.MissingTags(rows, []string{"fr", "", "de", "en", "fr"})
+		if len(missing) != 2 || missing[0] != "de" || missing[1] != "fr" {
+			t.Fatalf("missing = %v", missing)
+		}
+	})
+}