Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

24.1 KB
Raw Blame
package launcher

import (
	"bytes"
	"compress/gzip"
	"context"
	"encoding/json"
	"errors"
	"io"
	"io/fs"
	"net/http"
	"net/http/httptest"
	"net/url"
	"runtime"
	"strings"
	"testing"
	"testing/fstest"
	"time"

	appfailure "github.com/TNTcraftHIM/Piik/internal/app/failure"
	"github.com/TNTcraftHIM/Piik/internal/app/lan"
)

// appAssets stands in for the embedded Vite build the App ships.
func appAssets() fs.FS {
	return fstest.MapFS{
		"index.html": {Data: []byte("<!doctype html><html><body>client</body></html>")},
	}
}

func TestLauncherCompressesEntryAndAssetsWithoutChangingAPI(t *testing.T) {
	body := []byte(strings.Repeat("Piik launcher asset ", 400))
	assets := fstest.MapFS{
		"index.html":    {Data: body},
		"assets/app.js": {Data: body},
	}
	server, err := Start(t.Context(), assets, Options{Version: "development"})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = server.Close() })
	origin := strings.TrimSuffix(server.URL(), "/client")
	for _, path := range []string{"/client", "/client/", "/assets/app.js"} {
		t.Run(path, func(t *testing.T) {
			request := httptest.NewRequest(http.MethodGet, origin+path, nil)
			request.Header.Set("Accept-Encoding", "gzip")
			response := httptest.NewRecorder()
			server.ServeHTTP(response, request)
			if response.Code != http.StatusOK || response.Header().Get("Content-Encoding") != "gzip" {
				t.Fatalf("static response: %d, %v", response.Code, response.Header())
			}
			reader, err := gzip.NewReader(response.Body)
			if err != nil {
				t.Fatal(err)
			}
			defer reader.Close()
			decoded, err := io.ReadAll(reader)
			if err != nil || !bytes.Equal(decoded, body) {
				t.Fatalf("compressed asset changed: %v", err)
			}
			if path != "/assets/app.js" && response.Header().Get("Cache-Control") != "no-store" {
				t.Fatal("launcher entry lost its cache policy")
			}
		})
	}
	request := httptest.NewRequest(http.MethodGet, origin+"/api/client-launcher", nil)
	request.Header.Set("Accept-Encoding", "gzip")
	response := httptest.NewRecorder()
	server.ServeHTTP(response, request)
	if response.Code != http.StatusOK || response.Header().Get("Content-Encoding") != "" || !json.Valid(response.Body.Bytes()) {
		t.Fatalf("launcher API changed: %d, %v", response.Code, response.Header())
	}
}

func TestLauncherServesStateAndCompletesOneSelection(t *testing.T) {
	server := startFixture(t, "https://share.example")
	origin := strings.TrimSuffix(server.URL(), "/client")

	response, err := http.Get(origin + "/api/client-launcher")
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	var state struct {
		Sites               []string `json:"sites"`
		LocalAccessPassword string   `json:"localAccessPassword"`
		DefaultMode         Mode     `json:"defaultMode"`
		Version             string   `json:"version"`
		Revision            string   `json:"revision"`
		Debug               *bool    `json:"debug"`
	}
	if response.StatusCode != http.StatusOK || json.NewDecoder(response.Body).Decode(&state) != nil ||
		strings.Join(state.Sites, ",") != "https://share.example" || state.DefaultMode != ModeLink ||
		state.Version != "development" || state.Revision != "" || state.LocalAccessPassword != "" || state.Debug == nil || *state.Debug {
		t.Fatalf("launcher state = %d, %+v", response.StatusCode, state)
	}

	result := make(chan *http.Response, 1)
	requestErr := make(chan error, 1)
	go func() {
		response, err := localPost(
			origin+"/api/client-launcher/launch",
			"application/json",
			bytes.NewBufferString(`{"mode":"link","language":"vis","debug":true}`),
		)
		if err != nil {
			requestErr <- err
			return
		}
		result <- response
	}()

	select {
	case selection := <-server.Selection():
		if selection != (Selection{Mode: ModeLink, Language: "vis", Debug: true}) {
			t.Fatalf("selection = %+v", selection)
		}
		server.SetResult("http://localhost:8787/#piik-client=1", nil)
	case <-time.After(time.Second):
		t.Fatal("launcher did not emit a selection")
	}
	select {
	case err = <-requestErr:
		t.Fatal(err)
	case response = <-result:
		defer response.Body.Close()
		var launch struct {
			Target string `json:"target"`
		}
		if response.StatusCode != http.StatusOK || json.NewDecoder(response.Body).Decode(&launch) != nil ||
			launch.Target != "http://localhost:8787/#piik-client=1" {
			t.Fatalf("launcher result = %d, %+v", response.StatusCode, launch)
		}
	case <-time.After(time.Second):
		t.Fatal("launcher did not return its result")
	}
}

