thermograph/frontend/server/internal/render/render_test.go

103 lines
3.2 KiB
Go
Raw Normal View History

frontend: rewrite the SSR content service in Go Ports frontend/ (Jinja2/FastAPI, ~1180 LOC) to Go with html/template. No climate math, no DB, no auth here -- every route fetches from the backend's /content/* API, so this is I/O-bound glue with no hard-porting wall; the risk was always in reproducing the rendering exactly, not the language. Verified with a golden-HTML diff, not just unit tests: both the Python original and the Go rewrite were run against the same committed fixtures (frontend/tests/fixtures/) and every one of the 11 routes compared byte-for-byte. The only surviving differences after that process are insignificant inter-tag whitespace and one attribute where Go's stricter escaper HTML-encodes an apostrophe Jinja left literal (functionally identical in every browser) -- confirmed programmatically by normalizing whitespace and unescaping before diffing, not by eyeballing. That process caught defects unit tests alone would have missed, because map[string]any has no compile-time field check: - Render-context keys were snake_case throughout (content.py's Jinja convention, ported verbatim) while the templates -- written independently -- read PascalCase fields. A missing map key doesn't error in html/template, it silently renders empty, so this was invisible in every status code and every "it built" signal: title, meta description, canonical URL, OpenGraph tags, the homepage's entire ranked list, and the brand-tag/nav-active state were all blank across every page. Fixed by renaming every key to match each template's own header comment (the authoritative per-page field contract) and, where an API struct's exported fields already matched what a template needed (contentapi.CityInfo, Crumb, HomeRanked, HubCountry, ...), passing the struct straight through instead of hand-rewrapping it in a map -- removes a whole layer of future drift risk, not just this instance of it. - Three pages 500'd outright: `.ToolHref` needed a fully-composed href string, not the bare "lat,lon" fragment the handlers were building; the all-time-records table needed the raw contentapi.AllTimeRecords struct, not a re-wrapped map. - JSON-LD was being double-encoded: `<script type="application/ld+json">` is JAVASCRIPT context to html/template's contextual escaper regardless of the script's `type` attribute, so a template.HTML-typed value placed there gets re-escaped as a quoted JS string instead of emitted raw -- the entire structured-data payload shipped as a JSON string containing JSON, which no crawler would parse as the intended object. Needed template.JS instead, the type that actually means "trusted JS source." The glossary term page's JSON-LD was simply never built at all (the Jinja original assembled it inline in the template rather than through content.py's context dict, and that got lost in translation) -- added. - html/template silently strips literal HTML comments AND JavaScript comments from the parsed output (verified in isolation, zero template actions involved) -- confirmed as real engine behavior, not a bug in either port, so both need a FuncMap function returning template.HTML / template.JS respectively to survive parsing rather than a literal `<!-- -->` or `//` in the template source. Packaging: multi-stage Go build, final image alpine (not distroless -- the Swarm stack's env-entrypoint.sh shim needs bash), 187MB -> 22.6MB. Two defects caught before they reached a host: - The Swarm stack overrides `entrypoint:` with no `command:`, which drops the image's own CMD entirely (Docker/Swarm semantics, not merged) -- env-entrypoint.sh then fell through to its hardcoded `exec uvicorn app:app` fallback, which doesn't exist in this image. Every deploy would have exited 127. Fixed with an explicit `command:` on the stack's frontend service, and corrected the shim's stale comment claiming CMD passes through automatically. - `COPY --chown=thermograph` resolves the group by NAME at copy time; Alpine's `adduser -S` with no `-G` doesn't create a same-named group, so the classic (non-BuildKit) Docker builder -- which this CI runner falls back to, since it installs plain `docker.io` with no buildx plugin -- failed outright. Fixed with an explicit group and numeric --chown. Verification: go build/vet/test -race clean across all packages; the Docker image builds and passes its embedded go test step under both BuildKit and the classic builder; shellcheck 0 findings on the one script touched; rebased onto current main (the ERA5 lake stack landed on both main and dev during this work -- confirmed additive, no overlap with frontend/daemon).
2026-07-24 00:49:49 +00:00
package render
import (
"html/template"
"net/http/httptest"
"testing"
)
// stubFuncMap satisfies every function name the embedded templates reference
// (see New's doc comment for the full list) with the minimum needed to parse.
// The real implementations live in package content (funcmap.go), which itself
// imports render — so render's own test cannot import content without a
// cycle, and stands up its own stand-in instead. This only proves the
// template set PARSES against the real function names; content_test.go (via
// content.FuncMap) is what proves they render correctly.
func stubFuncMap() template.FuncMap {
return template.FuncMap{
"temp": func(unit, f any) template.HTML { return "" },
"temp_bare": func(unit, f any) template.HTML { return "" },
"temp_class": func(f any) string { return "" },
"ordinal": func(pct any) string { return "" },
"head_verify": func() template.HTML { return "" },
"tojson": func(v any) (template.HTML, error) { return "", nil },
"comment": func(s string) template.HTML { return "" },
"jscomment": func(s string) template.JS { return "" },
}
}
func TestETagFormat(t *testing.T) {
// Same construction as the Python: W/"sha1(body)[:20]".
// sha1("hello") = aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
got := ETag([]byte("hello"))
want := `W/"aaf4c61ddcc5e8a2dabe"`
if got != want {
t.Errorf("ETag = %s, want %s", got, want)
}
}
func TestNotModifiedAnySplitsOnCommas(t *testing.T) {
etag := `W/"abc"`
if !NotModifiedAny(`W/"zzz", W/"abc"`, etag) {
t.Error("comma-separated candidate list should match")
}
if !NotModifiedAny(`W/"abc"`, etag) {
t.Error("single candidate should match")
}
if NotModifiedAny("", etag) {
t.Error("empty header must not match")
}
if NotModifiedAny(`W/"zzz"`, etag) {
t.Error("non-matching header must not match")
}
}
func TestNotModifiedExact(t *testing.T) {
etag := `W/"abc"`
if !NotModifiedExact(`W/"abc"`, etag) {
t.Error("exact match should match")
}
// app.py's _page compared the raw header — a comma list is NOT split there.
if NotModifiedExact(`W/"zzz", W/"abc"`, etag) {
t.Error("exact comparison must not split on commas")
}
}
func TestWriteHTML(t *testing.T) {
body := []byte("<html>x</html>")
etag := ETag(body)
rec := httptest.NewRecorder()
req := httptest.NewRequest("GET", "/", nil)
WriteHTML(rec, req, body)
if rec.Code != 200 || rec.Body.String() != string(body) {
t.Errorf("fresh GET: code=%d body=%q", rec.Code, rec.Body.String())
}
if got := rec.Header().Get("Content-Type"); got != "text/html; charset=utf-8" {
t.Errorf("Content-Type = %q", got)
}
if got := rec.Header().Get("ETag"); got != etag {
t.Errorf("ETag header = %q, want %q", got, etag)
}
rec = httptest.NewRecorder()
req = httptest.NewRequest("GET", "/", nil)
req.Header.Set("If-None-Match", etag)
WriteHTML(rec, req, body)
if rec.Code != 304 {
t.Errorf("conditional GET: code = %d, want 304", rec.Code)
}
if rec.Body.Len() != 0 {
t.Error("304 must have an empty body")
}
if got := rec.Header().Get("ETag"); got != etag {
t.Errorf("304 must still carry the ETag, got %q", got)
}
}
func TestEngineParsesEmbeddedTemplates(t *testing.T) {
if _, err := New(stubFuncMap()); err != nil {
t.Fatalf("New: %v", err)
}
}