niuniu/supply-intelligence
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: sync local project state

Browse Source
This commit is contained in:
Your Name
2026-05-12 18:49:52 +08:00
parent afdbea6fb5
commit 1c0084afe8
105 changed files with 13221 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
internal/httpapi/server_test.go
View File

@@ -1,5 +1,7 @@
package httpapi
import "context"
import (
"bytes"
"encoding/json"
@@ -8,9 +10,11 @@ import (
"testing"
"time"
"supply-intelligence/internal/admission"
"supply-intelligence/internal/discovery"
"supply-intelligence/internal/domain"
"supply-intelligence/internal/gatewayconsumer"
"supply-intelligence/internal/poller"
"supply-intelligence/internal/probe"
"supply-intelligence/internal/publish"
"supply-intelligence/internal/repository"
@@ -18,7 +22,7 @@ import (
func TestServerRoutingStateEndpoint(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.UpsertRoutingState(domain.AccountRoutingState{
repo.UpsertRoutingState(context.Background(), domain.AccountRoutingState{
AccountID: 101,
Platform: "openai",
AccountStatus: domain.AccountStatusActive,
@@ -28,7 +32,7 @@ func TestServerRoutingStateEndpoint(t *testing.T) {
LastProbeAt: time.Unix(100, 0).UTC(),
Version: 3,
})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/accounts/101/routing-state", nil)
rr := httptest.NewRecorder()
@@ -88,7 +92,7 @@ func TestServerProbeEvaluateEndpointPaths(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
repo := repository.NewMemoryRepository()
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/probe/evaluate", bytes.NewBufferString(tt.body))
rr := httptest.NewRecorder()
@@ -118,9 +122,21 @@ func TestServerProbeEvaluateEndpointPaths(t *testing.T) {
func TestServerPublishPackageEventEndpoint(t *testing.T) {
repo := repository.NewMemoryRepository()
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
repo.UpsertDiscoveryCandidateContext(context.Background(), domain.DiscoveryCandidate{
CandidateID: "cand-http-publish",
AccountID: 501,
Platform: "openai",
Model: "gpt-4.1-mini",
Source: "admission",
Status: domain.DiscoveryCandidateStatusTestPassed,
DiscoveredAt: time.Unix(100, 0).UTC(),
UpdatedAt: time.Unix(110, 0).UTC(),
Version: 2,
})
repo.UpsertSupplyPackage(context.Background(), domain.SupplyPackage{PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", Status: "draft", Source: "admission", UpdatedAt: time.Unix(110, 0).UTC(), Version: 1})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
body := bytes.NewBufferString(`{"event_id":"evt-1","package_id":1001,"platform":"openai","model":"gpt-4.1-mini","version":7,"occurred_at":"2026-05-06T20:30:00Z"}`)
body := bytes.NewBufferString(`{"event_id":"evt-1","platform":"openai","model":"gpt-4.1-mini","occurred_at":"2026-05-06T20:30:00Z"}`)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/publish/package-event", body)
rr := httptest.NewRecorder()
server.Routes().ServeHTTP(rr, req)
@@ -128,22 +144,33 @@ func TestServerPublishPackageEventEndpoint(t *testing.T) {
t.Fatalf("unexpected publish status: %d body=%s", rr.Code, rr.Body.String())
}
var event domain.PackageChangeEvent
if err := json.NewDecoder(rr.Body).Decode(&event); err != nil {
var out struct {
Candidate domain.DiscoveryCandidate `json:"candidate"`
Package domain.SupplyPackage `json:"package"`
Event domain.PackageChangeEvent `json:"event"`
GatewaySyncStatus domain.GatewaySyncStatus `json:"gateway_sync_status"`
}
if err := json.NewDecoder(rr.Body).Decode(&out); err != nil {
t.Fatalf("decode error: %v", err)
}
if event.EventID != "evt-1" || event.EventType != publish.PackagePublishedEventType {
t.Fatalf("unexpected event: %+v", event)
if out.Candidate.Status != domain.DiscoveryCandidateStatusPublished {
t.Fatalf("unexpected candidate: %+v", out.Candidate)
}
if event.GatewaySyncStatus != domain.GatewaySyncStatusPending {
t.Fatalf("unexpected sync status: %q", event.GatewaySyncStatus)
if out.Package.Status != "active" {
t.Fatalf("unexpected package: %+v", out.Package)
}
if out.Event.EventID != "evt-1" || out.Event.EventType != publish.PackagePublishedEventType {
t.Fatalf("unexpected event: %+v", out.Event)
}
if out.GatewaySyncStatus != domain.GatewaySyncStatusPending {
t.Fatalf("unexpected sync status: %q", out.GatewaySyncStatus)
}
}
func TestServerPackageChangeListAndAck(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.AppendPackageEvent(domain.PackageChangeEvent{EventID: "evt-1", EventType: publish.PackagePublishedEventType, PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(5, 0).UTC(), Version: 7, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-1", EventType: publish.PackagePublishedEventType, PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(5, 0).UTC(), Version: 7, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
listReq := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/gateway/package-changes", nil)
listRR := httptest.NewRecorder()
@@ -158,7 +185,7 @@ func TestServerPackageChangeListAndAck(t *testing.T) {
if err := json.NewDecoder(listRR.Body).Decode(&listResp); err != nil {
t.Fatalf("decode list error: %v", err)
}
if len(listResp.Items) != 1 || listResp.NextCursor != "1" {
if len(listResp.Items) != 1 || listResp.NextCursor != "" {
t.Fatalf("unexpected list response: %+v", listResp)
}
@@ -168,19 +195,58 @@ func TestServerPackageChangeListAndAck(t *testing.T) {
if ackRR.Code != http.StatusNoContent {
t.Fatalf("unexpected ack status: %d body=%s", ackRR.Code, ackRR.Body.String())
}
updated, _ := repo.ListPackageEventsAfter("")
updated, _ := repo.ListPackageEventsAfter(context.Background(), "")
if len(updated) != 1 || updated[0].GatewaySyncStatus != domain.GatewaySyncStatusApplied {
t.Fatalf("unexpected ack state: %+v", updated)
}
}
func TestServerPackageChangeAckMissingEventReturnsNotFound(t *testing.T) {
repo := repository.NewMemoryRepository()
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
ackReq := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/package-changes/evt-missing/ack", bytes.NewBufferString(`{"consumer":"gateway","result":"applied","detail":"ok"}`))
ackRR := httptest.NewRecorder()
server.Routes().ServeHTTP(ackRR, ackReq)
if ackRR.Code != http.StatusNotFound {
t.Fatalf("unexpected ack status: %d body=%s", ackRR.Code, ackRR.Body.String())
}
var payload map[string]string
if err := json.NewDecoder(ackRR.Body).Decode(&payload); err != nil {
t.Fatalf("decode ack missing error: %v", err)
}
if payload["error"] != "not_found" {
t.Fatalf("unexpected ack missing payload: %+v", payload)
}
}
func TestServerPackageChangeAckRejectsInvalidResult(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-ack-invalid", EventType: publish.PackagePublishedEventType, PackageID: 1003, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(7, 0).UTC(), Version: 9, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
ackReq := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/package-changes/evt-ack-invalid/ack", bytes.NewBufferString(`{"consumer":"gateway","result":"unknown","detail":"bad"}`))
ackRR := httptest.NewRecorder()
server.Routes().ServeHTTP(ackRR, ackReq)
if ackRR.Code != http.StatusBadRequest {
t.Fatalf("unexpected invalid-result ack status: %d body=%s", ackRR.Code, ackRR.Body.String())
}
var payload map[string]string
if err := json.NewDecoder(ackRR.Body).Decode(&payload); err != nil {
t.Fatalf("decode invalid-result ack error: %v", err)
}
if payload["error"] != "invalid_result" {
t.Fatalf("unexpected invalid-result ack payload: %+v", payload)
}
}
func TestServerPackageChangeListWithCursor(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.AppendPackageEvent(domain.PackageChangeEvent{EventID: "evt-1", EventType: publish.PackagePublishedEventType, PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(5, 0).UTC(), Version: 7, GatewaySyncStatus: domain.GatewaySyncStatusPending})
repo.AppendPackageEvent(domain.PackageChangeEvent{EventID: "evt-2", EventType: publish.PackagePublishedEventType, PackageID: 1002, Platform: "openai", Model: "gpt-4.1", OccurredAt: time.Unix(6, 0).UTC(), Version: 8, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-1", EventType: publish.PackagePublishedEventType, PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(5, 0).UTC(), Version: 7, GatewaySyncStatus: domain.GatewaySyncStatusPending})
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-2", EventType: publish.PackagePublishedEventType, PackageID: 1002, Platform: "openai", Model: "gpt-4.1", OccurredAt: time.Unix(6, 0).UTC(), Version: 8, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/gateway/package-changes?cursor=1", nil)
req := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/gateway/package-changes?cursor=evt-1", nil)
rr := httptest.NewRecorder()
server.Routes().ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
@@ -193,16 +259,16 @@ func TestServerPackageChangeListWithCursor(t *testing.T) {
if err := json.NewDecoder(rr.Body).Decode(&resp); err != nil {
t.Fatalf("decode error: %v", err)
}
if len(resp.Items) != 1 || resp.Items[0].EventID != "evt-2" || resp.NextCursor != "2" {
if len(resp.Items) != 1 || resp.Items[0].EventID != "evt-2" || resp.NextCursor != "" {
t.Fatalf("unexpected cursor response: %+v", resp)
}
}
func TestServerConsumeOnceEndpoint(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.AppendPackageEvent(domain.PackageChangeEvent{EventID: "evt-apply", EventType: publish.PackagePublishedEventType, PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(5, 0).UTC(), Version: 7, GatewaySyncStatus: domain.GatewaySyncStatusPending})
repo.AppendPackageEvent(domain.PackageChangeEvent{EventID: "evt-fail", EventType: publish.PackagePublishedEventType, PackageID: 1002, Platform: "openai", Model: "gpt-fail-model", OccurredAt: time.Unix(6, 0).UTC(), Version: 8, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-apply", EventType: publish.PackagePublishedEventType, PackageID: 1001, Platform: "openai", Model: "gpt-4.1-mini", OccurredAt: time.Unix(5, 0).UTC(), Version: 7, GatewaySyncStatus: domain.GatewaySyncStatusPending})
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-fail", EventType: publish.PackagePublishedEventType, PackageID: 1002, Platform: "openai", Model: "gpt-fail-model", OccurredAt: time.Unix(6, 0).UTC(), Version: 8, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/consume-once", bytes.NewBufferString(`{"consumer":"gateway"}`))
rr := httptest.NewRecorder()
@@ -225,9 +291,146 @@ func TestServerConsumeOnceEndpoint(t *testing.T) {
}
}
func TestServerConsumeOnceSkipsUnauthorizedAndLeavesPending(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.UpsertSupplyAccount(context.Background(), domain.SupplyAccount{AccountID: 2001, Platform: "openai", APIKey: "key-other", ConsumerTag: "other-consumer", Status: "active", CreatedAt: time.Unix(1, 0).UTC(), UpdatedAt: time.Unix(1, 0).UTC()})
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-unauthorized", EventType: publish.PackagePublishedEventType, PackageID: 2001, AccountID: 2001, Platform: "openai", Model: "gpt-4.1-unauthorized", OccurredAt: time.Unix(8, 0).UTC(), Version: 10, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/consume-once", bytes.NewBufferString(`{"consumer":"gateway"}`))
rr := httptest.NewRecorder()
server.Routes().ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("unexpected consume status: %d body=%s", rr.Code, rr.Body.String())
}
var out gatewayconsumer.ConsumeOnceOutput
if err := json.NewDecoder(rr.Body).Decode(&out); err != nil {
t.Fatalf("decode error: %v", err)
}
if len(out.Items) != 0 {
t.Fatalf("expected unauthorized event to be skipped, got %+v", out.Items)
}
items, _ := repo.ListPackageEventsAfter(context.Background(), "")
if len(items) != 1 || items[0].GatewaySyncStatus != domain.GatewaySyncStatusPending {
t.Fatalf("expected unauthorized event to remain pending, got %+v", items)
}
}
func TestServerConsumeOnceSkipsNonPendingEvents(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-applied-existing", EventType: publish.PackagePublishedEventType, PackageID: 2002, Platform: "openai", Model: "gpt-4.1-applied", OccurredAt: time.Unix(9, 0).UTC(), Version: 11, GatewaySyncStatus: domain.GatewaySyncStatusApplied})
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-failed-existing", EventType: publish.PackagePublishedEventType, PackageID: 2003, Platform: "openai", Model: "gpt-4.1-failed-existing", OccurredAt: time.Unix(10, 0).UTC(), Version: 12, GatewaySyncStatus: domain.GatewaySyncStatusFailed})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/consume-once", bytes.NewBufferString(`{"consumer":"gateway"}`))
rr := httptest.NewRecorder()
server.Routes().ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("unexpected consume status: %d body=%s", rr.Code, rr.Body.String())
}
var out gatewayconsumer.ConsumeOnceOutput
if err := json.NewDecoder(rr.Body).Decode(&out); err != nil {
t.Fatalf("decode error: %v", err)
}
if len(out.Items) != 0 {
t.Fatalf("expected no items for non-pending events, got %+v", out.Items)
}
}
func TestServerConsumeOnceFailedDoesNotDriftSnapshot(t *testing.T) {
repo := repository.NewMemoryRepository()
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-apply-first", EventType: publish.PackagePublishedEventType, PackageID: 2004, Platform: "openai", Model: "gpt-4.1-first", OccurredAt: time.Unix(11, 0).UTC(), Version: 13, GatewaySyncStatus: domain.GatewaySyncStatusPending})
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-fail-second", EventType: publish.PackagePublishedEventType, PackageID: 2005, Platform: "openai", Model: "gpt-fail-second", OccurredAt: time.Unix(12, 0).UTC(), Version: 14, GatewaySyncStatus: domain.GatewaySyncStatusPending})
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/consume-once", bytes.NewBufferString(`{"consumer":"gateway"}`))
rr := httptest.NewRecorder()
server.Routes().ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("unexpected consume status: %d body=%s", rr.Code, rr.Body.String())
}
snapshot, ok := repo.GetGatewayAppliedSnapshot(context.Background(), "gateway")
if !ok {
t.Fatal("expected gateway snapshot")
}
if snapshot.LastEventID != "evt-apply-first" || snapshot.LastPackageID != 2004 || snapshot.LastResult != string(domain.GatewayAckResultApplied) {
t.Fatalf("expected snapshot to stay on last applied event, got %+v", snapshot)
}
items, _ := repo.ListPackageEventsAfter(context.Background(), "")
statusByID := map[string]domain.GatewaySyncStatus{}
for _, item := range items {
statusByID[item.EventID] = item.GatewaySyncStatus
}
if statusByID["evt-apply-first"] != domain.GatewaySyncStatusApplied || statusByID["evt-fail-second"] != domain.GatewaySyncStatusFailed {
t.Fatalf("unexpected event statuses after consume: %+v", statusByID)
}
}
func TestServerGatewayRuntimeStatusReportsCountsAndPauseResumeEndpoints(t *testing.T) {
repo := repository.NewMemoryRepository()
nextRetryAt := time.Unix(1, 0).UTC()
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-runtime-retry", EventType: publish.PackagePublishedEventType, PackageID: 3001, Platform: "openai", Model: "gpt-4.1-retry", OccurredAt: time.Unix(20, 0).UTC(), Version: 15, GatewaySyncStatus: domain.GatewaySyncStatusPending, RetryCount: 1, NextRetryAt: &nextRetryAt, LastFailureCategory: domain.GatewayFailureCategoryTemporaryTimeout})
repo.AppendPackageEvent(context.Background(), domain.PackageChangeEvent{EventID: "evt-runtime-failed", EventType: publish.PackagePublishedEventType, PackageID: 3002, Platform: "openai", Model: "gpt-4.1-failed", OccurredAt: time.Unix(21, 0).UTC(), Version: 16, GatewaySyncStatus: domain.GatewaySyncStatusFailed, LastFailureCategory: domain.GatewayFailureCategoryContractInvalid})
service := gatewayconsumer.NewService(repo)
runtime := poller.NewRuntime(poller.NewGatewayPackagePoller(service), time.Second)
if !runtime.Pause() {
t.Fatal("expected pause before start to succeed")
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if !runtime.Start(ctx) {
t.Fatal("expected runtime to start")
}
defer runtime.Stop()
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), service, runtime, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
statusReq := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/gateway/runtime-status", nil)
statusRR := httptest.NewRecorder()
server.Routes().ServeHTTP(statusRR, statusReq)
if statusRR.Code != http.StatusOK {
t.Fatalf("unexpected runtime-status status: %d body=%s", statusRR.Code, statusRR.Body.String())
}
var statusBody struct {
Started bool `json:"started"`
Paused bool `json:"paused"`
PendingRetryEvents int `json:"pending_retry_events"`
FailedEvents int `json:"failed_events"`
LastError string `json:"last_error"`
}
if err := json.NewDecoder(statusRR.Body).Decode(&statusBody); err != nil {
t.Fatalf("decode runtime-status response: %v", err)
}
if !statusBody.Started || !statusBody.Paused {
t.Fatalf("expected started and paused runtime, got %+v", statusBody)
}
if statusBody.PendingRetryEvents != 1 || statusBody.FailedEvents != 1 {
t.Fatalf("unexpected runtime counters: %+v", statusBody)
}
if statusBody.LastError != "" {
t.Fatalf("expected empty last_error, got %+v", statusBody)
}
pauseReq := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/runtime/pause", nil)
pauseRR := httptest.NewRecorder()
server.Routes().ServeHTTP(pauseRR, pauseReq)
if pauseRR.Code != http.StatusOK {
t.Fatalf("unexpected pause status: %d body=%s", pauseRR.Code, pauseRR.Body.String())
}
resumeReq := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/gateway/runtime/resume", nil)
resumeRR := httptest.NewRecorder()
server.Routes().ServeHTTP(resumeRR, resumeReq)
if resumeRR.Code != http.StatusOK {
t.Fatalf("unexpected resume status: %d body=%s", resumeRR.Code, resumeRR.Body.String())
}
if runtime.Status().Paused {
t.Fatalf("expected runtime resumed, got %+v", runtime.Status())
}
}
func TestServerDiscoveryCandidateCreateAndList(t *testing.T) {
repo := repository.NewMemoryRepository()
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
createReq := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/discovery/candidates", bytes.NewBufferString(`{"candidate_id":"cand-1","account_id":301,"platform":"openai","model":"gpt-4.1-mini","source":"manual_seed","reason_code":"new_model","discovered_at":"2026-05-06T20:30:00Z"}`))
createRR := httptest.NewRecorder()
@@ -236,7 +439,7 @@ func TestServerDiscoveryCandidateCreateAndList(t *testing.T) {
t.Fatalf("unexpected create status: %d body=%s", createRR.Code, createRR.Body.String())
}
listReq := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/discovery/candidates?status=pending_admission", nil)
listReq := httptest.NewRequest(http.MethodGet, "/internal/supply-intelligence/discovery/candidates", nil)
listRR := httptest.NewRecorder()
server.Routes().ServeHTTP(listRR, listReq)
if listRR.Code != http.StatusOK {
@@ -248,14 +451,14 @@ func TestServerDiscoveryCandidateCreateAndList(t *testing.T) {
if err := json.NewDecoder(listRR.Body).Decode(&listResp); err != nil {
t.Fatalf("decode list error: %v", err)
}
if len(listResp.Items) != 1 || listResp.Items[0].CandidateID != "cand-1" || listResp.Items[0].Status != domain.DiscoveryCandidateStatusPendingAdmission {
if len(listResp.Items) != 1 || listResp.Items[0].CandidateID != "cand-1" || listResp.Items[0].Status != domain.DiscoveryCandidateStatusDiscovered {
t.Fatalf("unexpected discovery list response: %+v", listResp.Items)
}
}
func TestServerDiscoveryCandidateRejectsInvalidInput(t *testing.T) {
repo := repository.NewMemoryRepository()
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), discovery.NewService(repo), nil)
server := NewServer(repo, probe.NewService(repo), publish.NewService(repo), gatewayconsumer.NewService(repo), nil, discovery.NewService(repo), admission.NewService(nil, nil, []admission.TestSuite{}, nil, nil), nil, nil)
req := httptest.NewRequest(http.MethodPost, "/internal/supply-intelligence/discovery/candidates", bytes.NewBufferString(`{"candidate_id":"","account_id":0}`))
rr := httptest.NewRecorder()