259 lines
9.4 KiB
Go
259 lines
9.4 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func TestMapTileSourceDefaultSeeded(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.GetDefaultMapTileSource()
|
|
if err != nil {
|
|
t.Fatalf("GetDefaultMapTileSource() error = %v", err)
|
|
}
|
|
if row.Name != defaultMapTileSourceName || row.URLTemplate != defaultMapTileSourceURLTemplate || !row.Enabled || !row.IsDefault {
|
|
t.Fatalf("default map source = %+v, want built-in default", row)
|
|
}
|
|
}
|
|
|
|
func TestCreateMapTileSourceValidation(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
if _, err := st.CreateMapTileSource(mapTileSourceInput{Name: "bad", URLTemplate: "https://tiles.example.com/{z}/{x}.png", MaxZoom: 19, Enabled: true, ProxyEnabled: true}); err == nil {
|
|
t.Fatal("CreateMapTileSource() missing placeholder error = nil, want error")
|
|
}
|
|
if _, err := st.CreateMapTileSource(mapTileSourceInput{Name: "bad", URLTemplate: "javascript:alert(1)/{z}/{x}/{y}", MaxZoom: 19, Enabled: true, ProxyEnabled: true}); err == nil {
|
|
t.Fatal("CreateMapTileSource() invalid scheme error = nil, want error")
|
|
}
|
|
if _, err := st.CreateMapTileSource(mapTileSourceInput{Name: "bad", URLTemplate: "https://user:pass@tiles.example.com/{z}/{x}/{y}.png", MaxZoom: 19, Enabled: true, ProxyEnabled: true}); err == nil {
|
|
t.Fatal("CreateMapTileSource() credentials error = nil, want error")
|
|
}
|
|
}
|
|
|
|
func TestListEnabledMapTileSources(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
disabled, err := st.CreateMapTileSource(mapTileSourceInput{Name: "Disabled", URLTemplate: "https://disabled.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: false})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource(disabled) error = %v", err)
|
|
}
|
|
custom, err := st.CreateMapTileSource(mapTileSourceInput{Name: "Custom", URLTemplate: "https://custom.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: true})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource(custom) error = %v", err)
|
|
}
|
|
if _, err := st.SetDefaultMapTileSource(custom.ID); err != nil {
|
|
t.Fatalf("SetDefaultMapTileSource() error = %v", err)
|
|
}
|
|
|
|
rows, err := st.ListEnabledMapTileSources()
|
|
if err != nil {
|
|
t.Fatalf("ListEnabledMapTileSources() error = %v", err)
|
|
}
|
|
if len(rows) < 2 {
|
|
t.Fatalf("ListEnabledMapTileSources() length = %d, want at least 2", len(rows))
|
|
}
|
|
if rows[0].ID != custom.ID {
|
|
t.Fatalf("first enabled source id = %d, want default %d", rows[0].ID, custom.ID)
|
|
}
|
|
for _, row := range rows {
|
|
if row.ID == disabled.ID {
|
|
t.Fatalf("disabled source was returned: %+v", row)
|
|
}
|
|
if !row.Enabled {
|
|
t.Fatalf("disabled row returned: %+v", row)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMapTileSourceDuplicateAndDefaultRules(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
first, err := st.CreateMapTileSource(mapTileSourceInput{Name: "Custom", URLTemplate: "https://tiles.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: true})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
if _, err := st.CreateMapTileSource(mapTileSourceInput{Name: "Custom", URLTemplate: "https://tiles2.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: true}); !errors.Is(err, errMapTileSourceAlreadyExists) {
|
|
t.Fatalf("duplicate name error = %v, want errMapTileSourceAlreadyExists", err)
|
|
}
|
|
if _, err := st.CreateMapTileSource(mapTileSourceInput{Name: "Custom 2", URLTemplate: first.URLTemplate, MaxZoom: 18, Enabled: true, ProxyEnabled: true}); !errors.Is(err, errMapTileSourceAlreadyExists) {
|
|
t.Fatalf("duplicate url error = %v, want errMapTileSourceAlreadyExists", err)
|
|
}
|
|
|
|
updated, err := st.SetDefaultMapTileSource(first.ID)
|
|
if err != nil {
|
|
t.Fatalf("SetDefaultMapTileSource() error = %v", err)
|
|
}
|
|
if !updated.IsDefault {
|
|
t.Fatalf("updated default = %+v, want is_default", updated)
|
|
}
|
|
|
|
oldDefault, err := st.GetDefaultMapTileSource()
|
|
if err != nil {
|
|
t.Fatalf("GetDefaultMapTileSource() error = %v", err)
|
|
}
|
|
if oldDefault.ID != first.ID {
|
|
t.Fatalf("default id = %d, want %d", oldDefault.ID, first.ID)
|
|
}
|
|
if _, err := st.UpdateMapTileSource(first.ID, mapTileSourceInput{Name: first.Name, URLTemplate: first.URLTemplate, Attribution: first.Attribution, MaxZoom: first.MaxZoom, Enabled: false, IsDefault: true}); !errors.Is(err, errMapTileSourceCannotDisableDefault) {
|
|
t.Fatalf("disable default error = %v, want errMapTileSourceCannotDisableDefault", err)
|
|
}
|
|
if err := st.DeleteMapTileSource(first.ID); !errors.Is(err, errMapTileSourceCannotDeleteDefault) {
|
|
t.Fatalf("delete default error = %v, want errMapTileSourceCannotDeleteDefault", err)
|
|
}
|
|
}
|
|
|
|
func TestMapTileSourceHashIsSetOnCreate(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.CreateMapTileSource(mapTileSourceInput{Name: "Hashed", URLTemplate: "https://test.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: true})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
want := mapTileSourceHash("https://test.example.com/{z}/{x}/{y}.png")
|
|
if row.URLTemplateHash != want {
|
|
t.Fatalf("URLTemplateHash = %q, want %q", row.URLTemplateHash, want)
|
|
}
|
|
if !row.ProxyEnabled {
|
|
t.Fatal("ProxyEnabled = false, want true")
|
|
}
|
|
}
|
|
|
|
func TestMapTileSourceDefaultHasHash(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.GetDefaultMapTileSource()
|
|
if err != nil {
|
|
t.Fatalf("GetDefaultMapTileSource() error = %v", err)
|
|
}
|
|
want := mapTileSourceHash(defaultMapTileSourceURLTemplate)
|
|
if row.URLTemplateHash != want {
|
|
t.Fatalf("default URLTemplateHash = %q, want %q", row.URLTemplateHash, want)
|
|
}
|
|
}
|
|
|
|
func TestGetEnabledMapTileSourceByHash(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.CreateMapTileSource(mapTileSourceInput{Name: "HashLookup", URLTemplate: "https://lookup.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: true})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
|
|
found, err := st.GetEnabledMapTileSourceByHash(row.URLTemplateHash)
|
|
if err != nil {
|
|
t.Fatalf("GetEnabledMapTileSourceByHash() error = %v", err)
|
|
}
|
|
if found.ID != row.ID {
|
|
t.Fatalf("found ID = %d, want %d", found.ID, row.ID)
|
|
}
|
|
}
|
|
|
|
func TestGetEnabledMapTileSourceByHashDisabled(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.CreateMapTileSource(mapTileSourceInput{Name: "DisabledHash", URLTemplate: "https://disabled-hash.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: false})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
|
|
_, err = st.GetEnabledMapTileSourceByHash(row.URLTemplateHash)
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
t.Fatalf("GetEnabledMapTileSourceByHash(disabled) = %v, want gorm.ErrRecordNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestGetEnabledMapTileSourceByHashProxyDisabled(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.CreateMapTileSource(mapTileSourceInput{Name: "ProxyDisabledHash", URLTemplate: "https://proxy-disabled.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: false})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
|
|
_, err = st.GetEnabledMapTileSourceByHash(row.URLTemplateHash)
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
t.Fatalf("GetEnabledMapTileSourceByHash(proxy disabled) = %v, want gorm.ErrRecordNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestGetEnabledMapTileSourceByHashUnknown(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
_, err := st.GetEnabledMapTileSourceByHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
t.Fatalf("GetEnabledMapTileSourceByHash(unknown) = %v, want gorm.ErrRecordNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestPublicMapTileSourceDTOProxyURL(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.CreateMapTileSource(mapTileSourceInput{Name: "ProxyTest", URLTemplate: "https://proxy.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: true})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
|
|
dto := publicMapTileSourceDTO(*row)
|
|
urlTemplate, ok := dto["url_template"].(string)
|
|
if !ok {
|
|
t.Fatal("url_template is not a string")
|
|
}
|
|
wantPrefix := "/api/map/" + row.URLTemplateHash + "?x={x}&y={y}&z={z}"
|
|
if urlTemplate != wantPrefix {
|
|
t.Fatalf("url_template = %q, want %q", urlTemplate, wantPrefix)
|
|
}
|
|
if strings.Contains(urlTemplate, "proxy.example.com") {
|
|
t.Fatal("url_template should not contain upstream hostname")
|
|
}
|
|
}
|
|
|
|
func TestPublicMapTileSourceDTORawURLWhenProxyDisabled(t *testing.T) {
|
|
st := openTestStore(t)
|
|
defer st.Close()
|
|
|
|
row, err := st.CreateMapTileSource(mapTileSourceInput{Name: "RawTest", URLTemplate: "https://raw.example.com/{z}/{x}/{y}.png", MaxZoom: 18, Enabled: true, ProxyEnabled: false})
|
|
if err != nil {
|
|
t.Fatalf("CreateMapTileSource() error = %v", err)
|
|
}
|
|
|
|
dto := publicMapTileSourceDTO(*row)
|
|
urlTemplate, ok := dto["url_template"].(string)
|
|
if !ok {
|
|
t.Fatal("url_template is not a string")
|
|
}
|
|
if urlTemplate != row.URLTemplate {
|
|
t.Fatalf("url_template = %q, want raw %q", urlTemplate, row.URLTemplate)
|
|
}
|
|
}
|
|
|
|
func TestMapTileSourceHashFunction(t *testing.T) {
|
|
hash1 := mapTileSourceHash("https://tile.openstreetmap.jp/{z}/{x}/{y}.png")
|
|
hash2 := mapTileSourceHash("https://tile.openstreetmap.jp/{z}/{x}/{y}.png")
|
|
hash3 := mapTileSourceHash("https://other.example.com/{z}/{x}/{y}.png")
|
|
|
|
if hash1 != hash2 {
|
|
t.Fatal("hash should be deterministic")
|
|
}
|
|
if len(hash1) != 64 {
|
|
t.Fatalf("hash length = %d, want 64", len(hash1))
|
|
}
|
|
if hash1 == hash3 {
|
|
t.Fatal("different URLs should produce different hashes")
|
|
}
|
|
}
|