func TestLauncherReentryReturnsTheExistingRoom(t *testing.T) {
	server := startFixture(t, "https://share.example")
	origin := strings.TrimSuffix(server.URL(), "/client")
	post := func(ctx context.Context) (*http.Response, error) {
		request, err := http.NewRequestWithContext(ctx, http.MethodPost, origin+"/api/client-launcher/launch",
			strings.NewReader(`{"mode":"local","language":"en"}`))
		if err != nil {
			return nil, err
		}
		request.Header.Set("Origin", origin)
		request.Header.Set("Content-Type", "application/json")
		return (&http.Client{Timeout: 3 * time.Second}).Do(request)
	}
	results := make(chan *http.Response, 2)
	errors := make(chan error, 2)
	enter := func(ctx context.Context) {
		response, err := post(ctx)
		if err != nil {
			errors <- err
			return
		}
		results <- response
	}
	first, cancel := context.WithCancel(t.Context())
	defer cancel()
	go enter(first)
	select {
	case <-server.Selection():
	case <-time.After(time.Second):
		t.Fatal("first entry did not start the room")
	}
	// Leaving the page cancels HTTP, but the accepted startup remains alive.
	cancel()
	select {
	case <-errors:
	case <-time.After(time.Second):
		t.Fatal("departed page did not release its request")
	}
	// A second page or rapid repeat entry must join the accepted startup.
	go enter(t.Context())
	go enter(t.Context())
	target := "http://localhost:8787/#piik-client=1"
	server.SetResult(target, nil)
	check := func(response *http.Response) {
		t.Helper()
		defer response.Body.Close()
		var result struct{ Target string }
		if json.NewDecoder(response.Body).Decode(&result) != nil || response.StatusCode != http.StatusOK || result.Target != target {
			t.Fatalf("entry did not open the existing room: status=%d result=%+v", response.StatusCode, result)
		}
	}
	for range 2 {
		select {
		case response := <-results:
			check(response)
		case err := <-errors:
			t.Fatal(err)
		case <-time.After(time.Second):
			t.Fatal("repeat entry did not finish")
		}
	}
	// Returning to the launcher after sharing uses the same healthy room.
	response, err := post(t.Context())
	if err != nil {
		t.Fatal(err)
	}
	check(response)
	select {
	case <-server.Selection():
		t.Fatal("reentry started a second room")
	default:
	}
}

func TestRoomFailureInvalidatesReadyTargetButKeepsSiteApprovalAvailable(t *testing.T) {
	server := startFixture(t, "https://share.example")
	server.changeSite = func(site string, allowed bool) ([]string, error) { return []string{}, nil }
	origin := strings.TrimSuffix(server.URL(), "/client")
	server.Begin()
	server.SetResult("http://localhost:8787/#piik-client=1", nil)
	server.SetResult("", errors.New("public invitation link stopped"))
	response, err := http.Get(origin + "/api/client-launcher")
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	var state struct {
		Target, Detail string
		Sites          []string
		Starting       bool
	}
	if json.NewDecoder(response.Body).Decode(&state) != nil || state.Target != "" || state.Starting ||
		state.Detail != "public invitation link stopped" || strings.Join(state.Sites, ",") != "https://share.example" {
		t.Fatalf("failed room state = %+v", state)
	}
	response, err = localPost(origin+"/api/client-launcher/site", "application/json",
		strings.NewReader(`{"site":"https://share.example","allowed":false}`))
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		t.Fatalf("failed room blocked approval revocation: %d", response.StatusCode)
	}
}

