motorino/internal/site/site_test.go
tgiachi 4ab8f8d122
All checks were successful
check / check (pull_request) Successful in 30s
fix: find code blocks with the Markdown parser and make the escape work everywhere
The hand written fence scanner took a line that starts with a code span for a
fence and missed fences in quotes and lists. The code blocks are now the ones
goldmark finds. A backslash before a placeholder is turned into a marker that
survives the Markdown and the list expansion, so it works in a code span and
next to a block name, and two backslashes are a literal one. The em dash rule
reports the line of the body, refuses padded entities and checks the header keys
by name, the feed leaves protocol-relative links alone, base_url needs a host
and a language file cannot set it.
2026-11-15 10:38:56 +01:00

186 lines
6.6 KiB
Go

// SPDX-License-Identifier: GPL-3.0-or-later
package site
import (
"os"
"path/filepath"
"strings"
"testing"
)
// writeSite writes files (path relative to a new directory, then content) and
// returns the directory.
func writeSite(t *testing.T, files map[string]string) string {
t.Helper()
dir := t.TempDir()
for name, content := range files {
path := filepath.Join(dir, name)
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
}
return dir
}
// validFiles is a small complete site configuration.
func validFiles() map[string]string {
return map[string]string{
"site.json": `{
"base_url": "https://kmalloc.org",
"languages": ["en", "it"],
"contact": "squid@kmalloc.org",
"security": "security@kmalloc.org",
"abuse": "abuse@kmalloc.org",
"assets": {"favicon.svg": "logo/svg/favicon-auto.svg", "squid.asc": "static/squid.asc"},
"services": [{"id": "ignored"}]
}`,
"lang/en.json": `{"lang_name": "English", "nojs": "No JavaScript.", "nav": {"news": "News"}}`,
"lang/it.json": `{"lang_name": "Italiano", "nojs": "Niente JavaScript.", "nav": {"news": "Novità"}}`,
}
}
// TestLoadDerivesShownAddresses checks that addresses get a harvest-proof twin.
func TestLoadDerivesShownAddresses(t *testing.T) {
cfg, langs, err := Load(writeSite(t, validFiles()))
if err != nil {
t.Fatalf("Load() error = %v", err)
}
want := map[string]string{
"contact_shown": "squid (at) kmalloc.org",
"security_shown": "security (at) kmalloc.org",
"abuse_shown": "abuse (at) kmalloc.org",
"base_url": "https://kmalloc.org",
}
for k, v := range want {
if got := cfg.Strings[k]; got != v {
t.Errorf("Strings[%q] = %q, want %q", k, got, v)
}
}
if len(cfg.Languages) != 2 || cfg.Languages[0] != "en" || cfg.Languages[1] != "it" {
t.Errorf("Languages = %v, want [en it]", cfg.Languages)
}
if got := langs["it"].Nav["news"]; got != "Novità" {
t.Errorf("it nav news = %q, want %q", got, "Novità")
}
if got := langs["en"].Strings["nojs"]; got != "No JavaScript." {
t.Errorf("en nojs = %q", got)
}
if got := langs["en"].Code; got != "en" {
t.Errorf("en Code = %q", got)
}
}
// TestLoadAssets checks the published-name to source map.
func TestLoadAssets(t *testing.T) {
cfg, _, err := Load(writeSite(t, validFiles()))
if err != nil {
t.Fatal(err)
}
if got := cfg.Assets["squid.asc"]; got != "static/squid.asc" {
t.Errorf("Assets[squid.asc] = %q", got)
}
if len(cfg.Assets) != 2 {
t.Errorf("len(Assets) = %d, want 2", len(cfg.Assets))
}
}
// TestLoadUnknownLanguageFile checks that a listed language needs its file.
func TestLoadUnknownLanguageFile(t *testing.T) {
files := validFiles()
delete(files, "lang/it.json")
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "lang/it.json") {
t.Errorf("Load() error = %v, want it to name lang/it.json", err)
}
}
// TestLoadBadJSON checks that a JSON error names the file.
func TestLoadBadJSON(t *testing.T) {
files := validFiles()
files["lang/en.json"] = `{"lang_name": `
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "lang/en.json") {
t.Errorf("Load() error = %v, want it to name lang/en.json", err)
}
}
// TestLoadLanguageNeedsNameAndNav checks the keys every language must have.
func TestLoadLanguageNeedsNameAndNav(t *testing.T) {
for _, tt := range []struct{ name, body, want string }{
{"no name", `{"nav": {}}`, "lang_name"},
{"no nav", `{"lang_name": "English"}`, "nav"},
} {
t.Run(tt.name, func(t *testing.T) {
files := validFiles()
files["lang/en.json"] = tt.body
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), tt.want) || !strings.Contains(err.Error(), "lang/en.json") {
t.Errorf("Load() error = %v, want it to name lang/en.json and %s", err, tt.want)
}
})
}
}
// TestLoadRejectsEscapingAssets checks that assets stay inside the site and the output.
func TestLoadRejectsEscapingAssets(t *testing.T) {
for _, assets := range []string{
`{"../escaped.txt": "static/a"}`, `{"/abs.txt": "static/a"}`,
`{"a.txt": "../../etc/hostname"}`, `{"a.txt": "/etc/hostname"}`,
} {
files := validFiles()
files["site.json"] = `{"base_url": "https://kmalloc.org", "languages": ["en", "it"], "assets": ` + assets + `}`
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "asset") {
t.Errorf("Load(%s) error = %v, want an error about the asset", assets, err)
}
}
}
// TestLoadRejectsBadLanguageCodes checks the shape of the language codes.
func TestLoadRejectsBadLanguageCodes(t *testing.T) {
for _, codes := range []string{`["en", "../x"]`, `["EN"]`, `["en", "en"]`, `["en", "it/x"]`} {
files := validFiles()
files["site.json"] = `{"base_url": "https://kmalloc.org", "languages": ` + codes + `}`
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "language") {
t.Errorf("Load(%s) error = %v, want an error about the language code", codes, err)
}
}
}
// TestLoadNeedsBaseURL checks that the address of the site is required and absolute,
// because the feed and the page addresses are built from it.
func TestLoadNeedsBaseURL(t *testing.T) {
for _, site := range []string{`{"languages": ["en", "it"]}`, `{"base_url": "kmalloc.org", "languages": ["en", "it"]}`, `{"base_url": "https://kmalloc.org/", "languages": ["en", "it"]}`, `{"base_url": "https://", "languages": ["en", "it"]}`, `{"base_url": "https:///x", "languages": ["en", "it"]}`} {
files := validFiles()
files["site.json"] = site
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "base_url") {
t.Errorf("Load(%s) error = %v, want an error about base_url", site, err)
}
}
}
// TestLoadLanguageCannotOverrideBaseURL checks that the address of the site has one source.
func TestLoadLanguageCannotOverrideBaseURL(t *testing.T) {
files := validFiles()
files["lang/it.json"] = `{"lang_name": "Italiano", "base_url": "https://example.org", "nav": {}}`
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "lang/it.json") || !strings.Contains(err.Error(), "base_url") {
t.Errorf("Load() error = %v, want it to name lang/it.json and base_url", err)
}
}
// TestLoadNeedsLanguages checks that an empty language list is an error.
func TestLoadNeedsLanguages(t *testing.T) {
files := validFiles()
files["site.json"] = `{"base_url": "https://kmalloc.org", "languages": []}`
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "languages") {
t.Errorf("Load() error = %v, want it to mention languages", err)
}
}