feat(release):完成双 release 运维闭环

internal/api/release_http_test.go

@@ -0,0 +1,175 @@
+package api
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"bat-api/internal/backendrpc"
+)
+
+type releaseBackendStub struct {
+	*fakeBackend
+	root               string
+	available          bool
+	distributionParams []backendrpc.ReleaseDistributionParams
+}
+
+func (b *controlBackend) ReleaseStatus(context.Context) (*backendrpc.ReleaseStatusReport, error) {
+	b.calls = append(b.calls, "release.status")
+	return &backendrpc.ReleaseStatusReport{Status: "ready", StatusCode: "distribution.ready"}, nil
+}
+
+func (b *controlBackend) ReleaseList(context.Context, backendrpc.ReleaseListParams) (*backendrpc.ReleaseListReport, error) {
+	b.calls = append(b.calls, "release.list")
+	return &backendrpc.ReleaseListReport{Status: "ready", StatusCode: "distribution.ready"}, nil
+}
+
+func (b *controlBackend) ReleaseDistribution(context.Context, backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	b.calls = append(b.calls, "release.distribution")
+	return &backendrpc.ReleaseDistributionPage{Available: false, StatusCode: "distribution.blocked"}, nil
+}
+
+func (b *controlBackend) ReleaseCleanup(context.Context, backendrpc.ReleaseCleanupParams) (*backendrpc.ReleaseCleanupReport, error) {
+	b.calls = append(b.calls, "release.cleanup")
+	return &backendrpc.ReleaseCleanupReport{PlanID: "plan-1"}, nil
+}
+
+func (b *releaseBackendStub) ReleaseStatus(context.Context) (*backendrpc.ReleaseStatusReport, error) {
+	return &backendrpc.ReleaseStatusReport{
+		Status:                     "ready",
+		StatusCode:                 "distribution.ready",
+		OfficialCurrentReleaseID:   "official-1",
+		DefaultDistributionChannel: "official",
+		OfficialDistributionReady:  true,
+	}, nil
+}
+
+func (b *releaseBackendStub) ReleaseList(context.Context, backendrpc.ReleaseListParams) (*backendrpc.ReleaseListReport, error) {
+	return &backendrpc.ReleaseListReport{
+		Status:     "ready",
+		StatusCode: "distribution.ready",
+		Releases: []backendrpc.ReleaseSummary{{
+			Channel:                     "localized",
+			ID:                          "localized-1",
+			ManifestContractStatus:      "valid",
+			ArtifactIntegrityStatus:     "valid",
+			DistributionIntegrityStatus: "valid",
+		}},
+	}, nil
+}
+
+func (b *releaseBackendStub) ReleaseDistribution(_ context.Context, params backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	b.distributionParams = append(b.distributionParams, params)
+	return &backendrpc.ReleaseDistributionPage{
+		Available:               b.available,
+		Channel:                 params.Channel,
+		ReleaseID:               params.ReleaseID,
+		ResourceRoot:            b.root,
+		Status:                  "ready",
+		StatusCode:              "distribution.ready",
+		ArtifactIntegrityStatus: "valid",
+		Total:                   1,
+		Limit:                   1000,
+		Entries: []backendrpc.ReleaseDistributionEntry{{
+			URL:         "https://prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes",
+			Destination: "prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes",
+			Bytes:       21,
+			BLAKE3:      "not-used-by-http-index",
+		}},
+	}, nil
+}
+
+func (*releaseBackendStub) ReleaseCleanup(context.Context, backendrpc.ReleaseCleanupParams) (*backendrpc.ReleaseCleanupReport, error) {
+	return &backendrpc.ReleaseCleanupReport{PlanID: "plan-1"}, nil
+}
+
+func TestReleaseHTTPForwardsTypedSelectionAndDoesNotFallback(t *testing.T) {
+	cfg := DefaultConfig()
+	if err := cfg.Normalize(); err != nil {
+		t.Fatal(err)
+	}
+	backend := &releaseBackendStub{fakeBackend: &fakeBackend{}, root: fixtureRoot(t), available: true}
+	server := NewServer(cfg, backend, nil)
+
+	recorder := httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/v1/releases?channel=localized", nil))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("release list status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/v1/distribution?channel=localized&release_id=localized-1&offset=2&limit=10", nil))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("distribution status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	if len(backend.distributionParams) != 1 ||
+		backend.distributionParams[0].Channel != "localized" ||
+		backend.distributionParams[0].ReleaseID != "localized-1" ||
+		backend.distributionParams[0].Offset != 2 ||
+		backend.distributionParams[0].Limit != 10 {
+		t.Fatalf("distribution params=%#v", backend.distributionParams)
+	}
+
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes?channel=localized&release_id=localized-1", nil))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("localized CDN status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	if recorder.Body.String() != "TABLE_CATALOG_FIXTURE" {
+		t.Fatalf("localized CDN body=%q", recorder.Body.String())
+	}
+
+	cfg.RequireIndexed = false
+	unindexedServer := NewServer(cfg, backend, nil)
+	recorder = httptest.NewRecorder()
+	unindexedServer.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/not-listed.bytes?channel=localized&release_id=localized-1", nil))
+	if recorder.Code != http.StatusNotFound {
+		t.Fatalf("unlisted localized CDN status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+
+	blocked := &releaseBackendStub{fakeBackend: &fakeBackend{}, root: fixtureRoot(t), available: false}
+	blockedServer := NewServer(cfg, blocked, nil)
+	recorder = httptest.NewRecorder()
+	blockedServer.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes?channel=localized", nil))
+	if recorder.Code != http.StatusConflict {
+		t.Fatalf("blocked localized CDN status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+}
+
+func TestAdminReleaseCleanupRequiresAuthAndForwards(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.AuthToken = "control-token"
+	if err := cfg.Normalize(); err != nil {
+		t.Fatal(err)
+	}
+	backend := &controlBackend{fakeBackend: &fakeBackend{}}
+	server := NewServer(cfg, backend, nil)
+
+	recorder := httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/admin/control/release-cleanup", nil))
+	if recorder.Code != http.StatusUnauthorized {
+		t.Fatalf("unauthenticated cleanup status=%d", recorder.Code)
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "/admin/control/release-cleanup", strings.NewReader(`{"execute":false}`))
+	request.Header.Set("Authorization", "Bearer control-token")
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusAccepted {
+		t.Fatalf("dry-run cleanup status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	if len(backend.calls) != 1 || backend.calls[0] != "release.cleanup" {
+		t.Fatalf("calls=%v", backend.calls)
+	}
+
+	request = httptest.NewRequest(http.MethodPost, "/admin/control/release-cleanup", strings.NewReader(`{"execute":true}`))
+	request.Header.Set("Authorization", "Bearer control-token")
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusBadRequest {
+		t.Fatalf("missing plan cleanup status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+}