func TestLauncherRetainsAcceptedSelectionAfterRequestCancellation(t *testing.T) {
	// Cancellation may race the handoff, but cannot discard an accepted launch.
	for range 32 {
		server := &Server{
			ctx:       t.Context(),
			selection: make(chan Selection, 1),
		}
		ctx, cancel := context.WithCancel(t.Context())
		request := httptest.NewRequestWithContext(ctx, http.MethodPost, "/api/client-launcher/launch",
			strings.NewReader(`{"mode":"link","language":"en"}`))
		cancel()
		server.handleLaunch(httptest.NewRecorder(), request)
		select {
		case selection := <-server.Selection():
			if selection != (Selection{Mode: ModeLink, Language: "en"}) {
				t.Fatalf("selection = %+v", selection)
			}
		default:
			t.Fatal("cancelled Browser request left the App starting without a selection")
		}
		if server.Begin() {
			t.Fatal("cancelled Browser request allowed a second launch")
		}
	}
}

type pausedLaunchContext struct {
	context.Context
	waiting chan struct{}
	resume  chan struct{}
}

func (ctx pausedLaunchContext) Done() <-chan struct{} {
	close(ctx.waiting)
	<-ctx.resume
	return ctx.Context.Done()
}

func TestFailedAttemptCanRetryWithoutReplacingAnOlderRequestResult(t *testing.T) {
	server := &Server{ctx: t.Context(), selection: make(chan Selection, 1)}
	// Resume the old HTTP waiter only after the retry has already succeeded.
	firstContext := pausedLaunchContext{t.Context(), make(chan struct{}), make(chan struct{})}
	firstResponse := httptest.NewRecorder()
	firstDone := make(chan struct{})
	go func() {
		defer close(firstDone)
		server.handleLaunch(firstResponse, httptest.NewRequestWithContext(firstContext, "POST", "/api/client-launcher/launch",
			strings.NewReader(`{"mode":"link","language":"en"}`)))
	}()
	select {
	case <-firstContext.waiting:
	case <-time.After(time.Second):
		t.Fatal("first request did not start waiting")
	}
	if selection := <-server.Selection(); selection.Mode != ModeLink {
		t.Fatalf("first selection = %+v", selection)
	}
	if server.Begin() {
		t.Fatal("pending room allowed another start")
	}
	server.SetResult("", errors.New("first attempt failed"))

	secondResponse := httptest.NewRecorder()
	secondDone := make(chan struct{})
	go func() {
		defer close(secondDone)
		server.handleLaunch(secondResponse, httptest.NewRequest("POST", "/api/client-launcher/launch",
			strings.NewReader(`{"mode":"local","language":"en"}`)))
	}()
	select {
	case selection := <-server.Selection():
		if selection.Mode != ModeLocal {
			t.Fatalf("retry selection = %+v", selection)
		}
	case <-time.After(time.Second):
		t.Fatal("failure did not permit retry")
	}
	server.SetResult("http://localhost:8787/#piik-client=1", nil)
	if server.Begin() {
		t.Fatal("successful room allowed replacement")
	}
	close(firstContext.resume)
	for _, done := range []chan struct{}{firstDone, secondDone} {
		select {
		case <-done:
		case <-time.After(time.Second):
			t.Fatal("launch request did not complete")
		}
	}
	if firstResponse.Code != http.StatusServiceUnavailable || !strings.Contains(firstResponse.Body.String(), "first attempt failed") {
		t.Fatalf("old request observed retry result: %d %s", firstResponse.Code, firstResponse.Body.String())
	}
	if secondResponse.Code != http.StatusOK || !strings.Contains(secondResponse.Body.String(), "http://localhost:8787/") {
		t.Fatalf("retry did not return its own success: %d %s", secondResponse.Code, secondResponse.Body.String())
	}
}

func TestLauncherIncludesTheInjectedBuildVersionAndRevision(t *testing.T) {
	const version = "v1.2.3"
	const revision = "0123456789abcdef0123456789abcdef01234567"
	server := startFixtureWithBuildAndPassword(t, "", version, revision, "")
	origin := strings.TrimSuffix(server.URL(), "/client")
	response, err := http.Get(origin + "/api/client-launcher")
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	var state struct {
		Version       string `json:"version"`
		Revision      string `json:"revision"`
		PackageTarget string `json:"packageTarget"`
		DefaultMode   Mode   `json:"defaultMode"`
	}
	packageTarget := runtime.GOOS + "-" + runtime.GOARCH
	if runtime.GOOS == "android" {
		packageTarget = "android-universal"
	}
	if response.StatusCode != http.StatusOK || json.NewDecoder(response.Body).Decode(&state) != nil ||
		state.Version != version || state.Revision != revision ||
		state.PackageTarget != packageTarget || state.DefaultMode != ModeLink {
		t.Fatalf("launcher build = %d, %+v", response.StatusCode, state)
	}
}

