summercms/modules/cabana/account_preferences_internal_test.go

package cabana

import (
	"context"
	"encoding/json"
	"testing"
	"testing/fstest"

	"git.golem15.com/golem15/summercms/modules/phrasebook"
)

// preferencesTranslator has admin strings in en and pl, and a non-admin key
// in de, so Locales(adminLangPrefix) is en and pl.
func preferencesTranslator(t *testing.T) *phrasebook.Translator {
	t.Helper()
	cat := phrasebook.NewCatalog()
	if err := cat.Load("backend", fstest.MapFS{
		"lang/en/lang.yaml":  {Data: []byte("nav:\n  settings: Settings\n")},
		"lang/pl/lang.yaml":  {Data: []byte("nav:\n  settings: Ustawienia\n")},
		"lang/de/other.yaml": {Data: []byte("nav: Navigation\n")},
	}); err != nil {
		t.Fatal(err)
	}
	return phrasebook.NewTranslator(cat, phrasebook.Options{Locale: "en", Fallback: "en"})
}

func TestPreferencesOf(t *testing.T) {
	tr := preferencesTranslator(t)
	cases := []struct {
		name     string
		metadata *string
		want     AdminPreferences
	}{
		{"null metadata", nil, AdminPreferences{Theme: "system"}},
		{"empty array", strPtr("[]"), AdminPreferences{Theme: "system"}},
		{"malformed", strPtr("{not json"), AdminPreferences{Theme: "system"}},
		{"not an object", strPtr(`"text"`), AdminPreferences{Theme: "system"}},
		{"stored values", strPtr(`{"admin_theme":"dark","admin_locale":"pl"}`), AdminPreferences{Theme: "dark", Locale: "pl"}},
		{"light", strPtr(`{"admin_theme":"light"}`), AdminPreferences{Theme: "light"}},
		{"invalid theme", strPtr(`{"admin_theme":"blue"}`), AdminPreferences{Theme: "system"}},
		{"non-string theme", strPtr(`{"admin_theme":1}`), AdminPreferences{Theme: "system"}},
		{"unsupported locale", strPtr(`{"admin_locale":"de"}`), AdminPreferences{Theme: "system"}},
		{"unknown locale", strPtr(`{"admin_locale":"xx"}`), AdminPreferences{Theme: "system"}},
	}
	for _, tc := range cases {
		if got := preferencesOf(BackendUser{Metadata: tc.metadata}, tr); got != tc.want {
			t.Errorf("%s: preferencesOf = %+v, want %+v", tc.name, got, tc.want)
		}
	}
	// Without a translator no locale is supported.
	if got := preferencesOf(BackendUser{Metadata: strPtr(`{"admin_locale":"pl"}`)}, nil); got.Locale != "" {
		t.Errorf("nil translator locale = %q", got.Locale)
	}
}

func TestValidPreferences(t *testing.T) {
	tr := preferencesTranslator(t)
	ctx := context.Background()
	updates, details := validPreferences(ctx, tr, map[string]any{"theme": "dark", "locale": "pl"})
	if len(details) != 0 || updates[metadataAdminTheme] != "dark" || updates[metadataAdminLocale] != "pl" {
		t.Fatalf("valid: updates=%v details=%v", updates, details)
	}
	updates, details = validPreferences(ctx, tr, map[string]any{"theme": "system", "locale": ""})
	if len(details) != 0 || len(updates) != 2 || updates[metadataAdminTheme] != "" || updates[metadataAdminLocale] != "" {
		t.Fatalf("defaults: updates=%v details=%v", updates, details)
	}
	updates, details = validPreferences(ctx, tr, map[string]any{})
	if len(details) != 0 || len(updates) != 0 {
		t.Fatalf("empty body: updates=%v details=%v", updates, details)
	}
	for name, body := range map[string]map[string]any{
		"theme blue":    {"theme": "blue"},
		"theme number":  {"theme": json.Number("1")},
		"theme null":    {"theme": nil},
		"locale xx":     {"locale": "xx"},
		"locale de":     {"locale": "de"},
		"locale number": {"locale": json.Number("1")},
		"locale bool":   {"locale": true},
	} {
		_, details := validPreferences(ctx, tr, body)
		for key := range body {
			if _, ok := details[key]; !ok {
				t.Errorf("%s: no detail on %s (%v)", name, key, details)
			}
		}
	}
	if details := refusedPreferenceKeys(ctx, tr, map[string]any{"theme": "dark", "id": 1, "backend_user_id": 2, "is_superuser": true}); len(details) != 3 || details["theme"] != nil {
		t.Fatalf("refused keys = %v", details)
	}
}

func TestPreferenceMetadataWrites(t *testing.T) {
	stored := strPtr(`{"subtitle":"Rear admiral","winter_key":{"a":1}}`)
	out, err := setMetadataString(stored, metadataAdminTheme, "dark")
	if err != nil {
		t.Fatal(err)
	}
	out, err = setMetadataString(out, metadataAdminLocale, "pl")
	if err != nil {
		t.Fatal(err)
	}
	var values map[string]json.RawMessage
	if err := json.Unmarshal([]byte(*out), &values); err != nil {
		t.Fatal(err)
	}
	if string(values["subtitle"]) != `"Rear admiral"` || string(values["winter_key"]) != `{"a":1}` || string(values["admin_theme"]) != `"dark"` || string(values["admin_locale"]) != `"pl"` {
		t.Fatalf("metadata = %s", *out)
	}

	// The defaults remove their keys; metadata without keys is NULL.
	out, err = setMetadataString(strPtr(`{"admin_theme":"dark","admin_locale":"pl"}`), metadataAdminTheme, "")
	if err != nil {
		t.Fatal(err)
	}
	out, err = setMetadataString(out, metadataAdminLocale, "")
	if err != nil || out != nil {
		t.Fatalf("cleared metadata = %v, %v; want nil", out, err)
	}

	// Metadata that is not a JSON object is refused, never overwritten.
	if _, err := setMetadataString(strPtr(`"legacy text"`), metadataAdminTheme, "dark"); err != errMetadataNotObject {
		t.Fatalf("non-object metadata err = %v", err)
	}

	if !sameMetadata(nil, nil) || sameMetadata(nil, strPtr("{}")) || !sameMetadata(strPtr("{}"), strPtr("{}")) {
		t.Fatal("sameMetadata")
	}
}

func TestPrincipalFromPreferredLocale(t *testing.T) {
	if p := principalFrom(BackendUser{ID: 1, Metadata: strPtr(`{"admin_locale":"pl","subtitle":"x"}`)}); p.PreferredLocale != "pl" {
		t.Fatalf("PreferredLocale = %q, want pl", p.PreferredLocale)
	}
	for _, metadata := range []*string{nil, strPtr(`{"subtitle":"x"}`), strPtr("[]"), strPtr("{bad")} {
		if p := principalFrom(BackendUser{ID: 1, Metadata: metadata}); p.PreferredLocale != "" {
			t.Fatalf("PreferredLocale = %q for %v, want empty", p.PreferredLocale, metadata)
		}
	}
}