1489 lines
41 KiB
Go
1489 lines
41 KiB
Go
package httpapi
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"errors"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"strings"
|
||
"testing"
|
||
"time"
|
||
|
||
"lijiaoqiao/supply-api/internal/audit"
|
||
"lijiaoqiao/supply-api/internal/domain"
|
||
"lijiaoqiao/supply-api/internal/middleware"
|
||
)
|
||
|
||
// ==================== Mock Implementations ====================
|
||
|
||
// mockAccountService Mock账户服务
|
||
type mockAccountService struct {
|
||
verifyResult *domain.VerifyResult
|
||
verifyErr error
|
||
account *domain.Account
|
||
createErr error
|
||
activateErr error
|
||
suspendErr error
|
||
deleteErr error
|
||
lastVerifySupplierID int64
|
||
}
|
||
|
||
func (m *mockAccountService) Verify(ctx context.Context, supplierID int64, provider domain.Provider, accountType domain.AccountType, credential string) (*domain.VerifyResult, error) {
|
||
m.lastVerifySupplierID = supplierID
|
||
if m.verifyErr != nil {
|
||
return nil, m.verifyErr
|
||
}
|
||
return m.verifyResult, nil
|
||
}
|
||
|
||
func (m *mockAccountService) Create(ctx context.Context, req *domain.CreateAccountRequest) (*domain.Account, error) {
|
||
if m.createErr != nil {
|
||
return nil, m.createErr
|
||
}
|
||
return m.account, nil
|
||
}
|
||
|
||
func (m *mockAccountService) Activate(ctx context.Context, supplierID, accountID int64) (*domain.Account, error) {
|
||
if m.activateErr != nil {
|
||
return nil, m.activateErr
|
||
}
|
||
return m.account, nil
|
||
}
|
||
|
||
func (m *mockAccountService) Suspend(ctx context.Context, supplierID, accountID int64) (*domain.Account, error) {
|
||
if m.suspendErr != nil {
|
||
return nil, m.suspendErr
|
||
}
|
||
return m.account, nil
|
||
}
|
||
|
||
func (m *mockAccountService) Delete(ctx context.Context, supplierID, accountID int64) error {
|
||
return m.deleteErr
|
||
}
|
||
|
||
func (m *mockAccountService) GetByID(ctx context.Context, supplierID, accountID int64) (*domain.Account, error) {
|
||
return m.account, nil
|
||
}
|
||
|
||
// mockPackageService Mock套餐服务
|
||
type mockPackageService struct {
|
||
pkg *domain.Package
|
||
createDraftErr error
|
||
publishErr error
|
||
pauseErr error
|
||
unlistErr error
|
||
cloneErr error
|
||
batchResp *domain.BatchUpdatePriceResponse
|
||
batchErr error
|
||
}
|
||
|
||
func (m *mockPackageService) CreateDraft(ctx context.Context, supplierID int64, req *domain.CreatePackageDraftRequest) (*domain.Package, error) {
|
||
if m.createDraftErr != nil {
|
||
return nil, m.createDraftErr
|
||
}
|
||
return m.pkg, nil
|
||
}
|
||
|
||
func (m *mockPackageService) Publish(ctx context.Context, supplierID, packageID int64) (*domain.Package, error) {
|
||
if m.publishErr != nil {
|
||
return nil, m.publishErr
|
||
}
|
||
return m.pkg, nil
|
||
}
|
||
|
||
func (m *mockPackageService) Pause(ctx context.Context, supplierID, packageID int64) (*domain.Package, error) {
|
||
if m.pauseErr != nil {
|
||
return nil, m.pauseErr
|
||
}
|
||
return m.pkg, nil
|
||
}
|
||
|
||
func (m *mockPackageService) Unlist(ctx context.Context, supplierID, packageID int64) (*domain.Package, error) {
|
||
if m.unlistErr != nil {
|
||
return nil, m.unlistErr
|
||
}
|
||
return m.pkg, nil
|
||
}
|
||
|
||
func (m *mockPackageService) Clone(ctx context.Context, supplierID, packageID int64) (*domain.Package, error) {
|
||
if m.cloneErr != nil {
|
||
return nil, m.cloneErr
|
||
}
|
||
return m.pkg, nil
|
||
}
|
||
|
||
func (m *mockPackageService) BatchUpdatePrice(ctx context.Context, supplierID int64, req *domain.BatchUpdatePriceRequest) (*domain.BatchUpdatePriceResponse, error) {
|
||
if m.batchErr != nil {
|
||
return nil, m.batchErr
|
||
}
|
||
return m.batchResp, nil
|
||
}
|
||
|
||
func (m *mockPackageService) GetByID(ctx context.Context, supplierID, packageID int64) (*domain.Package, error) {
|
||
return m.pkg, nil
|
||
}
|
||
|
||
// mockSettlementService Mock结算服务
|
||
type mockSettlementService struct {
|
||
settlement *domain.Settlement
|
||
withdrawErr error
|
||
cancelErr error
|
||
getErr error
|
||
}
|
||
|
||
func (m *mockSettlementService) Withdraw(ctx context.Context, supplierID int64, req *domain.WithdrawRequest) (*domain.Settlement, error) {
|
||
if m.withdrawErr != nil {
|
||
return nil, m.withdrawErr
|
||
}
|
||
return m.settlement, nil
|
||
}
|
||
|
||
func (m *mockSettlementService) Cancel(ctx context.Context, supplierID, settlementID int64) (*domain.Settlement, error) {
|
||
if m.cancelErr != nil {
|
||
return nil, m.cancelErr
|
||
}
|
||
return m.settlement, nil
|
||
}
|
||
|
||
func (m *mockSettlementService) GetByID(ctx context.Context, supplierID, settlementID int64) (*domain.Settlement, error) {
|
||
if m.getErr != nil {
|
||
return nil, m.getErr
|
||
}
|
||
return m.settlement, nil
|
||
}
|
||
|
||
func (m *mockSettlementService) List(ctx context.Context, supplierID int64) ([]*domain.Settlement, error) {
|
||
if m.settlement != nil {
|
||
return []*domain.Settlement{m.settlement}, nil
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
func (m *mockSettlementService) GetBillingSummary(ctx context.Context, supplierID int64, startDate, endDate string) (*domain.BillingSummary, error) {
|
||
return nil, nil
|
||
}
|
||
|
||
// mockEarningService Mock收益服务
|
||
type mockEarningService struct {
|
||
records []*domain.EarningRecord
|
||
total int
|
||
billingSummary *domain.BillingSummary
|
||
listErr error
|
||
billingErr error
|
||
}
|
||
|
||
func (m *mockEarningService) ListRecords(ctx context.Context, supplierID int64, startDate, endDate string, page, pageSize int) ([]*domain.EarningRecord, int, error) {
|
||
if m.listErr != nil {
|
||
return nil, 0, m.listErr
|
||
}
|
||
return m.records, m.total, nil
|
||
}
|
||
|
||
func (m *mockEarningService) GetBillingSummary(ctx context.Context, supplierID int64, startDate, endDate string) (*domain.BillingSummary, error) {
|
||
if m.billingErr != nil {
|
||
return nil, m.billingErr
|
||
}
|
||
return m.billingSummary, nil
|
||
}
|
||
|
||
// mockAuditStore Mock审计存储
|
||
type mockAuditStore struct {
|
||
events []audit.Event
|
||
event audit.Event
|
||
err error
|
||
}
|
||
|
||
func (m *mockAuditStore) Emit(ctx context.Context, event audit.Event) error {
|
||
return m.err
|
||
}
|
||
|
||
func (m *mockAuditStore) Query(ctx context.Context, filter audit.EventFilter) ([]audit.Event, error) {
|
||
if m.err != nil {
|
||
return nil, m.err
|
||
}
|
||
return m.events, nil
|
||
}
|
||
|
||
func (m *mockAuditStore) QueryWithTotal(ctx context.Context, filter audit.EventFilter) ([]audit.Event, int64, error) {
|
||
if m.err != nil {
|
||
return nil, 0, m.err
|
||
}
|
||
return m.events, int64(len(m.events)), nil
|
||
}
|
||
|
||
func (m *mockAuditStore) GetByID(ctx context.Context, eventID string) (audit.Event, error) {
|
||
if m.err != nil {
|
||
return audit.Event{}, m.err
|
||
}
|
||
return m.event, nil
|
||
}
|
||
|
||
// ==================== Test Helpers ====================
|
||
|
||
func newTestAPI() (*SupplyAPI, *mockAccountService, *mockPackageService, *mockSettlementService, *mockEarningService, *mockAuditStore) {
|
||
return newTestAPIWithIdempotency(middleware.NewIdempotencyMiddleware(nil, middleware.IdempotencyConfig{
|
||
Enabled: false,
|
||
}))
|
||
}
|
||
|
||
func newTestAPIWithoutIdempotencyForTest() (*SupplyAPI, *mockAccountService, *mockPackageService, *mockSettlementService, *mockEarningService, *mockAuditStore) {
|
||
return newTestAPIWithIdempotency(nil)
|
||
}
|
||
|
||
func newTestAPIWithIdempotency(idempotencyMw *middleware.IdempotencyMiddleware) (*SupplyAPI, *mockAccountService, *mockPackageService, *mockSettlementService, *mockEarningService, *mockAuditStore) {
|
||
accountSvc := &mockAccountService{
|
||
account: &domain.Account{
|
||
ID: 1,
|
||
SupplierID: 100,
|
||
Provider: domain.ProviderOpenAI,
|
||
AccountType: domain.AccountTypeAPIKey,
|
||
Status: domain.AccountStatusActive,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
},
|
||
verifyResult: &domain.VerifyResult{
|
||
VerifyStatus: "pass",
|
||
AvailableQuota: 1000,
|
||
RiskScore: 0,
|
||
},
|
||
}
|
||
|
||
packageSvc := &mockPackageService{
|
||
pkg: &domain.Package{
|
||
ID: 1,
|
||
SupplierID: 100,
|
||
Model: "gpt-4",
|
||
Status: domain.PackageStatusActive,
|
||
TotalQuota: 10000,
|
||
AvailableQuota: 8000,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
},
|
||
}
|
||
|
||
settlementSvc := &mockSettlementService{
|
||
settlement: &domain.Settlement{
|
||
ID: 1,
|
||
SupplierID: 100,
|
||
Status: domain.SettlementStatusPending,
|
||
TotalAmount: 1000,
|
||
NetAmount: 950,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
},
|
||
}
|
||
|
||
earningSvc := &mockEarningService{
|
||
records: []*domain.EarningRecord{
|
||
{
|
||
ID: 1,
|
||
Amount: 100,
|
||
Status: "available",
|
||
},
|
||
},
|
||
total: 1,
|
||
billingSummary: &domain.BillingSummary{},
|
||
}
|
||
|
||
auditSvc := &mockAuditStore{
|
||
events: []audit.Event{
|
||
{
|
||
EventID: "evt_123",
|
||
TenantID: 100,
|
||
ObjectType: "supply_account",
|
||
ObjectID: 1,
|
||
Action: "create",
|
||
CreatedAt: time.Now(),
|
||
},
|
||
},
|
||
event: audit.Event{
|
||
EventID: "evt_123",
|
||
TenantID: 100,
|
||
ObjectType: "supply_account",
|
||
ObjectID: 1,
|
||
Action: "create",
|
||
CreatedAt: time.Now(),
|
||
},
|
||
}
|
||
|
||
api, err := NewSupplyAPI(
|
||
accountSvc,
|
||
packageSvc,
|
||
settlementSvc,
|
||
earningSvc,
|
||
idempotencyMw,
|
||
auditSvc,
|
||
nil, // fkValidator
|
||
100, // supplierID
|
||
"https://statements.example.com",
|
||
time.Now,
|
||
)
|
||
if err != nil {
|
||
panic("expected api constructor to succeed: " + err.Error())
|
||
}
|
||
|
||
return api, accountSvc, packageSvc, settlementSvc, earningSvc, auditSvc
|
||
}
|
||
|
||
func TestNewSupplyAPI_ReturnsErrorWhenAccountServiceMissing(t *testing.T) {
|
||
api, err := NewSupplyAPI(
|
||
nil,
|
||
&mockPackageService{},
|
||
&mockSettlementService{},
|
||
&mockEarningService{},
|
||
nil,
|
||
&mockAuditStore{},
|
||
nil,
|
||
100,
|
||
"https://statements.example.com",
|
||
time.Now,
|
||
)
|
||
if err == nil {
|
||
t.Fatal("expected error")
|
||
}
|
||
if api != nil {
|
||
t.Fatal("expected nil api")
|
||
}
|
||
}
|
||
|
||
func TestNewSupplyAPI_DefaultsClockWhenNil(t *testing.T) {
|
||
api, err := NewSupplyAPI(
|
||
&mockAccountService{},
|
||
&mockPackageService{},
|
||
&mockSettlementService{},
|
||
&mockEarningService{},
|
||
nil,
|
||
&mockAuditStore{},
|
||
nil,
|
||
100,
|
||
"https://statements.example.com",
|
||
nil,
|
||
)
|
||
if err != nil {
|
||
t.Fatalf("expected no error, got %v", err)
|
||
}
|
||
if api.now == nil {
|
||
t.Fatal("expected default clock")
|
||
}
|
||
}
|
||
|
||
// ==================== Account Handler Tests ====================
|
||
|
||
func TestSupplyAPI_VerifyAccount_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{"provider":"openai","account_type":"resource","credential_input":"sk-test123"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/verify", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
req.Header.Set("X-Request-Id", "test-req-001")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleVerifyAccount(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
if resp["request_id"] != "test-req-001" {
|
||
t.Errorf("expected request_id test-req-001, got %v", resp["request_id"])
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_VerifyAccount_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/accounts/verify", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleVerifyAccount(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_VerifyAccount_InvalidJSON(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{invalid json}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/verify", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleVerifyAccount(w, req)
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_VerifyAccount_VerifyFailed(t *testing.T) {
|
||
api, accountSvc, _, _, _, _ := newTestAPI()
|
||
accountSvc.verifyErr = errors.New("SUP_ACC_4001: verification failed")
|
||
|
||
body := `{"provider":"openai","account_type":"resource","credential_input":"invalid"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/verify", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleVerifyAccount(w, req)
|
||
|
||
if w.Code != http.StatusUnprocessableEntity {
|
||
t.Errorf("expected status 422, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_VerifyAccount_UsesTenantIDFromContext(t *testing.T) {
|
||
api, accountSvc, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{"provider":"openai","account_type":"resource","credential_input":"sk-test123"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/verify", strings.NewReader(body))
|
||
req = req.WithContext(middleware.WithTenantID(req.Context(), 200))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleVerifyAccount(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Fatalf("expected status 200, got %d", w.Code)
|
||
}
|
||
if accountSvc.lastVerifySupplierID != 200 {
|
||
t.Fatalf("expected tenant supplier ID 200, got %d", accountSvc.lastVerifySupplierID)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_VerifyAccount_RejectsMissingTenantContextWithoutDefaultSupplier(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
api.supplierID = 0
|
||
|
||
body := `{"provider":"openai","account_type":"resource","credential_input":"sk-test123"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/verify", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleVerifyAccount(w, req)
|
||
|
||
if w.Code != http.StatusUnauthorized {
|
||
t.Fatalf("expected status 401, got %d body=%s", w.Code, w.Body.String())
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_CreateAccount_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{"provider":"openai","account_type":"resource","credential_input":"sk-test","account_alias":"test","risk_ack":true}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleCreateAccount(w, req)
|
||
|
||
if w.Code != http.StatusCreated {
|
||
t.Errorf("expected status 201, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestHandleCreateAccount_RequiresIdempotencyMiddleware(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPIWithoutIdempotencyForTest()
|
||
|
||
body := `{"provider":"openai","account_type":"resource","credential_input":"sk-test","account_alias":"test","risk_ack":true}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleCreateAccount(w, req)
|
||
|
||
if w.Code != http.StatusServiceUnavailable {
|
||
t.Fatalf("expected 503 when idempotency middleware is missing, got=%d body=%s", w.Code, w.Body.String())
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_CreateAccount_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/accounts", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleCreateAccount(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_ActivateAccount_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/1/activate", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_ActivateAccount_NotFound(t *testing.T) {
|
||
api, accountSvc, _, _, _, _ := newTestAPI()
|
||
accountSvc.activateErr = errors.New("account not found")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/1/activate", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_SuspendAccount_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/1/suspend", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_SuspendAccount_Conflict(t *testing.T) {
|
||
api, accountSvc, _, _, _, _ := newTestAPI()
|
||
accountSvc.suspendErr = errors.New("SUP_ACC_4091: account state conflict")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/1/suspend", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusConflict {
|
||
t.Errorf("expected status 409, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_SuspendAccount_WrongMethod(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/accounts/1/suspend", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_DeleteAccount_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("DELETE", "/api/v1/supply/accounts/1/delete", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusNoContent {
|
||
t.Errorf("expected status 204, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_DeleteAccount_Conflict(t *testing.T) {
|
||
api, accountSvc, _, _, _, _ := newTestAPI()
|
||
accountSvc.deleteErr = errors.New("SUP_ACC_4092: cannot delete account with active packages")
|
||
|
||
req := httptest.NewRequest("DELETE", "/api/v1/supply/accounts/1/delete", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusConflict {
|
||
t.Errorf("expected status 409, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_DeleteAccount_WrongMethod(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/1/delete", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_AccountAuditLogs_Success(t *testing.T) {
|
||
api, _, _, _, _, auditSvc := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/accounts/1/audit-logs", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
data, ok := resp["data"].([]any)
|
||
if !ok {
|
||
t.Fatal("expected data array in response")
|
||
}
|
||
if len(data) != 1 {
|
||
t.Errorf("expected 1 event, got %d", len(data))
|
||
}
|
||
|
||
auditSvc.err = errors.New("query failed")
|
||
req = httptest.NewRequest("GET", "/api/v1/supply/accounts/1/audit-logs", nil)
|
||
w = httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusInternalServerError {
|
||
t.Errorf("expected status 500, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_AccountActions_InvalidID(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/invalid/activate", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_AccountActions_UnknownRoute(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/accounts/1/unknown", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAccountActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
// ==================== Package Handler Tests ====================
|
||
|
||
func TestSupplyAPI_CreatePackageDraft_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{"supply_account_id":1,"model":"gpt-4","total_quota":10000,"price_per_1m_input":0.1,"price_per_1m_output":0.2,"valid_days":30,"max_concurrent":10,"rate_limit_rpm":1000}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/draft", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleCreatePackageDraft(w, req)
|
||
|
||
if w.Code != http.StatusCreated {
|
||
t.Errorf("expected status 201, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_CreatePackageDraft_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/packages/draft", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleCreatePackageDraft(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_PublishPackage_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/publish", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_PublishPackage_NotFound(t *testing.T) {
|
||
api, _, packageSvc, _, _, _ := newTestAPI()
|
||
packageSvc.publishErr = errors.New("package not found")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/publish", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_PausePackage_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/pause", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_PausePackage_Conflict(t *testing.T) {
|
||
api, _, packageSvc, _, _, _ := newTestAPI()
|
||
packageSvc.pauseErr = errors.New("SUP_PKG_4092: cannot pause active package")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/pause", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusConflict {
|
||
t.Errorf("expected status 409, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_PausePackage_WrongMethod(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/packages/1/pause", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_UnlistPackage_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/unlist", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_UnlistPackage_Conflict(t *testing.T) {
|
||
api, _, packageSvc, _, _, _ := newTestAPI()
|
||
packageSvc.unlistErr = errors.New("SUP_PKG_4093: cannot unlist package")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/unlist", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusConflict {
|
||
t.Errorf("expected status 409, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_UnlistPackage_WrongMethod(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/packages/1/unlist", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_ClonePackage_WrongMethod(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/packages/1/clone", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_ClonePackage_NotFound(t *testing.T) {
|
||
api, _, packageSvc, _, _, _ := newTestAPI()
|
||
packageSvc.cloneErr = errors.New("package not found")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/clone", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_PublishPackage_WrongMethod(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/packages/1/publish", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_ClonePackage_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/1/clone", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handlePackageActions(w, req)
|
||
|
||
if w.Code != http.StatusCreated {
|
||
t.Errorf("expected status 201, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_BatchUpdatePrice_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
api.packageService.(*mockPackageService).batchResp = &domain.BatchUpdatePriceResponse{
|
||
Total: 2,
|
||
SuccessCount: 2,
|
||
FailedCount: 0,
|
||
}
|
||
|
||
body := `{"items":[{"package_id":1,"price_per_1m_input":0.15,"price_per_1m_output":0.25},{"package_id":2,"price_per_1m_input":0.12,"price_per_1m_output":0.22}]}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/batch-price", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleBatchUpdatePrice(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_BatchUpdatePrice_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/packages/batch-price", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleBatchUpdatePrice(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_BatchUpdatePrice_InvalidJSON(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{invalid}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/batch-price", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleBatchUpdatePrice(w, req)
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_BatchUpdatePrice_BatchFailed(t *testing.T) {
|
||
api, _, packageSvc, _, _, _ := newTestAPI()
|
||
packageSvc.batchErr = errors.New("batch update failed")
|
||
|
||
body := `{"items":[{"package_id":1,"price_per_1m_input":0.15,"price_per_1m_output":0.25}]}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/packages/batch-price", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleBatchUpdatePrice(w, req)
|
||
|
||
if w.Code != http.StatusUnprocessableEntity {
|
||
t.Errorf("expected status 422, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
// ==================== Billing Handler Tests ====================
|
||
|
||
func TestSupplyAPI_GetBilling_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/billing?start_date=2024-01-01&end_date=2024-01-31", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetBilling(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetBilling_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/billing", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetBilling(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetBilling_QueryFailed(t *testing.T) {
|
||
api, _, _, _, earningSvc, _ := newTestAPI()
|
||
earningSvc.billingErr = errors.New("query failed")
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/billing", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetBilling(w, req)
|
||
|
||
if w.Code != http.StatusInternalServerError {
|
||
t.Errorf("expected status 500, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
// ==================== Settlement Handler Tests ====================
|
||
|
||
func TestSupplyAPI_Withdraw_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{"withdraw_amount":1000,"payment_method":"bank","payment_account":"1234567890","sms_code":"123456"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/withdraw", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusCreated {
|
||
t.Errorf("expected status 201, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestHandleWithdraw_RequiresIdempotencyMiddleware(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPIWithoutIdempotencyForTest()
|
||
|
||
body := `{"withdraw_amount":1000,"payment_method":"bank","payment_account":"1234567890","sms_code":"123456"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/withdraw", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusServiceUnavailable {
|
||
t.Fatalf("expected 503 when idempotency middleware is missing, got=%d body=%s", w.Code, w.Body.String())
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_Withdraw_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/settlements/withdraw", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_Withdraw_InvalidJSON(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
body := `{invalid}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/withdraw", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_Withdraw_WithdrawFailed(t *testing.T) {
|
||
api, _, _, settlementSvc, _, _ := newTestAPI()
|
||
settlementSvc.withdrawErr = errors.New("SUP_SET_4001: insufficient balance")
|
||
|
||
body := `{"withdraw_amount":1000000,"payment_method":"bank","payment_account":"1234567890","sms_code":"123456"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/withdraw", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusConflict {
|
||
t.Errorf("expected status 409, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_CancelSettlement_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/1/cancel", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleSettlementActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_CancelSettlement_NotFound(t *testing.T) {
|
||
api, _, _, settlementSvc, _, _ := newTestAPI()
|
||
settlementSvc.cancelErr = errors.New("settlement not found")
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/1/cancel", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleSettlementActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetStatement_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/settlements/1/statement", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleSettlementActions(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
data, ok := resp["data"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected data in response")
|
||
}
|
||
|
||
if data["file_name"] == nil {
|
||
t.Error("expected file_name in data")
|
||
}
|
||
if data["download_url"] == nil {
|
||
t.Error("expected download_url in data")
|
||
}
|
||
if data["expires_at"] == nil {
|
||
t.Error("expected expires_at in data")
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetStatement_NotFound(t *testing.T) {
|
||
api, _, _, settlementSvc, _, _ := newTestAPI()
|
||
settlementSvc.getErr = errors.New("settlement not found")
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/settlements/1/statement", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleSettlementActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_SettlementActions_InvalidID(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/invalid/cancel", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleSettlementActions(w, req)
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_SettlementActions_UnknownAction(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/1/unknown", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleSettlementActions(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
// ==================== Earning Handler Tests ====================
|
||
|
||
func TestSupplyAPI_GetEarningRecords_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/earnings/records?start_date=2024-01-01&end_date=2024-01-31&page=1&page_size=20", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetEarningRecords(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
data, ok := resp["data"].([]any)
|
||
if !ok {
|
||
t.Fatal("expected data array in response")
|
||
}
|
||
if len(data) != 1 {
|
||
t.Errorf("expected 1 record, got %d", len(data))
|
||
}
|
||
|
||
pagination, ok := resp["pagination"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected pagination in response")
|
||
}
|
||
if pagination["total"] != float64(1) {
|
||
t.Errorf("expected total 1, got %v", pagination["total"])
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetEarningRecords_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/earnings/records", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetEarningRecords(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetEarningRecords_QueryFailed(t *testing.T) {
|
||
api, _, _, _, earningSvc, _ := newTestAPI()
|
||
earningSvc.listErr = errors.New("query failed")
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/earnings/records", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetEarningRecords(w, req)
|
||
|
||
if w.Code != http.StatusInternalServerError {
|
||
t.Errorf("expected status 500, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
// ==================== Audit Event Handler Tests ====================
|
||
|
||
func TestSupplyAPI_GetAuditEvent_Success(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/audit/events/evt_123", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAuditEvent(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
data, ok := resp["data"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected data in response")
|
||
}
|
||
if data["event_id"] != "evt_123" {
|
||
t.Errorf("expected event_id evt_123, got %v", data["event_id"])
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetAuditEvent_NotFound(t *testing.T) {
|
||
api, _, _, _, _, auditSvc := newTestAPI()
|
||
auditSvc.err = errors.New("not found")
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/audit/events/evt_999", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAuditEvent(w, req)
|
||
|
||
if w.Code != http.StatusNotFound {
|
||
t.Errorf("expected status 404, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetAuditEvent_MissingID(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/audit/events/", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAuditEvent(w, req)
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_GetAuditEvent_MethodNotAllowed(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
|
||
req := httptest.NewRequest("POST", "/api/v1/audit/events/evt_123", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleAuditEvent(w, req)
|
||
|
||
if w.Code != http.StatusMethodNotAllowed {
|
||
t.Errorf("expected status 405, got %d", w.Code)
|
||
}
|
||
}
|
||
|
||
// ==================== Helper Function Tests ====================
|
||
|
||
func TestGetRequestID(t *testing.T) {
|
||
req := httptest.NewRequest("GET", "/", nil)
|
||
req.Header.Set("X-Request-Id", "req-123")
|
||
|
||
id := getRequestID(req)
|
||
if id != "req-123" {
|
||
t.Errorf("expected req-123, got %s", id)
|
||
}
|
||
|
||
req = httptest.NewRequest("GET", "/", nil)
|
||
req.Header.Set("X-Request-ID", "req-456")
|
||
|
||
id = getRequestID(req)
|
||
if id != "req-456" {
|
||
t.Errorf("expected req-456, got %s", id)
|
||
}
|
||
|
||
req = httptest.NewRequest("GET", "/", nil)
|
||
id = getRequestID(req)
|
||
if id != "" {
|
||
t.Errorf("expected empty string, got %s", id)
|
||
}
|
||
}
|
||
|
||
func TestGetQueryInt(t *testing.T) {
|
||
req := httptest.NewRequest("GET", "/?page=5&page_size=100", nil)
|
||
|
||
if getQueryInt(req, "page", 1) != 5 {
|
||
t.Error("expected page 5")
|
||
}
|
||
if getQueryInt(req, "page_size", 20) != 100 {
|
||
t.Error("expected page_size 100")
|
||
}
|
||
if getQueryInt(req, "missing", 10) != 10 {
|
||
t.Error("expected default 10 for missing param")
|
||
}
|
||
if getQueryInt(req, "invalid", 1) != 1 {
|
||
t.Error("expected default 1 for invalid value")
|
||
}
|
||
}
|
||
|
||
func TestWriteJSON(t *testing.T) {
|
||
w := httptest.NewRecorder()
|
||
|
||
writeJSON(w, http.StatusOK, map[string]any{"key": "value"})
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
if w.Header().Get("Content-Type") != "application/json" {
|
||
t.Error("expected Content-Type application/json")
|
||
}
|
||
}
|
||
|
||
func TestWriteError(t *testing.T) {
|
||
w := httptest.NewRecorder()
|
||
|
||
writeError(w, http.StatusBadRequest, "TEST_ERROR", "test message")
|
||
|
||
if w.Code != http.StatusBadRequest {
|
||
t.Errorf("expected status 400, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
json.Unmarshal(w.Body.Bytes(), &resp)
|
||
|
||
errObj, ok := resp["error"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected error object in response")
|
||
}
|
||
if errObj["code"] != "TEST_ERROR" {
|
||
t.Errorf("expected code TEST_ERROR, got %v", errObj["code"])
|
||
}
|
||
if errObj["message"] != "test message" {
|
||
t.Errorf("expected message 'test message', got %v", errObj["message"])
|
||
}
|
||
}
|
||
|
||
// ==================== Integration Tests ====================
|
||
|
||
func TestSupplyAPI_Register(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
mux := http.NewServeMux()
|
||
|
||
api.Register(mux)
|
||
|
||
// 验证路由已注册（不会panic）
|
||
_ = mux
|
||
}
|
||
|
||
func TestSupplyAPI_EndToEnd_Withdraw(t *testing.T) {
|
||
api, _, _, settlementSvc, _, _ := newTestAPI()
|
||
settlementSvc.settlement = &domain.Settlement{
|
||
ID: 1,
|
||
SupplierID: 100,
|
||
SettlementNo: "SET_20240101_001",
|
||
Status: domain.SettlementStatusPending,
|
||
TotalAmount: 1000,
|
||
NetAmount: 950,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
}
|
||
|
||
body := `{"withdraw_amount":500,"payment_method":"bank","payment_account":"1234567890","sms_code":"123456"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/withdraw", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
req.Header.Set("X-Request-Id", "test-req-001")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusCreated {
|
||
t.Errorf("expected status 201, got %d. Body: %s", w.Code, w.Body.String())
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
if resp["request_id"] != "test-req-001" {
|
||
t.Errorf("expected request_id test-req-001, got %v", resp["request_id"])
|
||
}
|
||
|
||
data, ok := resp["data"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected data in response")
|
||
}
|
||
if data["settlement_id"] != float64(1) {
|
||
t.Errorf("expected settlement_id 1, got %v", data["settlement_id"])
|
||
}
|
||
if data["status"] != "pending" {
|
||
t.Errorf("expected status pending, got %v", data["status"])
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_WithdrawDisabled_ReturnsServiceUnavailable(t *testing.T) {
|
||
api, _, _, _, _, _ := newTestAPI()
|
||
api.withdrawEnabled = false
|
||
|
||
body := `{"withdraw_amount":500,"payment_method":"bank","payment_account":"1234567890","sms_code":"123456"}`
|
||
req := httptest.NewRequest("POST", "/api/v1/supply/settlements/withdraw", strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleWithdraw(w, req)
|
||
|
||
if w.Code != http.StatusServiceUnavailable {
|
||
t.Fatalf("expected status 503, got %d body=%s", w.Code, w.Body.String())
|
||
}
|
||
}
|
||
|
||
func TestSupplyAPI_EndToEnd_BillingSummary(t *testing.T) {
|
||
api, _, _, _, earningSvc, _ := newTestAPI()
|
||
earningSvc.billingSummary = &domain.BillingSummary{
|
||
Period: domain.BillingPeriod{
|
||
Start: "2024-01-01",
|
||
End: "2024-01-31",
|
||
},
|
||
Summary: domain.BillingTotal{
|
||
TotalRevenue: 10000,
|
||
TotalOrders: 100,
|
||
TotalUsage: 1000000,
|
||
TotalRequests: 5000000,
|
||
AvgSuccessRate: 99.5,
|
||
},
|
||
}
|
||
|
||
req := httptest.NewRequest("GET", "/api/v1/supply/billing?start_date=2024-01-01&end_date=2024-01-31", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
api.handleGetBilling(w, req)
|
||
|
||
if w.Code != http.StatusOK {
|
||
t.Errorf("expected status 200, got %d", w.Code)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||
t.Fatalf("failed to unmarshal response: %v", err)
|
||
}
|
||
|
||
data, ok := resp["data"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected data in response")
|
||
}
|
||
|
||
summary, ok := data["summary"].(map[string]any)
|
||
if !ok {
|
||
t.Fatal("expected summary in data")
|
||
}
|
||
if summary["total_revenue"] != float64(10000) {
|
||
t.Errorf("expected total_revenue 10000, got %v", summary["total_revenue"])
|
||
}
|
||
}
|