func TestLauncherLANChoicesUseCurrentAddressesAndTheExplicitPreference(t *testing.T) {
	for _, test := range []struct {
		name, preferred, selected string
		addresses                 []lan.Address
	}{
		{name: "one", selected: "192.168.1.4", addresses: []lan.Address{{Address: "192.168.1.4", Name: "Wi-Fi"}}},
		{name: "one-private", selected: "192.168.1.4", addresses: []lan.Address{{Address: "192.168.1.4", Name: "Wi-Fi"}, {Address: "198.18.0.1", Name: "Tunnel"}}},
		{name: "ambiguous", addresses: []lan.Address{{Address: "10.0.0.2", Name: "Ethernet"}, {Address: "192.168.1.4", Name: "Wi-Fi"}}},
		{name: "cli-preferred", preferred: "192.168.1.4", selected: "192.168.1.4", addresses: []lan.Address{{Address: "10.0.0.2", Name: "Ethernet"}, {Address: "192.168.1.4", Name: "Wi-Fi"}}},
		{name: "stale-preference", preferred: "192.168.1.4", addresses: []lan.Address{{Address: "10.0.0.2", Name: "Ethernet"}}},
		{name: "unavailable"},
	} {
		t.Run(test.name, func(t *testing.T) {
			original := listLANAddresses
			t.Cleanup(func() { listLANAddresses = original })
			listLANAddresses = func() ([]lan.Address, error) {
				if test.addresses == nil {
					return nil, errors.New("interfaces are unavailable")
				}
				return test.addresses, nil
			}
			server, err := Start(t.Context(), appAssets(), Options{Sites: siteList("https://share.example"), LANAddress: test.preferred})
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = server.Close() })
			response, err := http.Get(strings.TrimSuffix(server.URL(), "/client") + "/api/client-launcher")
			if err != nil {
				t.Fatal(err)
			}
			defer response.Body.Close()
			var state struct {
				DefaultMode Mode
				LAN         *struct {
					Addresses []lan.Address
					Selected  string
				}
			}
			if err := json.NewDecoder(response.Body).Decode(&state); err != nil || response.StatusCode != http.StatusOK ||
				state.DefaultMode != ModeLink || state.LAN == nil || state.LAN.Addresses == nil ||
				state.LAN.Selected != test.selected || len(state.LAN.Addresses) != len(test.addresses) {
				t.Fatalf("LAN choices = %+v, status %d, %v", state, response.StatusCode, err)
			}
			for index, address := range state.LAN.Addresses {
				if address != test.addresses[index] {
					t.Fatalf("LAN interface label lost: %+v", address)
				}
			}
		})
	}
}

func TestLauncherPassesTheChosenLANAddressToTheApp(t *testing.T) {
	server := startFixture(t, "")
	selected := make(chan Selection, 1)
	go func() {
		selected <- <-server.Selection()
		server.SetResult("http://localhost:8787/#piik-client=1", nil)
	}()
	response, err := localPost(strings.TrimSuffix(server.URL(), "/client")+"/api/client-launcher/launch",
		"application/json", strings.NewReader(`{"mode":"local","language":"en","lanAddress":"192.168.1.4"}`))
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		t.Fatalf("selection status = %d", response.StatusCode)
	}
	selection := <-selected
	if selection.LANAddress == nil || *selection.LANAddress != "192.168.1.4" {
		t.Fatalf("selected invitation address was lost: %+v", selection)
	}
}

