bdeshi
85a49068d2
The first collection page earns the Query primitive: content.Query{Section, Lang}
with Site.Run, newest first, undated after dated, ties broken by key so the same
query always answers in the same order. No cache signature — nothing caches, and a
signature with no consumer is speculation.
Pagination lives in the path (ADR-0028): page one is the bare listing URL,
/page/1/ redirects to it, and a page past the end is 404 rather than an empty page,
because an empty page is a URL that means nothing. `page` is therefore a reserved
segment inside a section, now recorded in content-model.md.
Two kinds of page means two parsed template sets already — base plus the block that
kind defines — which is ADR-0019's per-type shape arriving by need rather than by
anticipation. A head struct is embedded in both Page and List so base.html has one
contract, and theme-contract.md gains the listing fields.
Bundle gains Date, accepting an unquoted YAML date or an RFC 3339 string, since
yaml.v3 hands back time.Time for one and a string for the other.
Evidence: 12 posts → /posts/ shows 10 with rel=next to /posts/page/2/,
/posts/page/2/ shows 3 with rel=prev to /posts/, ordering is post-12 11 10,
/posts/page/1/ 301s to /posts/, /posts/page/9/ is 404, /bn/posts/ is 200.
292 lines
9.3 KiB
Go
292 lines
9.3 KiB
Go
package web
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"testing/fstest"
|
|
|
|
"khosra/internal/content"
|
|
"khosra/internal/render"
|
|
)
|
|
|
|
func testHandler(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
fsys := fstest.MapFS{
|
|
"content/pages/about.md": {Data: []byte("---\ntitle: About\n---\nAbout me.\n")},
|
|
"content/posts/hello/index.md": {Data: []byte("---\ntitle: Hello\n---\nFirst post.\n")},
|
|
}
|
|
bundles, err := content.Scan(fsys)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err := render.New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Handler(content.NewSite(bundles), r)
|
|
}
|
|
|
|
func TestServeBundleAtItsPermalink(t *testing.T) {
|
|
h := testHandler(t)
|
|
for _, path := range []string{"/pages/about/", "/posts/hello/"} {
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("GET %s = %d, want 200", path, rec.Code)
|
|
}
|
|
if ct := rec.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/html") {
|
|
t.Errorf("GET %s content-type = %q", path, ct)
|
|
}
|
|
}
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/pages/about/", nil))
|
|
if body := rec.Body.String(); !strings.Contains(body, "<h1>About</h1>") || !strings.Contains(body, "About me.") {
|
|
t.Errorf("body did not render the bundle:\n%s", body)
|
|
}
|
|
}
|
|
|
|
func TestSlashlessPathRedirectsPermanently(t *testing.T) {
|
|
h := testHandler(t)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/pages/about", nil))
|
|
if rec.Code != http.StatusMovedPermanently {
|
|
t.Fatalf("got %d, want 301", rec.Code)
|
|
}
|
|
if loc := rec.Header().Get("Location"); loc != "/pages/about/" {
|
|
t.Errorf("Location = %q", loc)
|
|
}
|
|
}
|
|
|
|
func TestUnknownPathsAre404(t *testing.T) {
|
|
h := testHandler(t)
|
|
for _, path := range []string{"/", "/nope/", "/pages/nope", "/pages/about/deeper/"} {
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
|
|
if rec.Code != http.StatusNotFound {
|
|
t.Errorf("GET %s = %d, want 404", path, rec.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
func multilingualHandler(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
fsys := fstest.MapFS{
|
|
"content/pages/about.md": {Data: []byte("---\ntitle: About\n---\nEnglish.\n")},
|
|
"content/pages/about.bn.md": {Data: []byte("---\ntitle: পরিচিতি\n---\nবাংলা।\n")},
|
|
"content/pages/now.md": {Data: []byte("---\ntitle: Now\n---\nOnly English.\n")},
|
|
}
|
|
bundles, err := content.Scan(fsys)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err := render.New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Handler(content.NewSite(bundles), r)
|
|
}
|
|
|
|
func TestPrefixedLanguageServesThatVariant(t *testing.T) {
|
|
h := multilingualHandler(t)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/bn/pages/about/", nil))
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("got %d, want 200", rec.Code)
|
|
}
|
|
body := rec.Body.String()
|
|
if !strings.Contains(body, "বাংলা।") || !strings.Contains(body, `lang="bn"`) {
|
|
t.Errorf("did not serve the Bengali variant:\n%s", body)
|
|
}
|
|
if !strings.Contains(body, `rel="canonical" href="/bn/pages/about/"`) {
|
|
t.Error("canonical should name the variant actually served")
|
|
}
|
|
if !strings.Contains(body, `hreflang="en" href="/pages/about/"`) {
|
|
t.Error("hreflang should list the English variant at the root form")
|
|
}
|
|
}
|
|
|
|
func TestMissingVariantFallsBackAndSaysSo(t *testing.T) {
|
|
h := multilingualHandler(t)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/bn/pages/now/", nil))
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("got %d, want 200: the fallback chain must not 404 (ADR-0009)", rec.Code)
|
|
}
|
|
body := rec.Body.String()
|
|
if !strings.Contains(body, "Only English.") {
|
|
t.Error("expected the English body as fallback")
|
|
}
|
|
if !strings.Contains(body, `rel="canonical" href="/pages/now/"`) {
|
|
t.Error("canonical must point at the variant served, not the URL requested")
|
|
}
|
|
}
|
|
|
|
func TestDefaultLanguagePrefixRedirectsToRoot(t *testing.T) {
|
|
h := multilingualHandler(t)
|
|
for path, want := range map[string]string{
|
|
"/en/pages/about/": "/pages/about/",
|
|
"/en/pages/about": "/pages/about/",
|
|
} {
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
|
|
if rec.Code != http.StatusMovedPermanently {
|
|
t.Errorf("GET %s = %d, want 301: /en/… must never be live (ADR-0009)", path, rec.Code)
|
|
continue
|
|
}
|
|
if loc := rec.Header().Get("Location"); loc != want {
|
|
t.Errorf("GET %s → %q, want %q", path, loc, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPrefixedSlashlessPathRedirectsWithItsPrefix(t *testing.T) {
|
|
h := multilingualHandler(t)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/bn/pages/about", nil))
|
|
if rec.Code != http.StatusMovedPermanently {
|
|
t.Fatalf("got %d, want 301", rec.Code)
|
|
}
|
|
if loc := rec.Header().Get("Location"); loc != "/bn/pages/about/" {
|
|
t.Errorf("Location = %q, want /bn/pages/about/", loc)
|
|
}
|
|
}
|
|
|
|
func TestUnknownLanguagePrefixIsNotALanguage(t *testing.T) {
|
|
h := multilingualHandler(t)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/fr/pages/about/", nil))
|
|
if rec.Code != http.StatusNotFound {
|
|
t.Errorf("got %d, want 404: fr is not a language this site has", rec.Code)
|
|
}
|
|
}
|
|
|
|
func aliasHandler(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
fsys := fstest.MapFS{
|
|
"content/posts/new-name.md": {Data: []byte("---\ntitle: New\naliases: [posts/old-name]\n---\nMoved here.\n")},
|
|
"content/posts/new-name.bn.md": {Data: []byte("---\ntitle: নতুন\n---\nএখানে।\n")},
|
|
}
|
|
bundles, err := content.Scan(fsys)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err := render.New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Handler(content.NewSite(bundles), r)
|
|
}
|
|
|
|
func TestAliasRedirectsToCanonical(t *testing.T) {
|
|
h := aliasHandler(t)
|
|
for path, want := range map[string]string{
|
|
"/posts/old-name/": "/posts/new-name/",
|
|
"/bn/posts/old-name/": "/bn/posts/new-name/",
|
|
} {
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
|
|
if rec.Code != http.StatusMovedPermanently {
|
|
t.Errorf("GET %s = %d, want 301", path, rec.Code)
|
|
continue
|
|
}
|
|
if loc := rec.Header().Get("Location"); loc != want {
|
|
t.Errorf("GET %s → %q, want %q", path, loc, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUnknownPathIsStill404NotAnAliasProbe(t *testing.T) {
|
|
h := aliasHandler(t)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/never-existed/", nil))
|
|
if rec.Code != http.StatusNotFound {
|
|
t.Errorf("got %d, want 404", rec.Code)
|
|
}
|
|
}
|
|
|
|
func listingHandler(t *testing.T, n int) http.Handler {
|
|
t.Helper()
|
|
fsys := fstest.MapFS{}
|
|
for i := 1; i <= n; i++ {
|
|
name := fmt.Sprintf("content/posts/post-%02d.md", i)
|
|
body := fmt.Sprintf("---\ntitle: Post %02d\ndate: 2026-01-%02d\n---\nBody %d.\n", i, i, i)
|
|
fsys[name] = &fstest.MapFile{Data: []byte(body)}
|
|
}
|
|
fsys["content/pages/about.md"] = &fstest.MapFile{Data: []byte("---\ntitle: About\n---\nx\n")}
|
|
bundles, err := content.Scan(fsys)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err := render.New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Handler(content.NewSite(bundles), r)
|
|
}
|
|
|
|
func TestSectionIndexListsNewestFirst(t *testing.T) {
|
|
h := listingHandler(t, 3)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/", nil))
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("got %d, want 200", rec.Code)
|
|
}
|
|
body := rec.Body.String()
|
|
first, third := strings.Index(body, "Post 03"), strings.Index(body, "Post 01")
|
|
if first < 0 || third < 0 || first > third {
|
|
t.Errorf("newest should come first:\n%s", body)
|
|
}
|
|
if strings.Contains(body, "About") {
|
|
t.Error("a section listing must not leak another section's bundles")
|
|
}
|
|
}
|
|
|
|
func TestPaginationSplitsAndLinks(t *testing.T) {
|
|
h := listingHandler(t, content.PerPage+2)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/", nil))
|
|
body := rec.Body.String()
|
|
if strings.Count(body, "<li>") != content.PerPage {
|
|
t.Errorf("page one holds %d entries, want %d", strings.Count(body, "<li>"), content.PerPage)
|
|
}
|
|
if !strings.Contains(body, `rel="next" href="/posts/page/2/"`) || strings.Contains(body, `rel="prev"`) {
|
|
t.Errorf("page one should link next and not prev:\n%s", body)
|
|
}
|
|
rec = httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/page/2/", nil))
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("page two = %d, want 200", rec.Code)
|
|
}
|
|
body = rec.Body.String()
|
|
if strings.Count(body, "<li>") != 2 {
|
|
t.Errorf("page two holds %d entries, want 2", strings.Count(body, "<li>"))
|
|
}
|
|
if !strings.Contains(body, `rel="prev" href="/posts/"`) {
|
|
t.Errorf("page two should link back to the bare listing URL:\n%s", body)
|
|
}
|
|
}
|
|
|
|
func TestPageOneIsNeverItsOwnURL(t *testing.T) {
|
|
h := listingHandler(t, 3)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/page/1/", nil))
|
|
if rec.Code != http.StatusMovedPermanently {
|
|
t.Fatalf("got %d, want 301 (ADR-0028)", rec.Code)
|
|
}
|
|
if loc := rec.Header().Get("Location"); loc != "/posts/" {
|
|
t.Errorf("Location = %q, want /posts/", loc)
|
|
}
|
|
}
|
|
|
|
func TestPagePastTheEndIs404(t *testing.T) {
|
|
h := listingHandler(t, 3)
|
|
rec := httptest.NewRecorder()
|
|
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/page/9/", nil))
|
|
if rec.Code != http.StatusNotFound {
|
|
t.Errorf("got %d, want 404: an empty page is a URL that means nothing", rec.Code)
|
|
}
|
|
}
|