Ilia Denisov
020742fad3
CI / changes (pull_request) Successful in 2s
CI / unit (pull_request) Successful in 10s
CI / integration (pull_request) Successful in 18s
CI / ui (pull_request) Successful in 1m10s
CI / conformance (pull_request) Successful in 9s
CI / gate (pull_request) Successful in 0s
CI / deploy (pull_request) Successful in 1m43s
The C1 service worker served the precached shell for every navigation, even online, so a new deploy only reached a client after the worker updated its precache in the background (a one-launch lag): a cold online start showed the old version until then, and only a reinstall forced it fresh. - sw.ts: navigations are now network-first — fetch the fresh (no-cache) shell from the server on each online launch (it references the new hashed assets, fetched fresh), with a 3s timeout falling back to the precached shell when the network is unreachable or too slow. Only the tiny HTML is re-fetched; the immutable hashed assets stay cache-first and re-download only when their hash (the version) changes. Offline cold-launch still works via the fallback. - webui.go: serve sw.js with Cache-Control: no-cache so the browser reliably detects a new deploy's worker (regression-tested). Online launch is contour-verified (the mock e2e disables the SW); e2e 196. No new deps — the network-first handler is hand-written (~12 lines).
116 lines
4.8 KiB
Go
116 lines
4.8 KiB
Go
package webui
|
|
|
|
import (
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"testing/fstest"
|
|
)
|
|
|
|
// get drives the handler with a GET for the given path and returns the response.
|
|
func get(t *testing.T, h http.Handler, target string) *http.Response {
|
|
t.Helper()
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, target, nil))
|
|
return rec.Result()
|
|
}
|
|
|
|
func body(t *testing.T, resp *http.Response) string {
|
|
t.Helper()
|
|
b, _ := io.ReadAll(resp.Body)
|
|
return string(b)
|
|
}
|
|
|
|
// TestShellNoCache: the served HTML shell carries no-cache so a new deploy's
|
|
// shell (and the asset URLs it references) is fetched fresh.
|
|
func TestShellNoCache(t *testing.T) {
|
|
h := Handler("/app/", "index.html")
|
|
if cc := get(t, h, "/app/").Header.Get("Cache-Control"); cc != "no-cache" {
|
|
t.Errorf("shell Cache-Control = %q, want no-cache", cc)
|
|
}
|
|
}
|
|
|
|
// TestAppMountServesShellStripsPrefixAndCachesAssets: "/app/" and "/telegram/" serve the app
|
|
// shell (index.html), strip their prefix, fall back for deep links, and mark hash-named
|
|
// assets immutable.
|
|
func TestAppMountServesShellStripsPrefixAndCachesAssets(t *testing.T) {
|
|
for _, prefix := range []string{"/app/", "/telegram/"} {
|
|
h := Handler(prefix, "index.html")
|
|
|
|
if resp := get(t, h, prefix); resp.StatusCode != http.StatusOK || !strings.Contains(body(t, resp), "scrabble-app-shell") {
|
|
t.Fatalf("GET %s did not serve the app shell (status %d)", prefix, resp.StatusCode)
|
|
}
|
|
// A deep link falls back to the shell so the hash router can take over.
|
|
if resp := get(t, h, prefix+"game/abc"); resp.StatusCode != http.StatusOK || !strings.Contains(body(t, resp), "scrabble-app-shell") {
|
|
t.Fatalf("GET %sgame/abc did not fall back to the app shell (status %d)", prefix, resp.StatusCode)
|
|
}
|
|
// A hash-named asset is served directly and marked immutable.
|
|
resp := get(t, h, prefix+"assets/.gitkeep")
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("GET %sassets/.gitkeep status = %d, want 200", prefix, resp.StatusCode)
|
|
}
|
|
if cc := resp.Header.Get("Cache-Control"); !strings.Contains(cc, "immutable") {
|
|
t.Errorf("asset Cache-Control = %q, want immutable", cc)
|
|
}
|
|
}
|
|
}
|
|
|
|
// testFS mirrors what Vite emits into dist/: the SPA shell, the PWA manifest + service worker at
|
|
// the root (copied from ui/public), and a hash-named asset. The compile-time embedded dist/ holds
|
|
// only a placeholder shell, so the manifest/sw.js serving is exercised over this in-memory FS.
|
|
func testFS() fstest.MapFS {
|
|
return fstest.MapFS{
|
|
"index.html": {Data: []byte("<!doctype html><title>shell</title>")},
|
|
"manifest.webmanifest": {Data: []byte(`{"name":"Эрудит"}`)},
|
|
"sw.js": {Data: []byte("self.addEventListener('fetch', () => {});")},
|
|
"assets/app-abc123.js": {Data: []byte("export const x = 1;")},
|
|
}
|
|
}
|
|
|
|
// TestHandlerServesManifestWithManifestType: the PWA manifest is served with the manifest MIME
|
|
// type (registered in init, since the distroless image has no /etc/mime.types), not sniffed to
|
|
// text/plain, which some browsers reject.
|
|
func TestHandlerServesManifestWithManifestType(t *testing.T) {
|
|
h := handlerFor(testFS(), "/app/", "index.html")
|
|
resp := get(t, h, "/app/manifest.webmanifest")
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", resp.StatusCode)
|
|
}
|
|
if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(ct, "application/manifest+json") {
|
|
t.Errorf("Content-Type = %q, want application/manifest+json", ct)
|
|
}
|
|
}
|
|
|
|
// TestHandlerServesServiceWorkerAsJavaScript: sw.js is served as JavaScript from the root, so its
|
|
// registration (scope /app/) succeeds.
|
|
func TestHandlerServesServiceWorkerAsJavaScript(t *testing.T) {
|
|
h := handlerFor(testFS(), "/app/", "index.html")
|
|
resp := get(t, h, "/app/sw.js")
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", resp.StatusCode)
|
|
}
|
|
if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/javascript") {
|
|
t.Errorf("Content-Type = %q, want text/javascript", ct)
|
|
}
|
|
// Revalidated on every load so a new deploy's worker (and its fresh precache) is picked up.
|
|
if cc := resp.Header.Get("Cache-Control"); cc != "no-cache" {
|
|
t.Errorf("sw.js Cache-Control = %q, want no-cache", cc)
|
|
}
|
|
}
|
|
|
|
// TestHandlerFallsBackToShellForUnknownManifestPath guards the trap: a manifest/sw path NOT emitted
|
|
// into dist/ falls back to the SPA shell as text/html, on which SW registration would fail. The two
|
|
// tests above pin that the real files are served instead of the shell.
|
|
func TestHandlerFallsBackToShellForUnknownManifestPath(t *testing.T) {
|
|
h := handlerFor(testFS(), "/app/", "index.html")
|
|
resp := get(t, h, "/app/not-emitted.webmanifest")
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", resp.StatusCode)
|
|
}
|
|
if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/html") {
|
|
t.Errorf("Content-Type = %q, want text/html (SPA shell fallback)", ct)
|
|
}
|
|
}
|