All checks were successful
check / check (pull_request) Successful in 30s
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.
186 lines
6.6 KiB
Go
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)
|
|
}
|
|
}
|