func TestLauncherPreservesAnOptionalLocalPassword(t *testing.T) {
	for _, password := range []string{"", "x", "中文", " ", "  中文 +&  ", strings.Repeat("x", 256)} {
		t.Run(password, func(t *testing.T) {
			server := startFixtureWithPassword(t, "", password)
			origin := strings.TrimSuffix(server.URL(), "/client")
			stateResponse, err := http.Get(origin + "/api/client-launcher")
			if err != nil {
				t.Fatal(err)
			}
			var state struct {
				LocalAccessPassword string `json:"localAccessPassword"`
			}
			if stateResponse.StatusCode != http.StatusOK ||
				json.NewDecoder(stateResponse.Body).Decode(&state) != nil {
				_ = stateResponse.Body.Close()
				t.Fatal("launcher state was unavailable")
			}
			_ = stateResponse.Body.Close()
			if state.LocalAccessPassword != password {
				t.Fatal("launcher did not expose the saved Local access setting")
			}
			result := make(chan *http.Response, 1)
			payload, err := json.Marshal(Selection{Mode: ModeLocal, Language: "zh", LocalAccessPassword: password})
			if err != nil {
				t.Fatal(err)
			}
			go func() {
				response, err := localPost(
					origin+"/api/client-launcher/launch",
					"application/json",
					bytes.NewReader(payload),
				)
				if err != nil {
					t.Error(err)
					return
				}
				result <- response
			}()
			select {
			case selection := <-server.Selection():
				if selection.Mode != ModeLocal || selection.Language != "zh" || selection.LocalAccessPassword != password {
					t.Fatalf("selection = %+v", selection)
				}
				server.SetResult("http://localhost:8787/#piik-client=1", nil)
			case <-time.After(time.Second):
				t.Fatal("launcher did not emit a selection")
			}
			response := <-result
			defer response.Body.Close()
			if response.StatusCode != http.StatusOK {
				t.Fatalf("launch status = %d", response.StatusCode)
			}
		})
	}
}

func TestLauncherRejectsAnInvalidSavedSite(t *testing.T) {
	if _, err := Start(t.Context(), appAssets(), Options{Sites: siteList("https://example.test/path"), Version: "development"}); err == nil {
		t.Fatal("launcher accepted a Site path")
	}
}

// A binary built without the Browser build has nothing to launch.
func TestLauncherRequiresTheEmbeddedBrowserBuild(t *testing.T) {
	if _, err := Start(t.Context(), nil, Options{Version: "development"}); err == nil {
		t.Fatal("launcher started without embedded assets")
	}
	if _, err := Start(t.Context(), fstest.MapFS{}, Options{Version: "development"}); err == nil {
		t.Fatal("launcher started without an index document")
	}
}

func TestLauncherRejectsInvalidSelections(t *testing.T) {
	for name, payload := range map[string]string{
		"unknown":          `{"mode":"other","language":"en"}`,
		"local-site":       `{"mode":"local","language":"en","site":"https://share.example"}`,
		"missing-site":     `{"mode":"site","language":"en"}`,
		"site-path":        `{"mode":"site","language":"en","site":"https://share.example/path"}`,
		"bare-site-path":   `{"mode":"site","language":"en","site":"share.example/path"}`,
		"site-credentials": `{"mode":"site","language":"en","site":"user:[email protected]"}`,
		"site-password":    `{"mode":"site","language":"en","site":"https://share.example","localAccessPassword":"valid-pass"}`,
		"unknown-field":    `{"mode":"local","language":"en","extra":true}`,
		"password-type":    `{"mode":"local","language":"en","localAccessPassword":123}`,
		"debug-type":       `{"mode":"local","language":"en","debug":"true"}`,
		"lan-type":         `{"mode":"local","language":"en","lanAddress":123}`,
		"lan-invalid":      `{"mode":"local","language":"en","lanAddress":"bad-address"}`,
		"lan-ipv6":         `{"mode":"local","language":"en","lanAddress":"::1"}`,
		"link-lan":         `{"mode":"link","language":"en","lanAddress":"192.168.1.4"}`,
		"link-lan-empty":   `{"mode":"link","language":"en","lanAddress":""}`,
		"site-lan":         `{"mode":"site","language":"en","site":"https://share.example","lanAddress":"192.168.1.4"}`,
		"missing-language": `{"mode":"local"}`,
		"unknown-language": `{"mode":"local","language":"other"}`,
	} {
		t.Run(name, func(t *testing.T) {
			server := startFixture(t, "")
			origin := strings.TrimSuffix(server.URL(), "/client")
			response, err := localPost(
				origin+"/api/client-launcher/launch",
				"application/json",
				bytes.NewBufferString(payload),
			)
			if err != nil {
				t.Fatal(err)
			}
			defer response.Body.Close()
			if response.StatusCode != http.StatusBadRequest {
				t.Fatalf("status = %d", response.StatusCode)
			}
			var failure struct{ Error, Detail string }
			if err := json.NewDecoder(response.Body).Decode(&failure); err != nil || failure.Detail == "" {
				t.Fatalf("invalid selection lost its reason: %+v, %v", failure, err)
			}
		})
	}
}

