A new package, with no new dependency, that reads the HTML a page renders to (the lenient mode of encoding/xml with the HTML void elements and entities) and writes gemtext: three heading levels, one line paragraphs, the links of a paragraph, a list, a quote or a table on lines of their own after it, bullets (a list of only links is link lines), quotes (a note is a quote), preformatted blocks, tables as aligned preformatted blocks, images as link lines, no emphasis, and lines that look like gemtext are protected. Options.Link maps or drops an address and its error stops the conversion; Options.Block expands the placeholders of generated blocks. The language files also keep the order of the menu now (Lang.NavOrder), which the Gemini output needs. Refs #10
207 lines
7.4 KiB
Go
207 lines
7.4 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)
|
|
}
|
|
}
|
|
|
|
// TestLoadKeepsTheOrderOfTheMenu checks that the entries of nav are listed in the
|
|
// order the language file writes them, which a map cannot tell.
|
|
func TestLoadKeepsTheOrderOfTheMenu(t *testing.T) {
|
|
files := validFiles()
|
|
files["lang/en.json"] = `{"lang_name": "English", "nav": {"manifesto": "Manifesto", "people": "People", "news": "News", "services": "Services"}}`
|
|
_, langs, err := Load(writeSite(t, files))
|
|
if err != nil {
|
|
t.Fatalf("Load() error = %v", err)
|
|
}
|
|
want := []string{"manifesto", "people", "news", "services"}
|
|
got := langs["en"].NavOrder
|
|
if len(got) != len(want) {
|
|
t.Fatalf("NavOrder = %v, want %v", got, want)
|
|
}
|
|
for i := range want {
|
|
if got[i] != want[i] {
|
|
t.Fatalf("NavOrder = %v, want %v", got, want)
|
|
}
|
|
}
|
|
}
|