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

231
tests/http_test.go Normal file
View file

@ -0,0 +1,231 @@
package main
// http_test.go - protocol behaviour the browser and the proxy rely on:
// HEAD, byte ranges, conditional requests, and method handling. net/http
// implements most of it, but only if the handlers hand it the right thing -
// and a download path that loses Range support breaks resuming a 120 MB PDF
// and the page-by-page fetches a PDF viewer makes.
import (
"fmt"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
)
func TestHTTPHead(t *testing.T) {
buildFixture(t)
for _, p := range []string{"/", "/browse", "/doc/prism-slides",
"/files/prism-slides/prism-slides.pdf", "/api/facets", "/static/style.css"} {
r := httptest.NewRequest("HEAD", p, nil)
w := httptest.NewRecorder()
fixtureMux.ServeHTTP(w, r)
if w.Code != 200 {
t.Errorf("HEAD %s: %d", p, w.Code)
continue
}
// net/http drops the body for HEAD at the transport layer, so the
// recorder still sees one; the headers are what matters here.
if w.Header().Get("Content-Type") == "" {
t.Errorf("HEAD %s: no Content-Type", p)
}
}
}
// Range on a document file. http.ServeFile implements it - this test is
// here so a future change to the download path (a buffered writer, a
// compressing wrapper, a manual io.Copy) cannot quietly remove it.
func TestHTTPRangeOnFiles(t *testing.T) {
buildFixture(t)
const path = "/files/prism-slides/prism-slides.pdf"
full := get(t, path)
body := full.Body.String()
if full.Header().Get("Accept-Ranges") != "bytes" {
t.Fatalf("no Accept-Ranges on a document file: %v", full.Header())
}
req := func(rangeHdr string) *httptest.ResponseRecorder {
r := httptest.NewRequest("GET", path, nil)
r.Header.Set("Range", rangeHdr)
w := httptest.NewRecorder()
fixtureMux.ServeHTTP(w, r)
return w
}
w := req("bytes=0-3")
if w.Code != http.StatusPartialContent {
t.Fatalf("Range bytes=0-3: status %d, want 206", w.Code)
}
if got, want := w.Body.String(), body[:4]; got != want {
t.Errorf("range body %q, want %q", got, want)
}
if cr := w.Header().Get("Content-Range"); cr != fmt.Sprintf("bytes 0-3/%d", len(body)) {
t.Errorf("Content-Range %q", cr)
}
// A suffix range: what a resumed download asks for.
w = req(fmt.Sprintf("bytes=%d-", len(body)-4))
if w.Code != http.StatusPartialContent || w.Body.String() != body[len(body)-4:] {
t.Errorf("suffix range: %d %q", w.Code, w.Body.String())
}
// Past the end is a 416 with the length, not a 200 of the whole file.
w = req(fmt.Sprintf("bytes=%d-%d", len(body)+10, len(body)+20))
if w.Code != http.StatusRequestedRangeNotSatisfiable {
t.Errorf("unsatisfiable range: status %d, want 416", w.Code)
}
// A malformed Range is refused with 416 - net/http's choice, not this
// server's; it is recorded here so a change in behaviour is noticed.
if w = req("bytes=abc"); w.Code != http.StatusRequestedRangeNotSatisfiable {
t.Errorf("malformed Range: status %d, want 416", w.Code)
}
// An unknown range unit is refused the same way. RFC 7233 says to
// ignore it and serve the whole representation; net/http does not, and
// nothing this archive serves sends one. Recorded, not worked around.
if w = req("pages=1-2"); w.Code != http.StatusRequestedRangeNotSatisfiable {
t.Errorf("unknown range unit: status %d, want net/http's 416", w.Code)
}
}
// Conditional requests: a document file and a static asset both carry
// validators, so a reader's second visit is a 304 instead of a re-download.
func TestHTTPConditional(t *testing.T) {
buildFixture(t)
// A document file comes off disk and carries a modification time.
const doc = "/files/prism-slides/prism-slides.pdf"
lm := get(t, doc).Header().Get("Last-Modified")
if lm == "" {
t.Fatalf("%s: no Last-Modified", doc)
}
r := httptest.NewRequest("GET", doc, nil)
r.Header.Set("If-Modified-Since", lm)
w := httptest.NewRecorder()
fixtureMux.ServeHTTP(w, r)
if w.Code != http.StatusNotModified || w.Body.Len() != 0 {
t.Errorf("%s with If-Modified-Since: status %d, %d bytes", doc, w.Code, w.Body.Len())
}
// An embedded asset has no modification time - embed.FS zeroes it - so
// it carries a content ETag instead. Without one, every page view
// re-downloads the stylesheet on an unstamped build.
for _, asset := range []string{"/static/style.css", "/static/main.js"} {
first := get(t, asset)
tag := first.Header().Get("ETag")
if tag == "" {
t.Errorf("%s: no ETag", asset)
continue
}
r := httptest.NewRequest("GET", asset, nil)
r.Header.Set("If-None-Match", tag)
w := httptest.NewRecorder()
fixtureMux.ServeHTTP(w, r)
if w.Code != http.StatusNotModified || w.Body.Len() != 0 {
t.Errorf("%s with If-None-Match: status %d, %d bytes (want an empty 304)",
asset, w.Code, w.Body.Len())
}
// A different asset's tag must not satisfy it.
r = httptest.NewRequest("GET", asset, nil)
r.Header.Set("If-None-Match", `"0000000000000000"`)
w = httptest.NewRecorder()
fixtureMux.ServeHTTP(w, r)
if w.Code != 200 {
t.Errorf("%s with a stale ETag: status %d, want the asset", asset, w.Code)
}
}
}
// Method handling: the routes declare GET or POST, so anything else is a
// 405 from the mux rather than a handler running on the wrong verb.
func TestHTTPMethods(t *testing.T) {
buildFixture(t)
for _, c := range []struct {
method, path string
want int
}{
// Methods the archive never answers stop at the wrapper.
{"PUT", "/api/docs", http.StatusMethodNotAllowed},
{"DELETE", "/doc/prism-slides", http.StatusMethodNotAllowed},
{"OPTIONS", "/", http.StatusMethodNotAllowed},
{"TRACE", "/browse", http.StatusMethodNotAllowed},
// A supported method on the wrong route is a 404: the catch-all
// route claims every path, which is what keeps unknown paths on the
// archive's own 404 page, and it claims them for POST too.
{"POST", "/browse", http.StatusNotFound},
{"GET", "/preferences/save", http.StatusNotFound},
{"GET", "/pin/prism-slides", http.StatusNotFound},
} {
r := httptest.NewRequest(c.method, c.path, nil)
w := httptest.NewRecorder()
fixtureMux.ServeHTTP(w, r)
if w.Code != c.want {
t.Errorf("%s %s: status %d, want %d", c.method, c.path, w.Code, c.want)
}
}
}
// Odd but legal requests must not break anything: repeated parameters,
// unknown parameters, a very long path, an empty query.
func TestHTTPOddRequests(t *testing.T) {
buildFixture(t)
for _, c := range []struct {
path string
want int
}{
{"/browse?sort=title&sort=date", 200},
{"/browse?unknown=1&another=2", 200},
{"/search?q=a&q=b&do_search=1", 200},
{"/browse/program/" + strings.Repeat("x", 2000), 200}, // an empty page, not a crash
{"/doc/" + strings.Repeat("x", 2000), 404},
{"/browse?", 200},
{"/search?do_search=1&fqv=&fqv=&fqv=", 200},
} {
if w := get(t, c.path); w.Code != c.want {
t.Errorf("%.60s: status %d, want %d", c.path, w.Code, c.want)
}
}
}
// With -accel-files the file is nginx's to send: the handler answers only
// the files it would have served itself, with the redirect and no body.
func TestAccelFiles(t *testing.T) {
buildFixture(t)
accelPrefix = "/_files/"
defer func() { accelPrefix = "" }()
w := get(t, "/files/prism-slides/prism-slides.pdf")
rel, err := filepath.Rel(dataDir, filepath.Join(corpus().docIndex["prism-slides"].Dir, "prism-slides.pdf"))
if err != nil {
t.Fatal(err)
}
if got, want := w.Header().Get("X-Accel-Redirect"), "/_files/"+filepath.ToSlash(rel); got != want {
t.Errorf("X-Accel-Redirect %q, want %q", got, want)
}
if w.Code != http.StatusOK || w.Body.Len() != 0 {
t.Errorf("accel answer: status %d, %d body bytes, want an empty 200", w.Code, w.Body.Len())
}
if w.Header().Get("Cache-Control") == "" {
t.Error("accel answer carries no Cache-Control for nginx to pass on")
}
for _, p := range []string{"/files/prism-slides/zz-stray.pdf", "/files/prism-slides/../glossary.json", "/files/no-such-doc/x.pdf"} {
w := get(t, p)
if w.Header().Get("X-Accel-Redirect") != "" || w.Code == http.StatusOK {
t.Errorf("%s: status %d, X-Accel-Redirect %q - a file the server does not serve was handed to nginx", p, w.Code, w.Header().Get("X-Accel-Redirect"))
}
}
}
func TestAccelPathEscapes(t *testing.T) {
old, oldPrefix := dataDir, accelPrefix
dataDir, accelPrefix = "/srv/data", "/_files/"
defer func() { dataDir, accelPrefix = old, oldPrefix }()
if got, ok := accelPath("/srv/data/FOIA/a doc/50%?.pdf"); !ok || got != "/_files/FOIA/a%20doc/50%25%3F.pdf" {
t.Errorf("accelPath = %q, %v", got, ok)
}
if got, ok := accelPath("/srv/other/x.pdf"); ok {
t.Errorf("a file outside the data directory mapped to %q", got)
}
}