at-container-registry/pkg/appview/domain_routing_test.go

package appview

import (
	"net/http"
	"net/http/httptest"
	"testing"
)

// DomainRoutingMiddleware had no coverage at all, which is how both defects
// below survived into a shipped example config.
//
// The middleware strips the port from the request Host before matching, but
// compares against server.registry_domains verbatim. config-appview.example.yaml
// ships `registry_domains: [127.0.0.1:5000, atcr.io]`, so the first entry can
// never match any request — and because it also equals the auto-detected UI
// host, /v2/* is answered with "registry API is not available on this domain,
// use 127.0.0.1:5000", naming the very host that was used.

const (
	bodyRegistry = "NEXT" // the wrapped handler ran
)

func routingProbe(t *testing.T, registryDomains []string, uiBaseURL, host, path string) *httptest.ResponseRecorder {
	t.Helper()
	next := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(bodyRegistry))
	})
	h := DomainRoutingMiddleware(registryDomains, uiBaseURL)(next)

	req := httptest.NewRequest(http.MethodGet, path, nil)
	req.Host = host
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, req)
	return rec
}

// A port-bearing registry domain must match a request to that host:port.
// The shipped example config depends on this and it does not hold today.
func TestDomainRouting_PortBearingRegistryDomainMatches(t *testing.T) {
	rec := routingProbe(t,
		[]string{"registry.example:5000"},
		"http://ui.example:5000",
		"registry.example:5000",
		"/v2/",
	)
	if rec.Body.String() != bodyRegistry {
		t.Fatalf("registry domain configured with a port did not serve /v2/: status=%d body=%q",
			rec.Code, rec.Body.String())
	}
}

// A single host serving both the UI and the registry is a legitimate
// deployment, and is exactly what the dev stack is. Listing that host in
// registry_domains should grant it /v2/*, but `host == uiHost` is evaluated
// first, so the registry entry is silently ignored.
func TestDomainRouting_SameHostServesBothUIAndRegistry(t *testing.T) {
	const host = "127.0.0.1:5000"

	v2 := routingProbe(t, []string{host}, "http://127.0.0.1:5000", host, "/v2/")
	if v2.Body.String() != bodyRegistry {
		t.Errorf("/v2/ not served when the UI host is also a registry domain: status=%d body=%q",
			v2.Code, v2.Body.String())
	}

	ui := routingProbe(t, []string{host}, "http://127.0.0.1:5000", host, "/settings")
	if ui.Body.String() != bodyRegistry {
		t.Errorf("UI path stopped working on a dual-role host: status=%d body=%q",
			ui.Code, ui.Body.String())
	}
}

// Guard the behaviour that must NOT change: a UI-only host still refuses /v2/.
func TestDomainRouting_UIOnlyHostStillBlocksV2(t *testing.T) {
	rec := routingProbe(t,
		[]string{"registry.example"},
		"http://ui.example",
		"ui.example",
		"/v2/",
	)
	if rec.Body.String() == bodyRegistry {
		t.Fatal("/v2/ was served on a host that is not a registry domain")
	}
}

func TestDomainRouting_RegistryDomainRedirectsNonV2ToUI(t *testing.T) {
	rec := routingProbe(t,
		[]string{"registry.example"},
		"http://ui.example",
		"registry.example",
		"/settings",
	)
	if rec.Code != http.StatusTemporaryRedirect {
		t.Fatalf("expected 307 to the UI, got %d", rec.Code)
	}
	if got := rec.Header().Get("Location"); got != "http://ui.example/settings" {
		t.Fatalf("unexpected redirect target %q", got)
	}
}

// Auth endpoints stay on the registry domain: a cross-host 307 would strip the
// Authorization header.
func TestDomainRouting_AuthEndpointsServedOnRegistryDomain(t *testing.T) {
	for _, path := range []string{"/auth/token", "/auth/device/code"} {
		rec := routingProbe(t, []string{"registry.example"}, "http://ui.example", "registry.example", path)
		if rec.Body.String() != bodyRegistry {
			t.Errorf("%s was not served directly on the registry domain: status=%d", path, rec.Code)
		}
	}
}

func TestDomainRouting_UnknownHostRedirectsExceptHealth(t *testing.T) {
	rec := routingProbe(t, []string{"registry.example"}, "http://ui.example", "cdn.origin", "/")
	if rec.Code != http.StatusTemporaryRedirect {
		t.Errorf("unknown host should 307, got %d", rec.Code)
	}

	health := routingProbe(t, []string{"registry.example"}, "http://ui.example", "cdn.origin", "/health")
	if health.Body.String() != bodyRegistry {
		t.Errorf("/health should be served on unknown hosts, got status=%d", health.Code)
	}
}