first commit

This commit is contained in:
libroot 2026-11-19 04:40:59 +02:00
commit 8c4dcae475
Signed by: libroot
GPG key ID: 2AC68C029EBE9ACE
89 changed files with 24623 additions and 0 deletions

211
tests/assemblies_test.go Normal file
View file

@ -0,0 +1,211 @@
package main
import (
"encoding/json"
"fmt"
"path/filepath"
"reflect"
"slices"
"strings"
"testing"
)
func writeAssemblyDoc(t *testing.T, root, id string, meta map[string]interface{}, pages []string, versions map[string][]string) {
t.Helper()
dir := filepath.Join(root, id)
b, err := json.Marshal(meta)
if err != nil {
t.Fatal(err)
}
writeFixtureFile(t, filepath.Join(dir, "metadata.json"), string(b))
writeFixtureFile(t, filepath.Join(dir, id+".pdf"), "%PDF-1.4\n")
for _, p := range pages {
writeFixtureFile(t, filepath.Join(dir, "images", p), fixtureJPEG)
}
for slug, imgs := range versions {
v := filepath.Join(dir, "versions", slug)
writeFixtureFile(t, filepath.Join(v, slug+".pdf"), "%PDF-1.4\n")
for _, p := range imgs {
writeFixtureFile(t, filepath.Join(v, "images", p), fixtureJPEG)
}
}
}
func assemblyCorpus(t *testing.T, manifest string) string {
t.Helper()
root := t.TempDir()
writeAssemblyDoc(t, root, "deck", map[string]interface{}{
"title": "The Deck",
"publication": []map[string]interface{}{
{"publisher": "Outlet A"},
{"publisher": "Partner", "reporting_only": true},
{"publisher": "Outlet B", "version": "fuller"},
},
}, []string{"page-1.jpg", "page-2.jpg", "page-3.jpg"}, map[string][]string{"fuller": {"page-1.jpg", "page-2.jpg"}})
writeAssemblyDoc(t, root, "single", map[string]interface{}{
"title": "One Slide",
"publication": []map[string]interface{}{{"publisher": "Outlet C"}},
}, []string{"page-1.jpg"}, nil)
writeAssemblyDoc(t, root, "bystander", map[string]interface{}{"title": "Bystander"}, []string{"page-1.jpg"}, nil)
if manifest != "" {
writeFixtureFile(t, filepath.Join(root, "assemblies.json"), manifest)
}
return root
}
const assemblyManifest = `[{
"id": "set", "title": "A Set", "note": "Order is a guess.",
"slides": [
{"doc": "deck", "pages": "1-2", "alt": [{"doc": "deck", "version": "fuller", "pages": "1-2"}]},
{"doc": "deck", "version": "fuller", "pages": "2", "note": "Only here."},
{"doc": "single", "pages": "1"}
]
}]`
func TestParsePageList(t *testing.T) {
for in, want := range map[string][]int{
"8": {8}, "1-3": {1, 2, 3}, "1,3,5-6": {1, 3, 5, 6}, " 2 , 4 ": {2, 4}, "9,1": {9, 1},
} {
got, err := parsePageList(in)
if err != nil || !reflect.DeepEqual(got, want) {
t.Errorf("parsePageList(%q) = %v, %v; want %v", in, got, err, want)
}
}
for _, in := range []string{"", "a", "0", "3-1", "1-", "1,,2"} {
if got, err := parsePageList(in); err == nil {
t.Errorf("parsePageList(%q) = %v, want an error", in, got)
}
}
}
func TestAssemblyResolves(t *testing.T) {
withCorpus(t, assemblyCorpus(t, assemblyManifest))
a := corpus().assemblyIndex["set"]
if a == nil {
t.Fatal("assembly not loaded")
}
if len(a.Slides) != 4 {
t.Fatalf("%d slides, want 4", len(a.Slides))
}
for i, s := range a.Slides {
if s.Pos != i+1 {
t.Errorf("slide %d has Pos %d", i+1, s.Pos)
}
}
first := a.Slides[0]
if first.Image != "/files/deck/images/page-1.jpg" || first.Source != "Outlet A" {
t.Errorf("first slide %+v", first)
}
if len(first.Alts) != 1 || first.Alts[0].Image != "/files/deck/versions/fuller/images/page-1.jpg" || first.Alts[0].Source != "Outlet B" {
t.Errorf("first slide alts %+v", first.Alts)
}
if a.Slides[2].Note != "Only here." || a.Slides[2].Path != "/doc/deck/versions/fuller" {
t.Errorf("third slide %+v", a.Slides[2])
}
if fmt.Sprint(a.DocList) != "[deck single]" {
t.Errorf("DocList %v", a.DocList)
}
if a.Copies != 3 {
t.Errorf("Copies %d, want 3", a.Copies)
}
if len(corpus().assembliesByDoc["single"]) != 1 || len(corpus().assembliesByDoc["bystander"]) != 0 {
t.Errorf("assembliesByDoc %v", corpus().assembliesByDoc)
}
}
func TestAssemblyPages(t *testing.T) {
withCorpus(t, assemblyCorpus(t, assemblyManifest))
h := withBaseHeaders(newMux())
body := func(path string, code int) string {
t.Helper()
w := record(h, httptest_NewGet(path))
if w.Code != code {
t.Fatalf("%s: %d, want %d", path, w.Code, code)
}
return w.Body.String()
}
list := body("/explore/assemblies", 200)
if !strings.Contains(list, `href="/explore/assemblies/set"`) || !strings.Contains(list, "4 slides from 3 copies") {
t.Errorf("/explore/assemblies:\n%s", list)
}
page := body("/explore/assemblies/set", 200)
for _, want := range []string{
"<title>A Set - Snowden Archive</title>", "from 3 separately published copies.", "Order is a guess.", "not a document in its own right",
`id="lb-4"`, `href="#lb-a1-1"`, `id="lb-a1-1"`, "Other copy: Outlet B", "Back to slide 1", "(copy: fuller)", "Outlet C", "&middot; Only here.",
} {
if !strings.Contains(page, want) {
t.Errorf("/explore/assemblies/set lacks %q", want)
}
}
if strings.Contains(page, `id="lb-5"`) || strings.Contains(page, "Partner") {
t.Errorf("/explore/assemblies/set has a fifth overlay or a reporting-only credit")
}
if !strings.Contains(body("/doc/single", 200), `href="/explore/assemblies/set"`) {
t.Errorf("/doc/single has no assembly link")
}
if strings.Contains(body("/doc/bystander", 200), "/explore/assemblies/") {
t.Errorf("/doc/bystander links an assembly")
}
// Assemblies live under /explore only: listed there, not on /browse.
if !strings.Contains(body("/explore", 200), `href="/explore/assemblies"`) {
t.Errorf("/explore has no assemblies link")
}
if strings.Contains(body("/browse", 200), "assemblies") {
t.Errorf("/browse still links assemblies")
}
body("/explore/assemblies/nope", 404)
if !slicesContains(corpus().sitemapPaths, "/explore/assemblies/set") {
t.Errorf("sitemap lacks the assembly page")
}
}
func TestAssemblyProblemsWarn(t *testing.T) {
cases := map[string]struct {
manifest string
slides int
loaded bool
}{
"missing doc": {`[{"id":"x","title":"X","slides":[{"doc":"ghost","pages":"1"},{"doc":"single","pages":"1"}]}]`, 1, true},
"missing page": {`[{"id":"x","title":"X","slides":[{"doc":"deck","pages":"3-4"}]}]`, 1, true},
"bad version": {`[{"id":"x","title":"X","slides":[{"doc":"deck","version":"no","pages":"1"},{"doc":"single","pages":"1"}]}]`, 1, true},
"bad pages": {`[{"id":"x","title":"X","slides":[{"doc":"deck","pages":"two"},{"doc":"single","pages":"1"}]}]`, 1, true},
"alt mismatch": {`[{"id":"x","title":"X","slides":[{"doc":"deck","pages":"1-2","alt":[{"doc":"single","pages":"1"}]}]}]`, 2, true},
"nothing left": {`[{"id":"x","title":"X","slides":[{"doc":"ghost","pages":"1"}]}]`, 0, false},
"unsafe id": {`[{"id":"a/b","title":"X","slides":[{"doc":"single","pages":"1"}]}]`, 0, false},
"malformed": {`[{`, 0, false},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
withCorpus(t, assemblyCorpus(t, c.manifest))
if loadWarnings == 0 {
t.Errorf("no warning")
}
a := corpus().assemblyIndex["x"]
if (a != nil) != c.loaded {
t.Fatalf("loaded = %v, want %v", a != nil, c.loaded)
}
if a != nil && len(a.Slides) != c.slides {
t.Errorf("%d slides, want %d", len(a.Slides), c.slides)
}
})
}
}
func TestNoAssembliesFile(t *testing.T) {
withCorpus(t, assemblyCorpus(t, ""))
if len(corpus().assemblies) != 0 {
t.Fatalf("assemblies %v", corpus().assemblies)
}
h := withBaseHeaders(newMux())
if w := record(h, httptest_NewGet("/explore/assemblies")); w.Code != 200 {
t.Errorf("/explore/assemblies: %d", w.Code)
}
if w := record(h, httptest_NewGet("/explore")); strings.Contains(w.Body.String(), `href="/explore/assemblies"`) {
t.Errorf("/explore links assemblies with none loaded")
}
if slicesContains(corpus().sitemapPaths, "/explore/assemblies") {
t.Errorf("sitemap lists assemblies with none loaded")
}
}
func slicesContains(s []string, v string) bool { return slices.Contains(s, v) }