sm-seo-plugin/classes/normalize_test.go

package classes

import (
	"net/url"
	"testing"

	"git.golem15.com/golem15/sm-seo-plugin/models"
)

// TestNormalizeMatrix: every combination of the address rules on every
// input form reaches its final address in one hop (normalising the result
// changes nothing), never touches the query, keeps the root and does not
// modify its input.
func TestNormalizeMatrix(t *testing.T) {
	inputs := []string{
		"/", "/a", "/a/", "/A/b", "//a//b/", "/a/index.html", "/A/Index.PHP", "/index.htm",
		"/sitemap.xml", "/files/Doc.PDF/", "/%C5%81%C3%B3d%C5%BA/Abc/", "/a?Page=2&x=Y", "/a#frag",
		"http://example.test", "http://example.test/A//B/", "https://www.example.test/a/index.html?q=1",
		"https://WWW.Example.Test/Blog/", "http://www.example.test/",
	}
	var all []NormalizeOptions
	for _, host := range []string{models.HostKeep, models.HostWWW, models.HostBare} {
		for _, slash := range []string{models.SlashKeep, models.SlashAdd, models.SlashDrop} {
			for _, lower := range []bool{false, true} {
				all = append(all, NormalizeOptions{Host: host, Slash: slash, Lowercase: lower})
			}
		}
	}
	for _, opts := range all {
		for _, in := range inputs {
			u, err := url.Parse(in)
			if err != nil {
				t.Fatal(err)
			}
			before := *u
			once, _ := Normalize(u, opts)
			if *u != before {
				t.Fatalf("%+v: Normalize(%s) modified its input", opts, in)
			}
			twice, changed := Normalize(once, opts)
			if changed || twice.String() != once.String() {
				t.Fatalf("%+v: %s -> %s -> %s (changed %v): not one hop", opts, in, once, twice, changed)
			}
			if once.RawQuery != u.RawQuery {
				t.Fatalf("%+v: %s: query %q became %q", opts, in, u.RawQuery, once.RawQuery)
			}
			if once.Fragment != "" {
				t.Fatalf("%+v: %s kept its fragment", opts, in)
			}
			if once.Host != "" && once.Scheme != "https" {
				t.Fatalf("%+v: %s scheme %s", opts, in, once.Scheme)
			}
			if u.Path == "/" && once.Path != "/" {
				t.Fatalf("%+v: the root became %s", opts, once.Path)
			}
		}
	}
}

func TestNormalizeMatrixExpectations(t *testing.T) {
	for _, tc := range []struct {
		in   string
		opts NormalizeOptions
		want string
	}{
		{"/A//B/index.html", NormalizeOptions{Host: models.HostKeep, Slash: models.SlashKeep}, "/A/B"},
		{"/A//B/index.html", NormalizeOptions{Slash: models.SlashAdd, Lowercase: true}, "/a/b/"},
		{"/a/b///", NormalizeOptions{Slash: models.SlashDrop}, "/a/b"},
		{"/a/b///", NormalizeOptions{Slash: models.SlashKeep}, "/a/b/"},
		{"/report.PDF", NormalizeOptions{Slash: models.SlashAdd, Lowercase: true}, "/report.pdf"},
		{"/v1.2/page", NormalizeOptions{Slash: models.SlashAdd}, "/v1.2/page/"},
		{"http://EXAMPLE.test/a", NormalizeOptions{Host: models.HostKeep}, "https://example.test/a"},
		{"http://www.example.test/a/", NormalizeOptions{Host: models.HostBare, Slash: models.SlashDrop}, "https://example.test/a"},
		{"https://example.test", NormalizeOptions{Host: models.HostWWW, Slash: models.SlashAdd}, "https://www.example.test/"},
		{"/%c5%81/%C5%82X", NormalizeOptions{Lowercase: true}, "/%C5%81/%C5%82x"},
	} {
		u, _ := url.Parse(tc.in)
		got, _ := Normalize(u, tc.opts)
		if got.String() != tc.want {
			t.Errorf("Normalize(%s, %+v) = %s, want %s", tc.in, tc.opts, got, tc.want)
		}
	}
	if got, changed := Normalize(nil, NormalizeOptions{}); got != nil || changed {
		t.Fatal("Normalize(nil) answered a URL")
	}
	if got := NormalizeOptionsOf(models.Settings{URLHost: models.HostWWW, URLSlash: models.SlashAdd, URLLowercase: true}); got != (NormalizeOptions{Host: models.HostWWW, Slash: models.SlashAdd, Lowercase: true}) {
		t.Fatalf("NormalizeOptionsOf = %+v", got)
	}
}

func TestNormalizeHelpers(t *testing.T) {
	for in, want := range map[string]string{"/": "/", "//": "/", "/a//b": "/a/b", "///a///": "/a/", "/a/b": "/a/b"} {
		if got := collapseSlashes(in); got != want {
			t.Errorf("collapseSlashes(%q) = %q", in, got)
		}
	}
	if got := lowerASCII("/ŁÓDŹ/ABC-z"); got != "/ŁÓdŹ/abc-z" {
		t.Errorf("lowerASCII = %q", got)
	}
	for in, want := range map[string]string{"/a/b.c": "b.c", "/a/": "", "x": "x", "/": ""} {
		if got := lastSegment(in); got != want {
			t.Errorf("lastSegment(%q) = %q", in, got)
		}
	}
	for _, tc := range []struct {
		site, host string
		same       bool
	}{
		{"https://example.test", "example.test", true},
		{"https://example.test", "WWW.example.test", true},
		{"https://www.example.test", "example.test", true},
		{"https://example.test", "evil.test", false},
		{"https://example.test", "", false},
		{"", "example.test", false},
		{"https://example.test", "example.test.evil", false},
	} {
		if got := sameSite(tc.site, tc.host); got != tc.same {
			t.Errorf("sameSite(%q, %q) = %v", tc.site, tc.host, got)
		}
	}
}