func TestLauncherReportsSafeBoundedFailureDetails(t *testing.T) {
	server, err := Start(t.Context(), appAssets(), Options{Version: "development", Debug: true})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = server.Close() })
	origin := strings.TrimSuffix(server.URL(), "/client")
	response, err := http.Get(origin + "/api/client-launcher")
	if err != nil {
		t.Fatal(err)
	}
	var state struct{ Debug bool }
	if err := json.NewDecoder(response.Body).Decode(&state); err != nil || !state.Debug {
		t.Fatalf("CLI debug was not advertised: %+v, %v", state, err)
	}
	_ = response.Body.Close()
	cause := errors.New("public tunnel failed: token=private-secret " + strings.Repeat("network unavailable ", 200))
	go func() {
		<-server.Selection()
		server.SetResult("", errors.Join(appfailure.TunnelExited, cause))
	}()
	response, err = localPost(origin+"/api/client-launcher/launch", "application/json",
		strings.NewReader(`{"mode":"link","language":"en"}`))
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	var failure struct{ Error, Detail, Reason string }
	if err := json.NewDecoder(response.Body).Decode(&failure); err != nil || response.StatusCode != http.StatusServiceUnavailable {
		t.Fatalf("failure response = %d, %v", response.StatusCode, err)
	}
	if failure.Reason != string(appfailure.TunnelExited) || failure.Error != "Piik App could not start" || !strings.Contains(failure.Detail, "public tunnel failed") ||
		strings.Contains(failure.Detail, "private-secret") || len([]rune(failure.Detail)) > 2051 {
		t.Fatalf("unsafe or missing failure detail: %+v", failure)
	}
	response, err = http.Get(origin + "/api/client-launcher")
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	var restored struct{ Reason, Detail string }
	if err := json.NewDecoder(response.Body).Decode(&restored); err != nil || restored.Reason != failure.Reason || restored.Detail != failure.Detail {
		t.Fatalf("restored failure = %+v, %v", restored, err)
	}
	if !errors.Is(server.attempt.err, cause) {
		t.Fatal("launcher lost original cause")
	}
}

func TestLauncherAcceptsLocalhostAlias(t *testing.T) {
	server := startFixture(t, "")
	origin := strings.TrimSuffix(server.URL(), "/client")
	request, err := http.NewRequest(
		http.MethodGet,
		origin+"/api/client-launcher",
		nil,
	)
	if err != nil {
		t.Fatal(err)
	}
	request.Host = "localhost:" + strings.TrimPrefix(origin, "http://127.0.0.1:")
	response, err := http.DefaultClient.Do(request)
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		t.Fatalf("localhost status = %d", response.StatusCode)
	}
}

func TestLauncherRejectsCrossOriginControl(t *testing.T) {
	server := startFixture(t, "")
	origin := strings.TrimSuffix(server.URL(), "/client")
	request, err := http.NewRequest(
		http.MethodGet,
		origin+"/api/client-launcher",
		nil,
	)
	if err != nil {
		t.Fatal(err)
	}
	request.Header.Set("Origin", "https://unrelated.example")
	response, err := http.DefaultClient.Do(request)
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusNotFound {
		t.Fatalf("cross-origin status = %d", response.StatusCode)
	}
}

func startFixture(t *testing.T, site string) *Server {
	return startFixtureWithBuildAndPassword(t, site, "development", "", "")
}

func startFixtureWithPassword(t *testing.T, site, password string) *Server {
	return startFixtureWithBuildAndPassword(t, site, "development", "", password)
}

func startFixtureWithBuildAndPassword(
	t *testing.T,
	site, version, revision, password string,
) *Server {
	t.Helper()
	server, err := Start(t.Context(), appAssets(), Options{Sites: siteList(site), Version: version, Revision: revision, LocalAccessPassword: password,
		EnableDebug: func() error { return nil }})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = server.Close() })
	return server
}

func localPost(target, contentType string, body io.Reader) (*http.Response, error) {
	req, err := http.NewRequest(http.MethodPost, target, body)
	if err != nil {
		return nil, err
	}
	address, _ := url.Parse(target)
	req.Header.Set("Origin", address.Scheme+"://"+address.Host)
	req.Header.Set("Content-Type", contentType)
	return (&http.Client{Timeout: 3 * time.Second}).Do(req)
}

func siteList(site string) []string {
	if site == "" {
		return []string{}
	}
	return []string{site}
}