gbr-games/cmd/gbrgames/research_test.go

package main

import "testing"

func TestPickPagesPrefersDocsAndOnePerSite(t *testing.T) {
	hits := []searchHit{
		{URL: "https://blog.example.com/example-server"},
		{URL: "https://github.com/a/example-docker"},
		{URL: "https://github.com/b/other"},
		{URL: "https://hub.docker.com/r/x/example"},
		{URL: "https://blog.example.com/example-server"},
	}
	got := pickPages(hits, 3)
	if len(got) != 3 {
		t.Fatalf("got %d pages", len(got))
	}
	if got[0].URL != "https://github.com/a/example-docker" || got[1].URL != "https://hub.docker.com/r/x/example" || got[2].URL != "https://blog.example.com/example-server" {
		t.Errorf("order: %v", got)
	}
}

func TestTrimToJSON(t *testing.T) {
	if got := trimToJSON("Here you go:\n```json\n{\"a\": 1}\n```"); got != `{"a": 1}` {
		t.Errorf("got %q", got)
	}
}

func TestAppNameFromAppInfo(t *testing.T) {
	out := `"1000000"
{
	"common"
	{
		"name"		"Example Dedicated Server"
		"type"		"Tool"
	}
}`
	m := appName.FindStringSubmatch(out)
	if m == nil || m[1] != "Example Dedicated Server" {
		t.Errorf("got %v", m)
	}
}

func TestParseAppInfoFindsLinuxServers(t *testing.T) {
	linux, ok := parseAppInfo(`"1000000"
{
	"common"
	{
		"name"		"Example Dedicated Server"
		"oslist"		"windows,linux"
	}
}`)
	if !ok || linux.name != "Example Dedicated Server" || !linux.linux {
		t.Errorf("got %+v %v", linux, ok)
	}
	// A server that only exists for Windows (needs Proton or Wine)
	windows, _ := parseAppInfo(`"common" { "name" "Example Server" "oslist" "windows" }`)
	if windows.linux {
		t.Error("windows-only app reported as linux")
	}
}

func TestWithSteamCMDGoesFirstOnlyForLinuxServers(t *testing.T) {
	images := []string{"someone/example-server", "cm2network/steamcmd", "other/example"}
	got := withSteamCMD(images, true)
	if len(got) != 3 || got[0] != "cm2network/steamcmd" || got[1] != "someone/example-server" {
		t.Errorf("linux: %v", got)
	}
	got = withSteamCMD([]string{"someone/proton-example"}, false)
	if len(got) != 2 || got[1] != "cm2network/steamcmd" {
		t.Errorf("windows-only: %v", got)
	}
}

func TestRecommendPrefersTheSteamCMDVariant(t *testing.T) {
	v := []variant{
		{ID: "image", Recommended: true, Images: []string{"someone/example-server"}},
		{ID: "steam", Images: []string{"cm2network/steamcmd", "someone/example-server"}},
		{ID: "broken", Recommended: true},
	}
	recommend(v)
	if v[0].Recommended || !v[1].Recommended || v[2].Recommended {
		t.Errorf("got %+v", v)
	}
	// Without a SteamCMD variant, the model's runnable choice stands
	v = []variant{{ID: "a", Images: []string{"x/a"}}, {ID: "b", Recommended: true, Images: []string{"x/b"}}}
	recommend(v)
	if v[0].Recommended || !v[1].Recommended {
		t.Errorf("got %+v", v)
	}
}

func TestOneOptionPerImageThenSteamCMDRecommended(t *testing.T) {
	v := oneOptionPerImage([]variant{{
		ID: "dedicated", Title: "Example Dedicated Server", Recommended: true, SteamAppID: "1000000",
		Images:   withSteamCMD([]string{"someone/example-server"}, true),
		Verified: []string{"image someone/example-server exists", "Steam app 1000000 is \"Example Dedicated Server\""},
	}})
	recommend(v)
	if len(v) != 2 {
		t.Fatalf("want one option per image, got %+v", v)
	}
	steam, image := v[0], v[1]
	if steam.Title != "Example Dedicated Server (SteamCMD)" || !steam.Recommended || steam.SteamAppID != "1000000" || len(steam.Images) != 1 {
		t.Errorf("SteamCMD option: %+v", steam)
	}
	if image.Title != "Example Dedicated Server (image someone/example-server)" || image.Recommended || image.SteamAppID != "" {
		t.Errorf("image option: %+v", image)
	}
	for _, line := range steam.Verified {
		if line == "image someone/example-server exists" {
			t.Error("SteamCMD option lists the other option's image check")
		}
	}
}