felhom-controller/controller/internal/web/i18n_wiring_test.go

package web

import (
	"fmt"
	"io/fs"
	"net/http"
	"net/http/httptest"
	"net/url"
	"regexp"
	"strings"
	"testing"
	"time"

	"gitea.dooplex.hu/admin/felhom-controller/internal/i18n"
	"gitea.dooplex.hu/admin/felhom-controller/internal/stacks"
)

// ── i18n (v0.247.0) — wiring, keys and context safety ─────────────────────────────────────────────

var i18nScriptRe = regexp.MustCompile(`(?s)<script\b[^>]*>(.*?)</script>`)
var i18nMarkerRe = regexp.MustCompile(`\{\{\s*T\s+"([A-Za-z0-9_.\-]+)"\s*\}\}`)

func templateSources(t *testing.T) map[string]string {
	t.Helper()
	names, err := fs.Glob(templateFS, "templates/*.html")
	if err != nil || len(names) == 0 {
		t.Fatalf("no templates: %v", err)
	}
	out := map[string]string{}
	for _, n := range names {
		b, err := templateFS.ReadFile(n)
		if err != nil {
			t.Fatal(err)
		}
		out[n] = string(b)
	}
	return out
}

// Every key a template or the Go side names exists in Hungarian. (The loader refuses an undefined
// template key too; this test names the key instead of a parse error, and covers the Go-side keys the
// loader never sees.)
func TestBundleKeysUsedExistInHungarian(t *testing.T) {
	b, err := i18n.Shared()
	if err != nil {
		t.Fatal(err)
	}
	used := 0
	for name, src := range templateSources(t) {
		for _, m := range i18nMarkerRe.FindAllStringSubmatch(src, -1) {
			used++
			if !b.Has(i18n.Default, m[1]) {
				t.Errorf("%s: marker key %q is not in hu.json", name, m[1])
			}
		}
	}
	if used < 200 {
		t.Fatalf("only %d markers found — the scan is not reading the converted templates", used)
	}
	goKeys := []string{"page.title.launcher", "page.title.backups", "func.time.now", "func.time.minutes_ago",
		"func.time.hours_ago", "func.time.yesterday", "func.time.days_ago", "func.time.today_at", "func.time.tomorrow_at"}
	for _, st := range []string{"pending", "restoring", "done", "failed", "skipped"} {
		goKeys = append(goKeys, "func.restore_status."+st)
	}
	for _, st := range allContainerStates() {
		goKeys = append(goKeys, stateLabelKey(st))
	}
	for _, k := range goKeys {
		if !b.Has(i18n.Default, k) {
			t.Errorf("Go-side key %q is not in hu.json", k)
		}
	}
}

func allContainerStates() []stacks.ContainerState {
	return []stacks.ContainerState{stacks.StateRunning, stacks.StateStarting, stacks.StateDeploying, stacks.StateUnhealthy,
		stacks.StateDegraded, stacks.StateStopped, stacks.StateExited, stacks.StateRestarting, stacks.StateNotDeployed,
		stacks.StatePaused, stacks.ContainerState("something-new")}
}

// Expansion is textual, so a translation lands in the source exactly where the Hungarian was. Inside a
// JS string literal a bare quote or backslash ends or corrupts the string; inside a double-quoted
// attribute a `"` ends the attribute. Neither is caught by html/template, which sees the expanded text as
// the author's own source. So: a value may carry a quote character only where the Hungarian carries the
// same one (the author already made it safe there).
func TestI18nJSContextValuesAreSafe(t *testing.T) {
	b, err := i18n.Shared()
	if err != nil {
		t.Fatal(err)
	}
	checked := 0
	check := func(where, key string, forbidden string) {
		hu, _, _ := b.Text(i18n.Default, key)
		for _, lang := range i18n.Supported {
			for _, form := range []string{key, key + ".one", key + ".other"} {
				v, fellBack, ok := b.Text(lang, form)
				if !ok || fellBack {
					continue
				}
				checked++
				for _, c := range forbidden {
					if strings.ContainsRune(v, c) && !strings.ContainsRune(hu, c) {
						t.Errorf("%s: %s %q contains %q, which breaks its context", where, lang, form, c)
					}
				}
			}
		}
	}
	for name, src := range templateSources(t) {
		for _, sm := range i18nScriptRe.FindAllStringSubmatch(src, -1) {
			for _, m := range i18nMarkerRe.FindAllStringSubmatch(sm[1], -1) {
				check(name+" <script>", m[1], "'\"\\\n")
			}
		}
		for _, am := range regexp.MustCompile(`=\s*"((?:[^"{]|\{\{[^}]*\}\})*)"`).FindAllStringSubmatch(src, -1) {
			for _, m := range i18nMarkerRe.FindAllStringSubmatch(am[1], -1) {
				check(name+" attribute", m[1], "\"")
			}
		}
	}
	if checked < 50 {
		t.Fatalf("only %d context-sensitive values checked — the scan is not finding the script markers", checked)
	}
}

