211 lines
7.5 KiB
Go
211 lines
7.5 KiB
Go
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", "· 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) }
|