// The Hungarian bundle carries the same words the Hungarian template funcs return — so English is a
// translation of what a household actually reads, and the bundle can become the funcs' single source
// later without a byte moving.
func TestLocaleFuncsHungarianBundleMatchesFuncMap(t *testing.T) {
	s := i18nTestServer(t)
	b := s.i18n
	fm := s.templateFuncMap()
	stateLabel := fm["stateLabel"].(func(stacks.ContainerState) string)
	for _, st := range allContainerStates() {
		if got, want := b.Msg("hu", stateLabelKey(st)), stateLabel(st); got != want {
			t.Errorf("state %q: hu.json %q, funcmap %q", st, got, want)
		}
	}
	statusText := fm["statusText"].(func(string) string)
	for _, st := range []string{"pending", "restoring", "done", "failed", "skipped"} {
		if got, want := b.Msg("hu", "func.restore_status."+st), statusText(st); got != want {
			t.Errorf("restore status %q: hu.json %q, funcmap %q", st, got, want)
		}
	}
	timeAgo := fm["timeAgo"].(func(time.Time) string)
	now := time.Now()
	for d, key := range map[time.Duration]string{5 * time.Minute: "func.time.minutes_ago", 3 * time.Hour: "func.time.hours_ago", 100 * time.Hour: "func.time.days_ago"} {
		n := map[string]int{"func.time.minutes_ago": 5, "func.time.hours_ago": 3, "func.time.days_ago": 4}[key]
		if got, want := fmt.Sprintf(b.Msg("hu", key), n), timeAgo(now.Add(-d)); got != want {
			t.Errorf("%s: hu.json gives %q, funcmap %q", key, got, want)
		}
	}
	if got, want := b.Msg("hu", "func.time.now"), timeAgo(now); got != want {
		t.Errorf("now: %q vs %q", got, want)
	}
	if got, want := b.Msg("hu", "func.time.yesterday"), timeAgo(now.Add(-30*time.Hour)); got != want {
		t.Errorf("yesterday: %q vs %q", got, want)
	}
	// And the English funcs really are English.
	en := s.localeFuncs("en")
	if got := en["timeAgo"].(func(time.Time) string)(now.Add(-time.Minute - time.Second)); got != "1 minute ago" {
		t.Errorf("en timeAgo(1m) = %q", got)
	}
	if got := en["stateLabel"].(func(stacks.ContainerState) string)(stacks.StateRunning); got != "Running" {
		t.Errorf("en stateLabel(running) = %q", got)
	}
}

func postForm(t *testing.T, s *Server, path string, form url.Values) *httptest.ResponseRecorder {
	t.Helper()
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(form.Encode()))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	s.ServeHTTP(rec, req)
	return rec
}

// THE CONSEQUENCE, through the real handler and router: a Hungarian household sees no switch and no
// English; the ?lang= door shows the switch; saving English makes the real launcher English with its
// title; an unsupported value is refused and changes nothing; switching back hides the switch again.
//
// RED-PROOF (REPORT.md): delete `s.addLanguageData(data, r, lang)` from executeTemplate → the English
// assertions fail (the page stays Hungarian and the switch never appears).
func TestLanguageSwitch_EndToEnd(t *testing.T) {
	s := newDashboardServer(t, time.Time{})

	body := func(path string) string {
		rec := getPage(t, s, path)
		if rec.Code != 200 {
			t.Fatalf("GET %s = %d", path, rec.Code)
		}
		return rec.Body.String()
	}

	hu := body("/launcher")
	if strings.Contains(hu, `action="/settings/language"`) {
		t.Error("a Hungarian household must not see the language switch in this release")
	}
	if !strings.Contains(hu, "<h2>Indítópult</h2>") || !strings.Contains(hu, `<html lang="hu"`) {
		t.Error("default launcher is not Hungarian")
	}

	door := body("/launcher?lang=en")
	if !strings.Contains(door, `action="/settings/language"`) || !strings.Contains(door, "<h2>Launcher</h2>") {
		t.Error("?lang=en must render English and show the switch")
	}
	if s.settings.GetLanguage() != "hu" {
		t.Error("?lang= is a per-request override and must never persist")
	}

	rec := postForm(t, s, "/settings/language", url.Values{"lang": {"en"}, "back": {"/launcher?lang=en"}})
	if rec.Code != http.StatusFound || rec.Header().Get("Location") != "/launcher" {
		t.Fatalf("POST en = %d Location %q, want 302 /launcher (the ?lang= must be dropped)", rec.Code, rec.Header().Get("Location"))
	}
	if s.settings.GetLanguage() != "en" {
		t.Fatalf("language not saved: %q", s.settings.GetLanguage())
	}
	en := body("/launcher")
	for _, want := range []string{"<h2>Launcher</h2>", "<title>Launcher — Felhom.eu</title>", `<html lang="en"`, `action="/settings/language"`, ">Dashboard</a>"} {
		if !strings.Contains(en, want) {
			t.Errorf("saved English: launcher lacks %q", want)
		}
	}
	if strings.Contains(en, "<h2>Indítópult</h2>") {
		t.Error("saved English: launcher heading still Hungarian")
	}

	rec = postForm(t, s, "/settings/language", url.Values{"lang": {"de"}})
	if rec.Code != http.StatusBadRequest || s.settings.GetLanguage() != "en" {
		t.Errorf("unsupported language: code %d, language %q — must be 400 and unchanged", rec.Code, s.settings.GetLanguage())
	}

	postForm(t, s, "/settings/language", url.Values{"lang": {"hu"}, "back": {"//evil.example/"}})
	if s.settings.GetLanguage() != "hu" {
		t.Fatal("switch back to hu not saved")
	}
	if back := body("/launcher"); strings.Contains(back, `action="/settings/language"`) || !strings.Contains(back, "<h2>Indítópult</h2>") {
		t.Error("back on Hungarian: the page must be Hungarian with no switch")
	}
}