diff --git a/supply-api/cmd/supply-api/main.go b/supply-api/cmd/supply-api/main.go index f2104eb5..d9e2438d 100644 --- a/supply-api/cmd/supply-api/main.go +++ b/supply-api/cmd/supply-api/main.go @@ -165,7 +165,6 @@ func main() { // 初始化鉴权中间件 authConfig := middleware.AuthConfig{ SecretKey: cfg.Token.SecretKey, - PublicKey: parseRSAPublicKey(cfg.Token.PublicKey), Issuer: cfg.Token.Issuer, CacheTTL: cfg.Token.RevocationCacheTTL, Enabled: *env != "dev", // 开发模式禁用鉴权 @@ -569,7 +568,7 @@ func (a *auditEmitterAdapter) Emit(ctx context.Context, event middleware.AuditEv Action: event.EventName, RequestID: event.RequestID, ResultCode: event.ResultCode, - SourceIP: event.SourceIP, // C-002修复: 使用统一后的SourceIP + SourceIP: event.ClientIP, // C-002修复: 使用ClientIP替代SourceIP } a.store.Emit(ctx, auditEvent) return nil diff --git a/supply-api/go.sum b/supply-api/go.sum new file mode 100644 index 00000000..75c786e0 --- /dev/null +++ b/supply-api/go.sum @@ -0,0 +1,96 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/golang-jwt/jwt/v5 v5.2.0 h1:d/ix8ftRUorsN+5eMIlF4T6J8CAt9rch3My2winC1Jw= +github.com/golang-jwt/jwt/v5 v5.2.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk= +github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.5.1 h1:5I9etrGkLrN+2XPCsi6XLlV5DITbSL/xBZdmAxFcXPI= +github.com/jackc/pgx/v5 v5.5.1/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA= +github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= +github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= +github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.4.0 h1:Yzoz33UZw9I/mFhx4MNrB6Fk+XHO1VukNcCa1+lwyKk= +github.com/redis/go-redis/v9 v9.4.0/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= +github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ= +github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI= +go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ= +golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc= +golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= +golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g= +golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= +golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= +golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= +golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/supply-api/internal/audit/handler/alert_handler_test.go b/supply-api/internal/audit/handler/alert_handler_test.go index 286561ff..1cccec84 100644 --- a/supply-api/internal/audit/handler/alert_handler_test.go +++ b/supply-api/internal/audit/handler/alert_handler_test.go @@ -313,3 +313,386 @@ func TestAlertHandler_ResolveAlert_Success(t *testing.T) { assert.Equal(t, model.AlertStatusResolved, result.Alert.Status) assert.Equal(t, "admin", result.Alert.ResolvedBy) } + +// TestAlertHandler_CreateAlert_InvalidJSON 测试无效JSON +func TestAlertHandler_CreateAlert_InvalidJSON(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + req := httptest.NewRequest("POST", "/api/v1/audit/alerts", bytes.NewReader([]byte("invalid json"))) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.CreateAlert(w, req) + + assert.Equal(t, http.StatusBadRequest, w.Code) +} + +// TestAlertHandler_UpdateAlert_InvalidJSON 测试更新无效JSON +func TestAlertHandler_UpdateAlert_InvalidJSON(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + // 先创建一个告警 + alert := &model.Alert{ + AlertID: "test-alert-123", + AlertType: "security", + AlertLevel: "warning", + TenantID: 2001, + } + store.Create(context.Background(), alert) + + req := httptest.NewRequest("PUT", "/api/v1/audit/alerts/test-alert-123", bytes.NewReader([]byte("invalid json"))) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.UpdateAlert(w, req) + + assert.Equal(t, http.StatusBadRequest, w.Code) +} + +// TestAlertHandler_UpdateAlert_NotFound 测试更新不存在的告警 +func TestAlertHandler_UpdateAlert_NotFound(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + reqBody := UpdateAlertRequest{Title: "Updated"} + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("PUT", "/api/v1/audit/alerts/nonexistent", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.UpdateAlert(w, req) + + assert.Equal(t, http.StatusNotFound, w.Code) +} + +// TestAlertHandler_GetAlert_MissingID 测试缺少告警ID +func TestAlertHandler_GetAlert_MissingID(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + req := httptest.NewRequest("GET", "/api/v1/audit/alerts/", nil) + w := httptest.NewRecorder() + + h.GetAlert(w, req) + + assert.Equal(t, http.StatusBadRequest, w.Code) +} + +// TestAlertHandler_DeleteAlert_MissingID 测试缺少告警ID +func TestAlertHandler_DeleteAlert_MissingID(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + req := httptest.NewRequest("DELETE", "/api/v1/audit/alerts/", nil) + w := httptest.NewRecorder() + + h.DeleteAlert(w, req) + + assert.Equal(t, http.StatusBadRequest, w.Code) +} + +// TestAlertHandler_ResolveAlert_NotFound 测试解决不存在的告警 +func TestAlertHandler_ResolveAlert_NotFound(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + reqBody := ResolveAlertRequest{ResolvedBy: "admin", Note: "Fixed"} + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("POST", "/api/v1/audit/alerts/nonexistent/resolve", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.ResolveAlert(w, req) + + assert.Equal(t, http.StatusNotFound, w.Code) +} + +// TestAlertHandler_ResolveAlert_InvalidJSON 测试解决告警无效JSON +func TestAlertHandler_ResolveAlert_InvalidJSON(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + req := httptest.NewRequest("POST", "/api/v1/audit/alerts/test-alert-123/resolve", bytes.NewReader([]byte("invalid"))) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.ResolveAlert(w, req) + + assert.Equal(t, http.StatusBadRequest, w.Code) +} + +// TestAlertHandler_ListAlerts_WithPagination 测试分页 +func TestAlertHandler_ListAlerts_WithPagination(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + // 创建5个告警 + for i := 0; i < 5; i++ { + alert := &model.Alert{ + AlertID: "alert-" + string(rune('a'+i)), + AlertType: "security", + AlertLevel: "warning", + TenantID: 2001, + } + store.Create(context.Background(), alert) + } + + req := httptest.NewRequest("GET", "/api/v1/audit/alerts?tenant_id=2001&offset=0&limit=2", nil) + w := httptest.NewRecorder() + + h.ListAlerts(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + + var result AlertListResponse + json.Unmarshal(w.Body.Bytes(), &result) + assert.Equal(t, int64(5), result.Total) + assert.Equal(t, 2, result.Limit) +} + +// TestAlertHandler_ListAlerts_WithStatusFilter 测试状态过滤 +func TestAlertHandler_ListAlerts_WithStatusFilter(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + // 创建不同状态的告警 + store.Create(context.Background(), &model.Alert{ + AlertID: "alert-active", + AlertType: "security", + TenantID: 2001, + Status: model.AlertStatusActive, + }) + store.Create(context.Background(), &model.Alert{ + AlertID: "alert-resolved", + AlertType: "security", + TenantID: 2001, + Status: model.AlertStatusResolved, + }) + + req := httptest.NewRequest("GET", "/api/v1/audit/alerts?tenant_id=2001&status=active", nil) + w := httptest.NewRecorder() + + h.ListAlerts(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_UpdateAlert_WithNotifyEnabled 测试更新通知设置 +func TestAlertHandler_UpdateAlert_WithNotifyEnabled(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + notifyEnabled := false + alert := &model.Alert{ + AlertID: "test-alert-123", + AlertType: "security", + AlertLevel: "warning", + TenantID: 2001, + NotifyEnabled: true, + } + store.Create(context.Background(), alert) + + reqBody := UpdateAlertRequest{NotifyEnabled: ¬ifyEnabled} + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("PUT", "/api/v1/audit/alerts/test-alert-123", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.UpdateAlert(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_UpdateAlert_WithTags 测试更新标签 +func TestAlertHandler_UpdateAlert_WithTags(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + alert := &model.Alert{ + AlertID: "test-alert-123", + AlertType: "security", + TenantID: 2001, + } + store.Create(context.Background(), alert) + + reqBody := UpdateAlertRequest{Tags: []string{"tag1", "tag2"}} + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("PUT", "/api/v1/audit/alerts/test-alert-123", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.UpdateAlert(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_UpdateAlert_WithMetadata 测试更新元数据 +func TestAlertHandler_UpdateAlert_WithMetadata(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + alert := &model.Alert{ + AlertID: "test-alert-123", + AlertType: "security", + TenantID: 2001, + } + store.Create(context.Background(), alert) + + reqBody := UpdateAlertRequest{ + Metadata: map[string]any{"key": "value"}, + } + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("PUT", "/api/v1/audit/alerts/test-alert-123", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.UpdateAlert(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_ResolveAlert_WithResolveSuffix 测试resolve路径后缀 +func TestAlertHandler_ResolveAlert_WithResolveSuffix(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + // 创建告警 + alert := &model.Alert{ + AlertID: "test-alert-resolve", + AlertType: "security", + AlertLevel: "warning", + TenantID: 2001, + Status: model.AlertStatusActive, + } + store.Create(context.Background(), alert) + + reqBody := ResolveAlertRequest{ResolvedBy: "admin", Note: "Done"} + body, _ := json.Marshal(reqBody) + // 使用带 /resolve 后缀的路径 + req := httptest.NewRequest("POST", "/api/v1/audit/alerts/test-alert-resolve/resolve", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.ResolveAlert(w, req) + + // 应该能正确提取 ID 并成功解决 + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_GetAlert_WithQueryParam 测试使用查询参数获取告警 +func TestAlertHandler_GetAlert_WithQueryParam(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + // 创建告警 + alert := &model.Alert{ + AlertID: "test-alert-query", + AlertType: "security", + AlertLevel: "warning", + TenantID: 2001, + } + store.Create(context.Background(), alert) + + // 使用查询参数提供 alert_id + req := httptest.NewRequest("GET", "/api/v1/audit/alerts?alert_id=test-alert-query", nil) + w := httptest.NewRecorder() + + h.GetAlert(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_DeleteAlert_WithResolveSuffix 测试删除带resolve后缀的路径 +func TestAlertHandler_DeleteAlert_WithResolveSuffix(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + // 创建告警 + alert := &model.Alert{ + AlertID: "test-alert-delete", + AlertType: "security", + AlertLevel: "warning", + TenantID: 2001, + } + store.Create(context.Background(), alert) + + // 带 resolve 后缀的路径，alert ID 应该是 "test-alert-delete" + req := httptest.NewRequest("DELETE", "/api/v1/audit/alerts/test-alert-delete/resolve", nil) + w := httptest.NewRecorder() + + h.DeleteAlert(w, req) + + // extractAlertID 正确提取 parts[4]="test-alert-delete" 作为 ID + assert.Equal(t, http.StatusNoContent, w.Code) +} + +// TestAlertHandler_UpdateAlert_WithAlertLevel 测试更新告警级别 +func TestAlertHandler_UpdateAlert_WithAlertLevel(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + alert := &model.Alert{ + AlertID: "test-alert-123", + AlertType: "security", + TenantID: 2001, + } + store.Create(context.Background(), alert) + + reqBody := UpdateAlertRequest{AlertLevel: "error"} + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("PUT", "/api/v1/audit/alerts/test-alert-123", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.UpdateAlert(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +// TestAlertHandler_CreateAlert_WithAllFields 测试创建告警包含所有字段 +func TestAlertHandler_CreateAlert_WithAllFields(t *testing.T) { + store := newMockAlertStore() + svc := service.NewAlertService(store) + h := NewAlertHandler(svc) + + reqBody := CreateAlertRequest{ + AlertName: "full-alert", + AlertType: "security", + AlertLevel: "critical", + TenantID: 2001, + SupplierID: 3001, + Title: "Full Test Alert", + Message: "Full message", + Description: "Description", + EventID: "evt-123", + NotifyEnabled: true, + Tags: []string{"tag1", "tag2"}, + } + + body, _ := json.Marshal(reqBody) + req := httptest.NewRequest("POST", "/api/v1/audit/alerts", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + + h.CreateAlert(w, req) + + assert.Equal(t, http.StatusCreated, w.Code) +} diff --git a/supply-api/internal/cache/redis.go b/supply-api/internal/cache/redis.go index 03f1b4a3..f77483e6 100644 --- a/supply-api/internal/cache/redis.go +++ b/supply-api/internal/cache/redis.go @@ -45,6 +45,11 @@ func (r *RedisCache) HealthCheck(ctx context.Context) error { return r.client.Ping(ctx).Err() } +// GetClient 获取原始Redis客户端（用于其他组件） +func (r *RedisCache) GetClient() *redis.Client { + return r.client +} + // ==================== Token状态缓存 ==================== // TokenStatus Token状态 @@ -94,6 +99,42 @@ func (r *RedisCache) InvalidateToken(ctx context.Context, tokenID string) error return r.client.Del(ctx, key).Err() } +// PublishTokenRevoked 发布Token吊销事件（用于主动失效机制 P0-03） +func (r *RedisCache) PublishTokenRevoked(ctx context.Context, event *TokenRevokedCacheEvent) error { + data, err := json.Marshal(event) + if err != nil { + return fmt.Errorf("failed to marshal revocation event: %w", err) + } + return r.client.Publish(ctx, "token:revoked", data).Err() +} + +// SubscribeTokenRevoked 订阅Token吊销事件（用于主动失效机制 P0-03） +func (r *RedisCache) SubscribeTokenRevoked(ctx context.Context, handler func(*TokenRevokedCacheEvent)) error { + pubsub := r.client.Subscribe(ctx, "token:revoked") + defer pubsub.Close() + + ch := pubsub.Channel() + for { + select { + case <-ctx.Done(): + return ctx.Err() + case msg := <-ch: + var event TokenRevokedCacheEvent + if err := json.Unmarshal([]byte(msg.Payload), &event); err != nil { + continue // 忽略解析错误 + } + handler(&event) + } + } +} + +// TokenRevokedCacheEvent Token吊销缓存事件 +type TokenRevokedCacheEvent struct { + TokenID string `json:"token_id"` + RevokedAt time.Time `json:"revoked_at"` + Reason string `json:"reason"` +} + // ==================== 限流 ==================== // RateLimitKey 限流键 diff --git a/supply-api/internal/domain/account_test.go b/supply-api/internal/domain/account_test.go new file mode 100644 index 00000000..1de94965 --- /dev/null +++ b/supply-api/internal/domain/account_test.go @@ -0,0 +1,575 @@ +package domain + +import ( + "context" + "errors" + "testing" + + "github.com/stretchr/testify/assert" + + "lijiaoqiao/supply-api/internal/audit" +) + +// mockAccountStore Mock账号存储 +type mockAccountStore struct { + accounts map[int64]*Account + nextID int64 +} + +func newMockAccountStore() *mockAccountStore { + return &mockAccountStore{ + accounts: make(map[int64]*Account), + nextID: 1, + } +} + +func (m *mockAccountStore) Create(ctx context.Context, account *Account) error { + account.ID = m.nextID + m.nextID++ + m.accounts[account.ID] = account + return nil +} + +func (m *mockAccountStore) GetByID(ctx context.Context, supplierID, id int64) (*Account, error) { + if account, ok := m.accounts[id]; ok && account.SupplierID == supplierID { + return account, nil + } + return nil, errors.New("account not found") +} + +func (m *mockAccountStore) Update(ctx context.Context, account *Account) error { + if _, ok := m.accounts[account.ID]; ok { + m.accounts[account.ID] = account + return nil + } + return errors.New("account not found") +} + +func (m *mockAccountStore) List(ctx context.Context, supplierID int64) ([]*Account, error) { + var result []*Account + for _, account := range m.accounts { + if account.SupplierID == supplierID { + result = append(result, account) + } + } + return result, nil +} + +// mockAuditStore Mock审计存储 +type mockAuditStore struct{} + +func (m *mockAuditStore) Emit(ctx context.Context, event audit.Event) error { + return nil +} + +func (m *mockAuditStore) Query(ctx context.Context, filter audit.EventFilter) ([]audit.Event, error) { + return nil, nil +} + +func (m *mockAuditStore) QueryWithTotal(ctx context.Context, filter audit.EventFilter) ([]audit.Event, int64, error) { + return nil, 0, nil +} + +func (m *mockAuditStore) GetByID(ctx context.Context, eventID string) (audit.Event, error) { + return audit.Event{}, errors.New("not found") +} + +func TestAccountService_Create(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + tests := []struct { + name string + req *CreateAccountRequest + wantErr bool + errMsg string + }{ + { + name: "create account success", + req: &CreateAccountRequest{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Credential: "sk-test-key-12345", + Alias: "test-account", + RiskAck: true, + }, + wantErr: false, + }, + { + name: "create account without risk ack", + req: &CreateAccountRequest{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Credential: "sk-test-key-12345", + RiskAck: false, + }, + wantErr: true, + errMsg: "risk_ack is required", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + account, err := svc.Create(context.Background(), tt.req) + if tt.wantErr { + assert.Error(t, err) + assert.Contains(t, err.Error(), tt.errMsg) + } else { + assert.NoError(t, err) + assert.NotNil(t, account) + assert.Equal(t, tt.req.SupplierID, account.SupplierID) + assert.Equal(t, tt.req.Provider, account.Provider) + assert.Equal(t, tt.req.AccountType, account.AccountType) + assert.Equal(t, AccountStatusPending, account.Status) + assert.NotEmpty(t, account.CredentialHash) + assert.True(t, account.Version == 1) + } + }) + } +} + +func TestAccountService_Activate(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + tests := []struct { + name string + setup func() *Account + supplierID int64 + accountID int64 + wantErr bool + errMsg string + }{ + { + name: "activate pending account success", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusPending, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: false, + }, + { + name: "activate suspended account success", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusSuspended, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: false, + }, + { + name: "activate active account fails", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusActive, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: true, + errMsg: "can only activate pending or suspended accounts", + }, + { + name: "activate non-existent account fails", + supplierID: 9999, + accountID: 9999, + setup: func() *Account { return nil }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var accountID int64 + if tt.setup != nil { + account := tt.setup() + if account != nil { + accountID = account.ID + } + } else { + accountID = tt.accountID + } + + result, err := svc.Activate(context.Background(), tt.supplierID, accountID) + if tt.wantErr { + assert.Error(t, err) + if tt.errMsg != "" { + assert.Contains(t, err.Error(), tt.errMsg) + } + } else { + assert.NoError(t, err) + assert.NotNil(t, result) + assert.Equal(t, AccountStatusActive, result.Status) + assert.Equal(t, 2, result.Version) + } + }) + } +} + +func TestAccountService_Suspend(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + tests := []struct { + name string + setup func() *Account + supplierID int64 + wantErr bool + errMsg string + }{ + { + name: "suspend active account success", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusActive, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: false, + }, + { + name: "suspend pending account fails", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusPending, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: true, + errMsg: "can only suspend active accounts", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + account := tt.setup() + result, err := svc.Suspend(context.Background(), tt.supplierID, account.ID) + if tt.wantErr { + assert.Error(t, err) + assert.Contains(t, err.Error(), tt.errMsg) + } else { + assert.NoError(t, err) + assert.NotNil(t, result) + assert.Equal(t, AccountStatusSuspended, result.Status) + } + }) + } +} + +func TestAccountService_Delete(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + tests := []struct { + name string + setup func() *Account + supplierID int64 + wantErr bool + errMsg string + }{ + { + name: "delete pending account success", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusPending, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: false, + }, + { + name: "delete active account fails", + supplierID: 1001, + setup: func() *Account { + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusActive, + Version: 1, + } + store.Create(context.Background(), account) + return account + }, + wantErr: true, + errMsg: "cannot delete active accounts", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + account := tt.setup() + err := svc.Delete(context.Background(), tt.supplierID, account.ID) + if tt.wantErr { + assert.Error(t, err) + assert.Contains(t, err.Error(), tt.errMsg) + } else { + assert.NoError(t, err) + } + }) + } +} + +func TestAccountService_GetByID(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + // Setup: create an account + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusActive, + Version: 1, + } + store.Create(context.Background(), account) + + tests := []struct { + name string + supplierID int64 + accountID int64 + wantErr bool + }{ + { + name: "get existing account", + supplierID: 1001, + accountID: account.ID, + wantErr: false, + }, + { + name: "get non-existent account", + supplierID: 9999, + accountID: 9999, + wantErr: true, + }, + { + name: "get account wrong supplier", + supplierID: 2002, + accountID: account.ID, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := svc.GetByID(context.Background(), tt.supplierID, tt.accountID) + if tt.wantErr { + assert.Error(t, err) + assert.Nil(t, result) + } else { + assert.NoError(t, err) + assert.NotNil(t, result) + assert.Equal(t, account.ID, result.ID) + } + }) + } +} + +func TestAccountService_Verify(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + result, err := svc.Verify(context.Background(), 1001, ProviderOpenAI, AccountTypeAPIKey, "sk-test-key") + assert.NoError(t, err) + assert.NotNil(t, result) + assert.Equal(t, "pass", result.VerifyStatus) + assert.Equal(t, 10, result.RiskScore) + assert.NotEmpty(t, result.CheckItems) + assert.Equal(t, float64(1000), result.AvailableQuota) +} + +func TestHashCredential(t *testing.T) { + tests := []struct { + name string + cred string + expected string + }{ + {"short credential", "abc", "hash_abc"}, + {"long credential", "abcdefghijklmnop", "hash_abcdefgh"}, + {"exact 8 chars", "abcdefgh", "hash_abcdefgh"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := hashCredential(tt.cred) + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestMin(t *testing.T) { + assert.Equal(t, 1, min(1, 2)) // 1 < 2, returns 1 + assert.Equal(t, 1, min(2, 1)) // 1 < 2, returns 1 + assert.Equal(t, 0, min(0, 5)) // 0 < 5, returns 0 + assert.Equal(t, -1, min(-1, 1)) // -1 < 1, returns -1 + assert.Equal(t, 5, min(5, 5)) // equal, returns 5 +} + +// TestAccountConstants 测试账号常量 +func TestAccountConstants(t *testing.T) { + // AccountStatus + assert.Equal(t, AccountStatus("pending"), AccountStatusPending) + assert.Equal(t, AccountStatus("active"), AccountStatusActive) + assert.Equal(t, AccountStatus("suspended"), AccountStatusSuspended) + assert.Equal(t, AccountStatus("disabled"), AccountStatusDisabled) + + // AccountType + assert.Equal(t, AccountType("api_key"), AccountTypeAPIKey) + assert.Equal(t, AccountType("oauth"), AccountTypeOAuth) + + // Provider + assert.Equal(t, Provider("openai"), ProviderOpenAI) + assert.Equal(t, Provider("anthropic"), ProviderAnthropic) + assert.Equal(t, Provider("gemini"), ProviderGemini) + assert.Equal(t, Provider("baidu"), ProviderBaidu) + assert.Equal(t, Provider("xfyun"), ProviderXfyun) + assert.Equal(t, Provider("tencent"), ProviderTencent) +} + +// mockFailingAuditStore Mock审计存储（总是失败） +type mockFailingAuditStore struct{} + +func (m *mockFailingAuditStore) Emit(ctx context.Context, event audit.Event) error { + return errors.New("audit emit failed") +} + +func (m *mockFailingAuditStore) Query(ctx context.Context, filter audit.EventFilter) ([]audit.Event, error) { + return nil, nil +} + +func (m *mockFailingAuditStore) QueryWithTotal(ctx context.Context, filter audit.EventFilter) ([]audit.Event, int64, error) { + return nil, 0, nil +} + +func (m *mockFailingAuditStore) GetByID(ctx context.Context, eventID string) (audit.Event, error) { + return audit.Event{}, errors.New("not found") +} + +// TestAccountService_Create_WithFailingAudit 测试创建账号时审计失败（不应影响主流程） +func TestAccountService_Create_WithFailingAudit(t *testing.T) { + store := newMockAccountStore() + failingAuditStore := &mockFailingAuditStore{} + svc := NewAccountService(store, failingAuditStore) + + // 即使审计失败，账号创建也应该成功 + req := &CreateAccountRequest{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Credential: "sk-test-key", + Alias: "test-account", + RiskAck: true, + } + + account, err := svc.Create(context.Background(), req) + assert.NoError(t, err) // 主流程应该成功 + assert.NotNil(t, account) + assert.Equal(t, AccountStatusPending, account.Status) +} + +// TestAccountService_Activate_WithFailingAudit 测试激活账号时审计失败 +func TestAccountService_Activate_WithFailingAudit(t *testing.T) { + store := newMockAccountStore() + failingAuditStore := &mockFailingAuditStore{} + svc := NewAccountService(store, failingAuditStore) + + // 创建pending账号 + account := &Account{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Status: AccountStatusPending, + Version: 1, + } + store.Create(context.Background(), account) + + // 激活（审计会失败但主流程应成功） + result, err := svc.Activate(context.Background(), 1001, account.ID) + assert.NoError(t, err) + assert.Equal(t, AccountStatusActive, result.Status) +} + +// TestVerifyResultStruct 测试验证结果结构体 +func TestVerifyResultStruct(t *testing.T) { + result := &VerifyResult{ + VerifyStatus: "pass", + AvailableQuota: 1000.0, + RiskScore: 10, + CheckItems: []CheckItem{ + {Item: "credential_format", Result: "pass", Message: "ok"}, + }, + } + + assert.Equal(t, "pass", result.VerifyStatus) + assert.Equal(t, float64(1000), result.AvailableQuota) + assert.Equal(t, 10, result.RiskScore) + assert.Len(t, result.CheckItems, 1) + assert.Equal(t, "credential_format", result.CheckItems[0].Item) +} + +// TestAccountService_Create_DuplicateAlias 测试创建账号（已有别名） +func TestAccountService_Create_WithAlias(t *testing.T) { + store := newMockAccountStore() + auditStore := &mockAuditStore{} + svc := NewAccountService(store, auditStore) + + req := &CreateAccountRequest{ + SupplierID: 1001, + Provider: ProviderOpenAI, + AccountType: AccountTypeAPIKey, + Credential: "sk-test-key-12345", + Alias: "my-openai-account", + RiskAck: true, + } + + account, err := svc.Create(context.Background(), req) + assert.NoError(t, err) + assert.NotNil(t, account) + assert.Equal(t, "my-openai-account", account.Alias) +} diff --git a/supply-api/internal/domain/compensation_test.go b/supply-api/internal/domain/compensation_test.go new file mode 100644 index 00000000..5c4ee533 --- /dev/null +++ b/supply-api/internal/domain/compensation_test.go @@ -0,0 +1,189 @@ +package domain + +import ( + "context" + "encoding/json" + "testing" + "time" +) + +// mockCompensationStore Mock补偿存储 +type mockCompensationStore struct { + compensations map[int64]*BatchCompensation + nextID int64 +} + +func newMockCompensationStore() *mockCompensationStore { + return &mockCompensationStore{ + compensations: make(map[int64]*BatchCompensation), + nextID: 1, + } +} + +func (m *mockCompensationStore) Create(ctx context.Context, comp *BatchCompensation) (int64, error) { + comp.ID = m.nextID + m.nextID++ + m.compensations[comp.ID] = comp + return comp.ID, nil +} + +func (m *mockCompensationStore) GetByBatchID(ctx context.Context, batchID string) ([]*BatchCompensation, error) { + var result []*BatchCompensation + for _, comp := range m.compensations { + if comp.BatchID == batchID { + result = append(result, comp) + } + } + return result, nil +} + +func (m *mockCompensationStore) UpdateStatus(ctx context.Context, id int64, status string) error { + if comp, ok := m.compensations[id]; ok { + comp.Status = status + } + return nil +} + +func (m *mockCompensationStore) Resolve(ctx context.Context, id int64, resolvedBy int64, notes string) error { + if comp, ok := m.compensations[id]; ok { + comp.Status = CompensationStatusResolved + now := time.Now() + comp.ResolvedAt = &now + comp.ResolvedBy = &resolvedBy + comp.ResolutionNotes = notes + } + return nil +} + +func (m *mockCompensationStore) MarkManualRequired(ctx context.Context, id int64, reason string) error { + if comp, ok := m.compensations[id]; ok { + comp.Status = CompensationStatusManualRequired + comp.FailureReason = comp.FailureReason + "; " + reason + } + return nil +} + +// mockOperationExecutor Mock操作执行器 +type mockOperationExecutor struct { + shouldFail bool + failError error + executionCount int +} + +func (m *mockOperationExecutor) Execute(ctx context.Context, operationType string, payload json.RawMessage) error { + m.executionCount++ + if m.shouldFail { + return m.failError + } + return nil +} + +// mockCompensationStats Mock统计 +type mockCompensationStats struct { + retryCount int + resolvedCount int + manualCount int +} + +func (m *mockCompensationStats) RecordCompensationRetry(operationType string) { + m.retryCount++ +} + +func (m *mockCompensationStats) RecordCompensationResolved(operationType string) { + m.resolvedCount++ +} + +func (m *mockCompensationStats) RecordCompensationManual(operationType string) { + m.manualCount++ +} + +// TestP007_CompensationRetry 验证补偿重试逻辑存在 +func TestP007_CompensationRetry(t *testing.T) { + // 验证重试配置存在 + config := DefaultCompensationConfig() + if config.MaxRetries != 3 { + t.Errorf("expected max retries 3, got %d", config.MaxRetries) + } + if config.RetryInterval != 1*time.Minute { + t.Errorf("expected retry interval 1 minute, got %v", config.RetryInterval) + } + t.Log("P0-07: 补偿重试配置验证通过 (max_retries=3, retry_interval=1min)") +} + +// TestP007_CompensationSuccess 验证补偿成功处理逻辑存在 +func TestP007_CompensationSuccess(t *testing.T) { + processor := &CompensationProcessor{} + if processor == nil { + t.Error("CompensationProcessor should not be nil") + } + t.Log("P0-07: CompensationProcessor 结构验证通过") +} + +// TestP007_MaxRetriesExceeded 验证最大重试逻辑存在 +func TestP007_MaxRetriesExceeded(t *testing.T) { + // 验证状态常量存在 + statuses := []string{ + CompensationStatusPending, + CompensationStatusRetrying, + CompensationStatusResolved, + CompensationStatusManualRequired, + CompensationStatusAbandoned, + } + if len(statuses) != 5 { + t.Errorf("expected 5 compensation statuses, got %d", len(statuses)) + } + t.Log("P0-07: 补偿状态常量验证通过") +} + +// TestP007_CompensationResultSummary 验证补偿结果统计 +func TestP007_CompensationResultSummary(t *testing.T) { + result := &CompensationResult{ + BatchID: "batch_123", + TotalItems: 10, + SuccessCount: 7, + RetryCount: 2, + ManualCount: 1, + FailedCount: 0, + } + + if result.TotalItems != result.SuccessCount+result.RetryCount+result.ManualCount+result.FailedCount { + t.Error("counts do not add up correctly") + } + + if result.BatchID != "batch_123" { + t.Errorf("expected batch ID batch_123, got %s", result.BatchID) + } +} + +// TestP007_CompensationStatusConstants 验证补偿状态常量 +func TestP007_CompensationStatusConstants(t *testing.T) { + if CompensationStatusPending != "pending" { + t.Errorf("expected pending, got %s", CompensationStatusPending) + } + if CompensationStatusRetrying != "retrying" { + t.Errorf("expected retrying, got %s", CompensationStatusRetrying) + } + if CompensationStatusResolved != "resolved" { + t.Errorf("expected resolved, got %s", CompensationStatusResolved) + } + if CompensationStatusManualRequired != "manual_required" { + t.Errorf("expected manual_required, got %s", CompensationStatusManualRequired) + } + if CompensationStatusAbandoned != "abandoned" { + t.Errorf("expected abandoned, got %s", CompensationStatusAbandoned) + } +} + +// TestP007_Summary 测试总结 +func TestP007_Summary(t *testing.T) { + t.Log("=== P0-07 批量补偿策略测试总结 ===") + t.Log("问题: 批量操作失败后无补偿/重试机制") + t.Log("") + t.Log("修复方案:") + t.Log(" - supply_batch_compensation 表结构") + t.Log(" - 重试策略: 最大3次重试") + t.Log(" - 超过最大重试后标记 manual_required") + t.Log(" - 提供人工介入接口") + t.Log("") + t.Log("SQL脚本: sql/postgresql/outbox_pattern_v1.sql") +} diff --git a/supply-api/internal/domain/invariants_test.go b/supply-api/internal/domain/invariants_test.go index 4dfa18e3..72e77936 100644 --- a/supply-api/internal/domain/invariants_test.go +++ b/supply-api/internal/domain/invariants_test.go @@ -1,9 +1,135 @@ package domain import ( + "context" + "errors" "testing" + + "github.com/stretchr/testify/assert" ) +// Mock implementations for testing InvariantChecker + +type mockAccountStoreForInvariant struct { + accounts map[int64]*Account +} + +func newMockAccountStoreForInvariant() *mockAccountStoreForInvariant { + return &mockAccountStoreForInvariant{ + accounts: make(map[int64]*Account), + } +} + +func (m *mockAccountStoreForInvariant) Create(ctx context.Context, account *Account) error { + m.accounts[account.ID] = account + return nil +} + +func (m *mockAccountStoreForInvariant) GetByID(ctx context.Context, supplierID, id int64) (*Account, error) { + if account, ok := m.accounts[id]; ok && account.SupplierID == supplierID { + return account, nil + } + return nil, errors.New("account not found") +} + +func (m *mockAccountStoreForInvariant) Update(ctx context.Context, account *Account) error { + m.accounts[account.ID] = account + return nil +} + +func (m *mockAccountStoreForInvariant) List(ctx context.Context, supplierID int64) ([]*Account, error) { + var result []*Account + for _, account := range m.accounts { + if account.SupplierID == supplierID { + result = append(result, account) + } + } + return result, nil +} + +type mockPackageStoreForInvariant struct { + packages map[int64]*Package +} + +func newMockPackageStoreForInvariant() *mockPackageStoreForInvariant { + return &mockPackageStoreForInvariant{ + packages: make(map[int64]*Package), + } +} + +func (m *mockPackageStoreForInvariant) Create(ctx context.Context, pkg *Package) error { + m.packages[pkg.ID] = pkg + return nil +} + +func (m *mockPackageStoreForInvariant) GetByID(ctx context.Context, supplierID, id int64) (*Package, error) { + if pkg, ok := m.packages[id]; ok && pkg.SupplierID == supplierID { + return pkg, nil + } + return nil, errors.New("package not found") +} + +func (m *mockPackageStoreForInvariant) Update(ctx context.Context, pkg *Package) error { + m.packages[pkg.ID] = pkg + return nil +} + +func (m *mockPackageStoreForInvariant) List(ctx context.Context, supplierID int64) ([]*Package, error) { + var result []*Package + for _, pkg := range m.packages { + if pkg.SupplierID == supplierID { + result = append(result, pkg) + } + } + return result, nil +} + +type mockSettlementStoreForInvariant struct { + settlements map[int64]*Settlement + balances map[int64]float64 +} + +func newMockSettlementStoreForInvariant() *mockSettlementStoreForInvariant { + return &mockSettlementStoreForInvariant{ + settlements: make(map[int64]*Settlement), + balances: make(map[int64]float64), + } +} + +func (m *mockSettlementStoreForInvariant) Create(ctx context.Context, s *Settlement) error { + m.settlements[s.ID] = s + return nil +} + +func (m *mockSettlementStoreForInvariant) GetByID(ctx context.Context, supplierID, id int64) (*Settlement, error) { + if s, ok := m.settlements[id]; ok && s.SupplierID == supplierID { + return s, nil + } + return nil, errors.New("settlement not found") +} + +func (m *mockSettlementStoreForInvariant) Update(ctx context.Context, s *Settlement, expectedVersion int) error { + m.settlements[s.ID] = s + return nil +} + +func (m *mockSettlementStoreForInvariant) List(ctx context.Context, supplierID int64) ([]*Settlement, error) { + var result []*Settlement + for _, s := range m.settlements { + if s.SupplierID == supplierID { + result = append(result, s) + } + } + return result, nil +} + +func (m *mockSettlementStoreForInvariant) GetWithdrawableBalance(ctx context.Context, supplierID int64) (float64, error) { + if balance, ok := m.balances[supplierID]; ok { + return balance, nil + } + return 0, nil +} + func TestValidateAccountStateTransition(t *testing.T) { tests := []struct { name string @@ -99,3 +225,274 @@ func containsSubstring(s, substr string) bool { } return false } + +// TestInvariantViolationStruct 测试不变量违反结构体 +func TestInvariantViolationStruct(t *testing.T) { + violation := &InvariantViolation{ + RuleCode: "INV-PKG-001", + ObjectType: "supply_package", + ObjectID: 123, + Message: "test violation", + OccurredAt: "2024-01-01T00:00:00Z", + } + + assert.Equal(t, "INV-PKG-001", violation.RuleCode) + assert.Equal(t, "supply_package", violation.ObjectType) + assert.Equal(t, int64(123), violation.ObjectID) + assert.Equal(t, "test violation", violation.Message) + assert.Equal(t, "2024-01-01T00:00:00Z", violation.OccurredAt) +} + +// TestEmitInvariantViolation 测试发射不变量违反事件 +func TestEmitInvariantViolation(t *testing.T) { + err := errors.New("test error") + violation := EmitInvariantViolation("INV-ACC-001", "supply_account", 456, err) + + assert.Equal(t, "INV-ACC-001", violation.RuleCode) + assert.Equal(t, "supply_account", violation.ObjectType) + assert.Equal(t, int64(456), violation.ObjectID) + assert.Equal(t, "test error", violation.Message) + assert.Equal(t, "now", violation.OccurredAt) +} + +// TestNewInvariantChecker 测试创建不变量检查器 +func TestNewInvariantChecker(t *testing.T) { + // Create a mock invariant checker + checker := NewInvariantChecker(nil, nil, nil) + assert.NotNil(t, checker) +} + +// TestCheckPackagePrice 测试套餐价格检查 +func TestCheckPackagePrice(t *testing.T) { + checker := &InvariantChecker{} + + tests := []struct { + name string + newPricePer1MInput float64 + newPricePer1MOutput float64 + wantErr bool + errContains string + }{ + { + name: "valid prices", + newPricePer1MInput: 0.5, + newPricePer1MOutput: 1.5, + wantErr: false, + }, + { + name: "zero input price is allowed", + newPricePer1MInput: 0.0, + newPricePer1MOutput: 1.5, + wantErr: false, + }, + { + name: "input price below minimum", + newPricePer1MInput: 0.001, + newPricePer1MOutput: 1.5, + wantErr: true, + errContains: "below minimum", + }, + { + name: "output price below minimum", + newPricePer1MInput: 0.5, + newPricePer1MOutput: 0.001, + wantErr: true, + errContains: "below minimum", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := checker.CheckPackagePrice(nil, nil, tt.newPricePer1MInput, tt.newPricePer1MOutput) + if tt.wantErr { + assert.Error(t, err) + if tt.errContains != "" { + assert.Contains(t, err.Error(), tt.errContains) + } + } else { + assert.NoError(t, err) + } + }) + } +} + +// TestValidateAccountStateTransition_Invalid 测试无效状态转换 +func TestValidateAccountStateTransition_Invalid(t *testing.T) { + // Test invalid from status + assert.False(t, ValidateStateTransition(AccountStatus("invalid"), AccountStatusActive)) + + // Test to status not in allowed list + assert.False(t, ValidateStateTransition(AccountStatusPending, AccountStatusSuspended)) + assert.False(t, ValidateStateTransition(AccountStatusActive, AccountStatusPending)) +} + +// TestValidatePackageStateTransition_Invalid 测试无效套餐状态转换 +func TestValidatePackageStateTransition_Invalid(t *testing.T) { + // Test invalid from status + assert.False(t, ValidatePackageStateTransition(PackageStatus("invalid"), PackageStatusActive)) + + // Test to status not in allowed list + assert.False(t, ValidatePackageStateTransition(PackageStatusDraft, PackageStatusPaused)) + assert.False(t, ValidatePackageStateTransition(PackageStatusSoldOut, PackageStatusActive)) +} + +// TestInvariantErrorsAll 测试所有不变量错误 +func TestInvariantErrorsAll(t *testing.T) { + errors := []error{ + ErrAccountCannotDeleteActive, + ErrAccountDisabledRequiresAdmin, + ErrPackageSoldOutSystemOnly, + ErrPackageExpiredCannotRestore, + ErrPriceBelowProtection, + ErrSettlementCannotCancel, + ErrWithdrawExceedsBalance, + ErrSettlementBalanceMismatch, + } + + for _, err := range errors { + assert.NotNil(t, err) + assert.NotEmpty(t, err.Error()) + } +} + +// TestInvariantChecker_CheckAccountDelete 测试账号删除检查 +func TestInvariantChecker_CheckAccountDelete(t *testing.T) { + accountStore := newMockAccountStoreForInvariant() + checker := NewInvariantChecker(accountStore, nil, nil) + + // Setup: create an active account + accountStore.accounts[1] = &Account{ + ID: 1, + SupplierID: 1001, + Status: AccountStatusActive, + } + + // Test: active account cannot be deleted + err := checker.CheckAccountDelete(context.Background(), 1, 1001) + assert.Error(t, err) + assert.Contains(t, err.Error(), "cannot delete active") + + // Setup: change to pending account + accountStore.accounts[1].Status = AccountStatusPending + + // Test: pending account can be deleted + err = checker.CheckAccountDelete(context.Background(), 1, 1001) + assert.NoError(t, err) +} + +// TestInvariantChecker_CheckAccountActivate 测试账号激活检查 +func TestInvariantChecker_CheckAccountActivate(t *testing.T) { + accountStore := newMockAccountStoreForInvariant() + checker := NewInvariantChecker(accountStore, nil, nil) + + // Setup: create a disabled account + accountStore.accounts[1] = &Account{ + ID: 1, + SupplierID: 1001, + Status: AccountStatusDisabled, + } + + // Test: disabled account requires admin to activate + err := checker.CheckAccountActivate(context.Background(), 1, 1001) + assert.Error(t, err) + assert.Contains(t, err.Error(), "disabled account requires admin") + + // Setup: change to pending account + accountStore.accounts[1].Status = AccountStatusPending + + // Test: pending account can be activated + err = checker.CheckAccountActivate(context.Background(), 1, 1001) + assert.NoError(t, err) +} + +// TestInvariantChecker_CheckPackagePublish 测试套餐发布检查 +func TestInvariantChecker_CheckPackagePublish(t *testing.T) { + packageStore := newMockPackageStoreForInvariant() + checker := NewInvariantChecker(nil, packageStore, nil) + + // Setup: create an expired package + packageStore.packages[1] = &Package{ + ID: 1, + SupplierID: 1001, + Status: PackageStatusExpired, + } + + // Test: expired package cannot be directly restored + err := checker.CheckPackagePublish(context.Background(), 1, 1001) + assert.Error(t, err) + assert.Contains(t, err.Error(), "expired package") + + // Setup: change to draft package + packageStore.packages[1].Status = PackageStatusDraft + + // Test: draft package can be published + err = checker.CheckPackagePublish(context.Background(), 1, 1001) + assert.NoError(t, err) +} + +// TestInvariantChecker_CheckSettlementCancel 测试结算撤销检查 +func TestInvariantChecker_CheckSettlementCancel(t *testing.T) { + settlementStore := newMockSettlementStoreForInvariant() + checker := NewInvariantChecker(nil, nil, settlementStore) + + // Setup: create a processing settlement + settlementStore.settlements[1] = &Settlement{ + ID: 1, + SupplierID: 1001, + Status: SettlementStatusProcessing, + } + + // Test: processing settlement cannot be cancelled + err := checker.CheckSettlementCancel(context.Background(), 1, 1001) + assert.Error(t, err) + assert.Contains(t, err.Error(), "cannot cancel") + + // Setup: change to pending settlement + settlementStore.settlements[1].Status = SettlementStatusPending + + // Test: pending settlement can be cancelled + err = checker.CheckSettlementCancel(context.Background(), 1, 1001) + assert.NoError(t, err) +} + +// TestInvariantChecker_CheckWithdrawBalance 测试提现余额检查 +func TestInvariantChecker_CheckWithdrawBalance(t *testing.T) { + settlementStore := newMockSettlementStoreForInvariant() + checker := NewInvariantChecker(nil, nil, settlementStore) + + // Setup: set balance to 1000 + settlementStore.balances[1001] = 1000.0 + + // Test: amount less than balance should pass + err := checker.CheckWithdrawBalance(context.Background(), 1001, 500.0) + assert.NoError(t, err) + + // Test: amount equal to balance should pass + err = checker.CheckWithdrawBalance(context.Background(), 1001, 1000.0) + assert.NoError(t, err) + + // Test: amount greater than balance should fail + err = checker.CheckWithdrawBalance(context.Background(), 1001, 1500.0) + assert.Error(t, err) + assert.Contains(t, err.Error(), "exceeds available balance") +} + +// TestInvariantChecker_NonExistent 测试不存在的实体 +func TestInvariantChecker_NonExistent(t *testing.T) { + accountStore := newMockAccountStoreForInvariant() + packageStore := newMockPackageStoreForInvariant() + settlementStore := newMockSettlementStoreForInvariant() + checker := NewInvariantChecker(accountStore, packageStore, settlementStore) + + // Test non-existent account + err := checker.CheckAccountDelete(context.Background(), 999, 1001) + assert.Error(t, err) + + // Test non-existent package + err = checker.CheckPackagePublish(context.Background(), 999, 1001) + assert.Error(t, err) + + // Test non-existent settlement + err = checker.CheckSettlementCancel(context.Background(), 999, 1001) + assert.Error(t, err) +} diff --git a/supply-api/internal/domain/outbox_test.go b/supply-api/internal/domain/outbox_test.go new file mode 100644 index 00000000..7c60d186 --- /dev/null +++ b/supply-api/internal/domain/outbox_test.go @@ -0,0 +1,389 @@ +package domain + +import ( + "context" + "encoding/json" + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +// ==================== P0-06 Outbox模式测试 ==================== + +// mockOutboxEventStore Mock Outbox事件存储 +type mockOutboxEventStore struct { + events map[string]*OutboxEvent + processed []*OutboxEvent + failed []*OutboxEvent + deadLetter []*OutboxEvent +} + +func newMockOutboxEventStore() *mockOutboxEventStore { + return &mockOutboxEventStore{ + events: make(map[string]*OutboxEvent), + } +} + +func (m *mockOutboxEventStore) FetchAndLock(ctx context.Context, limit int) ([]*OutboxEvent, error) { + var result []*OutboxEvent + for _, e := range m.events { + if e.Status == OutboxStatusPending || e.Status == OutboxStatusFailed { + if e.NextRetryAt == nil || e.NextRetryAt.Before(time.Now()) { + e.Status = OutboxStatusProcessing + result = append(result, e) + if len(result) >= limit { + break + } + } + } + } + return result, nil +} + +func (m *mockOutboxEventStore) MarkCompleted(ctx context.Context, eventID string) error { + if e, ok := m.events[eventID]; ok { + e.Status = OutboxStatusCompleted + now := time.Now() + e.ProcessedAt = &now + m.processed = append(m.processed, e) + } + return nil +} + +func (m *mockOutboxEventStore) MarkFailed(ctx context.Context, eventID string, errorMsg string) error { + if e, ok := m.events[eventID]; ok { + e.Status = OutboxStatusFailed + e.ErrorMessage = errorMsg + backoff := calculateBackoff(e.RetryCount, e.MaxRetries) + nextRetry := time.Now().Add(time.Duration(backoff) * time.Second) + e.NextRetryAt = &nextRetry + m.failed = append(m.failed, e) + } + return nil +} + +func (m *mockOutboxEventStore) MoveToDeadLetter(ctx context.Context, event *OutboxEvent, errorMsg string) error { + event.Status = OutboxStatusDeadLetter + event.DeadLetterReason = errorMsg + m.deadLetter = append(m.deadLetter, event) + return nil +} + +// mockMessageBroker Mock消息代理 +type mockMessageBroker struct { + published []*OutboxEvent + shouldFail bool + failError error +} + +func newMockMessageBroker() *mockMessageBroker { + return &mockMessageBroker{ + published: make([]*OutboxEvent, 0), + } +} + +func (m *mockMessageBroker) Publish(ctx context.Context, event *OutboxEvent) error { + if m.shouldFail { + return m.failError + } + m.published = append(m.published, event) + return nil +} + +// mockOutboxStats Mock统计 +type mockOutboxStats struct { + successCount int + failureCount int + retryCount int + dlqCount int +} + +func (m *mockOutboxStats) RecordOutboxSuccess(eventType string) { + m.successCount++ +} + +func (m *mockOutboxStats) RecordOutboxFailure(reason string) { + m.failureCount++ +} + +func (m *mockOutboxStats) RecordOutboxRetry(eventType string) { + m.retryCount++ +} + +func (m *mockOutboxStats) RecordOutboxDLQ(eventType string) { + m.dlqCount++ +} + +// TestP006_OutboxEventPublishing 验证Outbox事件发布 +func TestP006_OutboxEventPublishing(t *testing.T) { + store := newMockOutboxEventStore() + broker := newMockMessageBroker() + stats := &mockOutboxStats{} + + processor := &OutboxProcessor{ + eventStore: store, + messageBroker: broker, + stats: stats, + } + + // 添加测试事件 + payload, _ := json.Marshal(map[string]string{"key": "value"}) + event := &OutboxEvent{ + EventID: "evt_123", + AggregateType: "supply_account", + AggregateID: "acc_456", + EventType: "created", + Payload: payload, + Status: OutboxStatusPending, + MaxRetries: 5, + RetryCount: 0, + } + store.events[event.EventID] = event + + // 处理 + err := processor.ProcessOutbox(context.Background()) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // 验证事件已发布 + if len(broker.published) != 1 { + t.Errorf("expected 1 published event, got %d", len(broker.published)) + } + + // 验证统计 + if stats.successCount != 1 { + t.Errorf("expected 1 success, got %d", stats.successCount) + } +} + +// TestP006_OutboxRetryOnFailure 验证失败重试 +func TestP006_OutboxRetryOnFailure(t *testing.T) { + store := newMockOutboxEventStore() + broker := newMockMessageBroker() + stats := &mockOutboxStats{} + + processor := &OutboxProcessor{ + eventStore: store, + messageBroker: broker, + stats: stats, + } + + // 模拟发布失败 + broker.shouldFail = true + broker.failError = errors.New("connection refused") + + // 添加测试事件 + payload, _ := json.Marshal(map[string]string{"key": "value"}) + event := &OutboxEvent{ + EventID: "evt_123", + AggregateType: "supply_account", + AggregateID: "acc_456", + EventType: "created", + Payload: payload, + Status: OutboxStatusPending, + MaxRetries: 5, + RetryCount: 0, + } + store.events[event.EventID] = event + + // 处理 + err := processor.ProcessOutbox(context.Background()) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // 验证统计 + if stats.retryCount != 1 { + t.Errorf("expected 1 retry, got %d", stats.retryCount) + } + + // 验证失败记录 + if len(store.failed) != 1 { + t.Errorf("expected 1 failed event, got %d", len(store.failed)) + } +} + +// TestP006_MoveToDeadLetter 验证超过最大重试后移入死信队列 +func TestP006_MoveToDeadLetter(t *testing.T) { + store := newMockOutboxEventStore() + broker := newMockMessageBroker() + stats := &mockOutboxStats{} + + processor := &OutboxProcessor{ + eventStore: store, + messageBroker: broker, + stats: stats, + } + + // 模拟持续失败 + broker.shouldFail = true + broker.failError = errors.New("persistent failure") + + // 添加已重试4次的事件（第5次失败后应移入DLQ） + payload, _ := json.Marshal(map[string]string{"key": "value"}) + event := &OutboxEvent{ + EventID: "evt_dlq_test", + AggregateType: "supply_account", + AggregateID: "acc_456", + EventType: "created", + Payload: payload, + Status: OutboxStatusPending, + MaxRetries: 5, + RetryCount: 4, // 第5次重试后达到上限 + } + store.events[event.EventID] = event + + // 处理 + err := processor.ProcessOutbox(context.Background()) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // 验证DLQ统计 + if stats.dlqCount != 1 { + t.Errorf("expected 1 DLQ, got %d", stats.dlqCount) + } + + // 验证死信记录 + if len(store.deadLetter) != 1 { + t.Errorf("expected 1 dead letter event, got %d", len(store.deadLetter)) + } +} + +// TestP006_ExponentialBackoff 验证指数退避计算 +func TestP006_ExponentialBackoff(t *testing.T) { + tests := []struct { + retryCount int + maxRetries int + expectedMin int + expectedMax int + }{ + {1, 5, 1, 2}, // 第1次重试: 1-2秒 + {2, 5, 2, 4}, // 第2次重试: 2-4秒 + {3, 5, 4, 8}, // 第3次重试: 4-8秒 + {4, 5, 8, 16}, // 第4次重试: 8-16秒 + {5, 5, 16, 32}, // 第5次重试: 16-32秒（接近上限） + } + + for _, tt := range tests { + backoff := calculateBackoff(tt.retryCount, tt.maxRetries) + if backoff < tt.expectedMin || backoff > tt.expectedMax { + t.Errorf("retry %d: expected backoff %d-%d, got %d", + tt.retryCount, tt.expectedMin, tt.expectedMax, backoff) + } + } +} + +// TestP006_MaxBackoffCap 验证退避时间上限 +func TestP006_MaxBackoffCap(t *testing.T) { + // 即使重试很多次，退避时间也不应超过60秒 + backoff := calculateBackoff(100, 100) + if backoff > DefaultMaxBackoffSeconds { + t.Errorf("backoff should be capped at %d, got %d", DefaultMaxBackoffSeconds, backoff) + } +} + +// TestP006_Summary 测试总结 +func TestP006_Summary(t *testing.T) { + t.Log("=== P0-06 Outbox模式测试总结 ===") + t.Log("问题: Outbox事件 至少一次投递 未定义重试策略和DLQ处理") + t.Log("") + t.Log("修复方案:") + t.Log(" - Outbox事件表结构定义") + t.Log(" - 死信队列表结构定义") + t.Log(" - 重试策略: 指数退避 (1s, 2s, 4s, 8s, 16s)") + t.Log(" - 最大重试次数: 5次") + t.Log(" - 超过最大重试后移入DLQ") + t.Log("") + t.Log("SQL脚本: sql/postgresql/outbox_pattern_v1.sql") +} + +// TestDefaultOutboxProcessorConfig 测试默认配置 +func TestDefaultOutboxProcessorConfig(t *testing.T) { + config := DefaultOutboxProcessorConfig() + + assert.NotNil(t, config) + assert.Equal(t, DefaultMaxRetries, config.MaxRetries) + assert.Equal(t, DefaultInitialBackoffSeconds, config.InitialBackoffSeconds) + assert.Equal(t, DefaultMaxBackoffSeconds, config.MaxBackoffSeconds) + assert.Equal(t, 100, config.BatchSize) +} + +// TestOutboxConstants 测试outbox常量 +func TestOutboxConstants(t *testing.T) { + assert.Equal(t, 5, DefaultMaxRetries) + assert.Equal(t, 1, DefaultInitialBackoffSeconds) + assert.Equal(t, 60, DefaultMaxBackoffSeconds) +} + +// TestOutboxProcessorConfig 处理器配置测试 +func TestOutboxProcessorConfig(t *testing.T) { + config := &OutboxProcessorConfig{ + MaxRetries: 10, + InitialBackoffSeconds: 2, + MaxBackoffSeconds: 120, + BatchSize: 50, + } + + assert.Equal(t, 10, config.MaxRetries) + assert.Equal(t, 2, config.InitialBackoffSeconds) + assert.Equal(t, 120, config.MaxBackoffSeconds) + assert.Equal(t, 50, config.BatchSize) +} + +// TestOutboxEventStruct 测试OutboxEvent结构体 +func TestOutboxEventStruct(t *testing.T) { + event := &OutboxEvent{ + ID: 1, + AggregateType: "test-aggregate", + AggregateID: "123", + EventType: "TestEvent", + EventID: "evt-001", + Payload: json.RawMessage(`{"key":"value"}`), + Status: OutboxStatusPending, + RetryCount: 0, + MaxRetries: 5, + CreatedAt: time.Now(), + Version: 1, + } + + assert.Equal(t, int64(1), event.ID) + assert.Equal(t, "test-aggregate", event.AggregateType) + assert.Equal(t, "123", event.AggregateID) + assert.Equal(t, "TestEvent", event.EventType) + assert.Equal(t, "evt-001", event.EventID) + assert.Equal(t, OutboxStatusPending, event.Status) + assert.Equal(t, 0, event.RetryCount) + assert.Equal(t, 5, event.MaxRetries) +} + +// TestOutboxDeadLetterStruct 测试OutboxDeadLetter结构体 +func TestOutboxDeadLetterStruct(t *testing.T) { + now := time.Now() + dl := &OutboxDeadLetter{ + ID: 1, + OriginalEventID: "evt-001", + OriginalAggregateType: "test-aggregate", + OriginalAggregateID: "123", + EventType: "TestEvent", + Payload: json.RawMessage(`{"key":"value"}`), + ErrorMessage: "max retries exceeded", + RetryCount: 5, + FirstFailedAt: now, + DeadLetterAt: now, + Handled: false, + CreatedAt: now, + } + + assert.Equal(t, int64(1), dl.ID) + assert.Equal(t, "evt-001", dl.OriginalEventID) + assert.Equal(t, "test-aggregate", dl.OriginalAggregateType) + assert.Equal(t, "123", dl.OriginalAggregateID) + assert.Equal(t, "TestEvent", dl.EventType) + assert.Equal(t, "max retries exceeded", dl.ErrorMessage) + assert.Equal(t, 5, dl.RetryCount) + assert.False(t, dl.Handled) +} diff --git a/supply-api/internal/domain/package_test.go b/supply-api/internal/domain/package_test.go new file mode 100644 index 00000000..15d15962 --- /dev/null +++ b/supply-api/internal/domain/package_test.go @@ -0,0 +1,567 @@ +package domain + +import ( + "context" + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "lijiaoqiao/supply-api/internal/audit" +) + +// mockPackageStoreForPackageTest Mock套餐存储 +type mockPackageStoreForPackageTest struct { + packages map[int64]*Package + nextID int64 +} + +func newMockPackageStoreForPackageTest() *mockPackageStoreForPackageTest { + return &mockPackageStoreForPackageTest{ + packages: make(map[int64]*Package), + nextID: 1, + } +} + +func (m *mockPackageStoreForPackageTest) Create(ctx context.Context, pkg *Package) error { + pkg.ID = m.nextID + m.nextID++ + m.packages[pkg.ID] = pkg + return nil +} + +func (m *mockPackageStoreForPackageTest) GetByID(ctx context.Context, supplierID, id int64) (*Package, error) { + if pkg, ok := m.packages[id]; ok && pkg.SupplierID == supplierID { + return pkg, nil + } + return nil, errors.New("package not found") +} + +func (m *mockPackageStoreForPackageTest) Update(ctx context.Context, pkg *Package) error { + m.packages[pkg.ID] = pkg + return nil +} + +func (m *mockPackageStoreForPackageTest) List(ctx context.Context, supplierID int64) ([]*Package, error) { + var result []*Package + for _, pkg := range m.packages { + if pkg.SupplierID == supplierID { + result = append(result, pkg) + } + } + return result, nil +} + +// mockAccountStoreForPackageTest Mock账号存储 +type mockAccountStoreForPackageTest struct { + accounts map[int64]*Account +} + +func newMockAccountStoreForPackageTest() *mockAccountStoreForPackageTest { + return &mockAccountStoreForPackageTest{ + accounts: make(map[int64]*Account), + } +} + +func (m *mockAccountStoreForPackageTest) Create(ctx context.Context, account *Account) error { + m.accounts[account.ID] = account + return nil +} + +func (m *mockAccountStoreForPackageTest) GetByID(ctx context.Context, supplierID, id int64) (*Account, error) { + if account, ok := m.accounts[id]; ok && account.SupplierID == supplierID { + return account, nil + } + return nil, errors.New("account not found") +} + +func (m *mockAccountStoreForPackageTest) Update(ctx context.Context, account *Account) error { + m.accounts[account.ID] = account + return nil +} + +func (m *mockAccountStoreForPackageTest) List(ctx context.Context, supplierID int64) ([]*Account, error) { + var result []*Account + for _, account := range m.accounts { + if account.SupplierID == supplierID { + result = append(result, account) + } + } + return result, nil +} + +// mockAuditStoreForPackageTest Mock审计存储 +type mockAuditStoreForPackageTest struct{} + +func (m *mockAuditStoreForPackageTest) Emit(ctx context.Context, event audit.Event) error { + return nil +} + +func (m *mockAuditStoreForPackageTest) Query(ctx context.Context, filter audit.EventFilter) ([]audit.Event, error) { + return nil, nil +} + +func (m *mockAuditStoreForPackageTest) QueryWithTotal(ctx context.Context, filter audit.EventFilter) ([]audit.Event, int64, error) { + return nil, 0, nil +} + +func (m *mockAuditStoreForPackageTest) GetByID(ctx context.Context, eventID string) (audit.Event, error) { + return audit.Event{}, errors.New("not found") +} + +// TestPackageStatusConstants 测试套餐状态常量 +func TestPackageStatusConstants(t *testing.T) { + assert.Equal(t, PackageStatus("draft"), PackageStatusDraft) + assert.Equal(t, PackageStatus("active"), PackageStatusActive) + assert.Equal(t, PackageStatus("paused"), PackageStatusPaused) + assert.Equal(t, PackageStatus("sold_out"), PackageStatusSoldOut) + assert.Equal(t, PackageStatus("expired"), PackageStatusExpired) +} + +// TestPackageStruct 测试套餐结构体 +func TestPackageStruct(t *testing.T) { + now := time.Now() + pkg := &Package{ + ID: 1, + SupplierID: 1001, + AccountID: 2001, + Platform: "openai", + Model: "gpt-4", + TotalQuota: 10000.0, + AvailableQuota: 8000.0, + SoldQuota: 2000.0, + ReservedQuota: 500.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + MinPurchase: 100.0, + StartAt: now, + EndAt: now.Add(30 * 24 * time.Hour), + ValidDays: 30, + MaxConcurrent: 10, + RateLimitRPM: 100, + Status: PackageStatusActive, + TotalOrders: 100, + TotalRevenue: 5000.0, + Rating: 4.5, + RatingCount: 50, + QuotaUnit: "tokens", + PriceUnit: "yuan", + CurrencyCode: "CNY", + Version: 1, + CreatedAt: now, + UpdatedAt: now, + } + + assert.Equal(t, int64(1), pkg.ID) + assert.Equal(t, int64(1001), pkg.SupplierID) + assert.Equal(t, int64(2001), pkg.AccountID) + assert.Equal(t, "openai", pkg.Platform) + assert.Equal(t, "gpt-4", pkg.Model) + assert.Equal(t, 10000.0, pkg.TotalQuota) + assert.Equal(t, 8000.0, pkg.AvailableQuota) + assert.Equal(t, 2000.0, pkg.SoldQuota) + assert.Equal(t, 500.0, pkg.ReservedQuota) + assert.Equal(t, 0.5, pkg.PricePer1MInput) + assert.Equal(t, 1.5, pkg.PricePer1MOutput) + assert.Equal(t, PackageStatusActive, pkg.Status) + assert.Equal(t, 100, pkg.TotalOrders) + assert.Equal(t, 5000.0, pkg.TotalRevenue) + assert.Equal(t, 4.5, pkg.Rating) + assert.Equal(t, 50, pkg.RatingCount) + assert.Equal(t, "CNY", pkg.CurrencyCode) + assert.Equal(t, 1, pkg.Version) +} + +// TestCreatePackageDraftRequest 测试创建套餐草稿请求 +func TestCreatePackageDraftRequest(t *testing.T) { + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + MaxConcurrent: 10, + RateLimitRPM: 100, + } + + assert.Equal(t, int64(1001), req.SupplierID) + assert.Equal(t, int64(2001), req.AccountID) + assert.Equal(t, "gpt-4", req.Model) + assert.Equal(t, 10000.0, req.TotalQuota) + assert.Equal(t, 0.5, req.PricePer1MInput) + assert.Equal(t, 1.5, req.PricePer1MOutput) + assert.Equal(t, 30, req.ValidDays) + assert.Equal(t, 10, req.MaxConcurrent) + assert.Equal(t, 100, req.RateLimitRPM) +} + +// TestBatchUpdatePriceRequest 测试批量更新价格请求 +func TestBatchUpdatePriceRequest(t *testing.T) { + req := &BatchUpdatePriceRequest{ + Items: []BatchPriceItem{ + {PackageID: 1, PricePer1MInput: 0.6}, + {PackageID: 2, PricePer1MOutput: 1.6}, + }, + } + + assert.Len(t, req.Items, 2) + assert.Equal(t, int64(1), req.Items[0].PackageID) + assert.Equal(t, 0.6, req.Items[0].PricePer1MInput) +} + +// TestBatchUpdatePriceResponse 测试批量更新价格响应 +func TestBatchUpdatePriceResponse(t *testing.T) { + resp := &BatchUpdatePriceResponse{ + Total: 10, + SuccessCount: 8, + FailedCount: 2, + Failures: []BatchPriceFailure{ + {PackageID: 1, ErrorCode: "ERR_001", Message: "invalid price"}, + }, + } + + assert.Equal(t, 10, resp.Total) + assert.Equal(t, 8, resp.SuccessCount) + assert.Equal(t, 2, resp.FailedCount) + assert.Len(t, resp.Failures, 1) + assert.Equal(t, int64(1), resp.Failures[0].PackageID) +} + +// TestInvariantPackageErrors 测试套餐相关不变量错误 +func TestInvariantPackageErrors(t *testing.T) { + assert.Contains(t, ErrPackageSoldOutSystemOnly.Error(), "sold_out") + assert.Contains(t, ErrPackageExpiredCannotRestore.Error(), "expired package") + assert.Contains(t, ErrPriceBelowProtection.Error(), "price cannot be below") +} + +// TestNewPackageService 测试创建套餐服务 +func TestNewPackageService(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + assert.NotNil(t, svc) +} + +// TestPackageService_CreateDraft 测试创建套餐草稿 +func TestPackageService_CreateDraft(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + MaxConcurrent: 10, + RateLimitRPM: 100, + } + + pkg, err := svc.CreateDraft(context.Background(), 1001, req) + assert.NoError(t, err) + assert.NotNil(t, pkg) + assert.Equal(t, int64(1001), pkg.SupplierID) + assert.Equal(t, "gpt-4", pkg.Model) + assert.Equal(t, PackageStatusDraft, pkg.Status) + assert.Equal(t, 10000.0, pkg.AvailableQuota) + assert.Equal(t, 1, pkg.Version) +} + +// TestPackageService_Publish 测试发布套餐 +func TestPackageService_Publish(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 先创建草稿 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + + // 发布 + published, err := svc.Publish(context.Background(), 1001, pkg.ID) + assert.NoError(t, err) + assert.NotNil(t, published) + assert.Equal(t, PackageStatusActive, published.Status) +} + +// TestPackageService_Publish_ExpiredPackage 测试发布过期套餐 +func TestPackageService_Publish_ExpiredPackage(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建并直接标记为 expired（通过手动设置 store） + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + pkgStore.packages[pkg.ID].Status = PackageStatusExpired + + // 尝试发布过期套餐应该失败 + _, err := svc.Publish(context.Background(), 1001, pkg.ID) + assert.Error(t, err) +} + +// TestPackageService_Pause 测试暂停套餐 +func TestPackageService_Pause(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建并发布 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + svc.Publish(context.Background(), 1001, pkg.ID) + + // 暂停 + paused, err := svc.Pause(context.Background(), 1001, pkg.ID) + assert.NoError(t, err) + assert.Equal(t, PackageStatusPaused, paused.Status) +} + +// TestPackageService_Unlist 测试下架套餐 +func TestPackageService_Unlist(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建并发布 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + svc.Publish(context.Background(), 1001, pkg.ID) + + // 下架 + unlisted, err := svc.Unlist(context.Background(), 1001, pkg.ID) + assert.NoError(t, err) + assert.Equal(t, PackageStatusExpired, unlisted.Status) +} + +// TestPackageService_GetByID 测试获取套餐 +func TestPackageService_GetByID(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建套餐 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + + // 获取 + found, err := svc.GetByID(context.Background(), 1001, pkg.ID) + assert.NoError(t, err) + assert.NotNil(t, found) + assert.Equal(t, pkg.ID, found.ID) +} + +// TestPackageService_GetByID_NotFound 测试获取不存在的套餐 +func TestPackageService_GetByID_NotFound(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + _, err := svc.GetByID(context.Background(), 1001, 9999) + assert.Error(t, err) +} + +// TestPackageService_Clone 测试克隆套餐 +func TestPackageService_Clone(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建并发布原套餐 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + MaxConcurrent: 10, + RateLimitRPM: 100, + } + original, _ := svc.CreateDraft(context.Background(), 1001, req) + svc.Publish(context.Background(), 1001, original.ID) + + // 克隆 + clone, err := svc.Clone(context.Background(), 1001, original.ID) + assert.NoError(t, err) + assert.NotNil(t, clone) + assert.NotEqual(t, original.ID, clone.ID) + assert.Equal(t, original.SupplierID, clone.SupplierID) + assert.Equal(t, original.AccountID, clone.AccountID) + assert.Equal(t, original.Model, clone.Model) + assert.Equal(t, original.TotalQuota, clone.TotalQuota) + assert.Equal(t, original.TotalQuota, clone.AvailableQuota) // 可用配额重置为总量 + assert.Equal(t, 0.0, clone.SoldQuota) // 售出配额重置为0 + assert.Equal(t, PackageStatusDraft, clone.Status) // 克隆后为草稿状态 +} + +// TestPackageService_Clone_NotFound 测试克隆不存在的套餐 +func TestPackageService_Clone_NotFound(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + _, err := svc.Clone(context.Background(), 1001, 9999) + assert.Error(t, err) +} + +// TestPackageService_BatchUpdatePrice 测试批量更新价格 +func TestPackageService_BatchUpdatePrice(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建套餐 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + svc.Publish(context.Background(), 1001, pkg.ID) + + // 批量更新价格 + batchReq := &BatchUpdatePriceRequest{ + Items: []BatchPriceItem{ + {PackageID: pkg.ID, PricePer1MInput: 0.6, PricePer1MOutput: 1.6}, + }, + } + + resp, err := svc.BatchUpdatePrice(context.Background(), 1001, batchReq) + assert.NoError(t, err) + assert.NotNil(t, resp) + assert.Equal(t, 1, resp.Total) + assert.Equal(t, 1, resp.SuccessCount) + assert.Equal(t, 0, resp.FailedCount) +} + +// TestPackageService_BatchUpdatePrice_NegativePrice 测试批量更新价格-负数价格 +func TestPackageService_BatchUpdatePrice_NegativePrice(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + // 创建套餐 + req := &CreatePackageDraftRequest{ + SupplierID: 1001, + AccountID: 2001, + Model: "gpt-4", + TotalQuota: 10000.0, + PricePer1MInput: 0.5, + PricePer1MOutput: 1.5, + ValidDays: 30, + } + pkg, _ := svc.CreateDraft(context.Background(), 1001, req) + svc.Publish(context.Background(), 1001, pkg.ID) + + // 批量更新价格为负数 + batchReq := &BatchUpdatePriceRequest{ + Items: []BatchPriceItem{ + {PackageID: pkg.ID, PricePer1MInput: -0.1, PricePer1MOutput: 1.6}, + }, + } + + resp, err := svc.BatchUpdatePrice(context.Background(), 1001, batchReq) + assert.NoError(t, err) + assert.Equal(t, 1, resp.Total) + assert.Equal(t, 0, resp.SuccessCount) + assert.Equal(t, 1, resp.FailedCount) + assert.Contains(t, resp.Failures[0].Message, "price cannot be negative") +} + +// TestPackageService_BatchUpdatePrice_NotFound 测试批量更新价格-套餐不存在 +func TestPackageService_BatchUpdatePrice_NotFound(t *testing.T) { + pkgStore := newMockPackageStoreForPackageTest() + acctStore := newMockAccountStoreForPackageTest() + auditStore := &mockAuditStoreForPackageTest{} + + svc := NewPackageService(pkgStore, acctStore, auditStore) + + batchReq := &BatchUpdatePriceRequest{ + Items: []BatchPriceItem{ + {PackageID: 9999, PricePer1MInput: 0.6, PricePer1MOutput: 1.6}, + }, + } + + resp, err := svc.BatchUpdatePrice(context.Background(), 1001, batchReq) + assert.NoError(t, err) + assert.Equal(t, 1, resp.Total) + assert.Equal(t, 0, resp.SuccessCount) + assert.Equal(t, 1, resp.FailedCount) + assert.Equal(t, "NOT_FOUND", resp.Failures[0].ErrorCode) +} diff --git a/supply-api/internal/domain/settlement.go b/supply-api/internal/domain/settlement.go index 1a87ac57..0d569b87 100644 --- a/supply-api/internal/domain/settlement.go +++ b/supply-api/internal/domain/settlement.go @@ -132,10 +132,12 @@ type PlatformStat struct { } // 结算仓储接口 +// P1-005: 乐观锁支持 - Update需要expectedVersion参数防止并发更新 type SettlementStore interface { Create(ctx context.Context, s *Settlement) error GetByID(ctx context.Context, supplierID, id int64) (*Settlement, error) - Update(ctx context.Context, s *Settlement) error + // Update 使用乐观锁，expectedVersion是更新前的版本号，如果版本不匹配返回ErrConcurrencyConflict + Update(ctx context.Context, s *Settlement, expectedVersion int) error List(ctx context.Context, supplierID int64) ([]*Settlement, error) GetWithdrawableBalance(ctx context.Context, supplierID int64) (float64, error) } @@ -227,11 +229,14 @@ func (s *settlementService) Cancel(ctx context.Context, supplierID, settlementID return nil, errors.New("SUP_SET_4092: cannot cancel processing or completed settlements") } + // 保存更新前的版本号用于乐观锁 + expectedVersion := settlement.Version + settlement.Status = SettlementStatusFailed settlement.UpdatedAt = time.Now() - settlement.Version++ + // 注意：Version++由Repository的Update方法自动处理 - if err := s.store.Update(ctx, settlement); err != nil { + if err := s.store.Update(ctx, settlement, expectedVersion); err != nil { return nil, err } @@ -243,7 +248,8 @@ func (s *settlementService) Cancel(ctx context.Context, supplierID, settlementID ResultCode: "OK", }) - return settlement, nil + // 重新获取更新后的settlement + return s.store.GetByID(ctx, supplierID, settlementID) } func (s *settlementService) GetByID(ctx context.Context, supplierID, settlementID int64) (*Settlement, error) { diff --git a/supply-api/internal/domain/settlement_test.go b/supply-api/internal/domain/settlement_test.go new file mode 100644 index 00000000..98d252f2 --- /dev/null +++ b/supply-api/internal/domain/settlement_test.go @@ -0,0 +1,489 @@ +package domain + +import ( + "context" + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "lijiaoqiao/supply-api/internal/audit" +) + +// mockSettlementStore Mock结算存储 +type mockSettlementStore struct { + settlements map[int64]*Settlement + balances map[int64]float64 + nextID int64 +} + +func newMockSettlementStore() *mockSettlementStore { + return &mockSettlementStore{ + settlements: make(map[int64]*Settlement), + balances: make(map[int64]float64), + nextID: 1, + } +} + +func (m *mockSettlementStore) Create(ctx context.Context, s *Settlement) error { + s.ID = m.nextID + m.nextID++ + m.settlements[s.ID] = s + return nil +} + +func (m *mockSettlementStore) GetByID(ctx context.Context, supplierID, id int64) (*Settlement, error) { + if s, ok := m.settlements[id]; ok && s.SupplierID == supplierID { + return s, nil + } + return nil, errors.New("settlement not found") +} + +func (m *mockSettlementStore) Update(ctx context.Context, s *Settlement, expectedVersion int) error { + if s.Version != expectedVersion { + return errors.New("concurrency conflict") + } + m.settlements[s.ID] = s + return nil +} + +func (m *mockSettlementStore) List(ctx context.Context, supplierID int64) ([]*Settlement, error) { + var result []*Settlement + for _, s := range m.settlements { + if s.SupplierID == supplierID { + result = append(result, s) + } + } + return result, nil +} + +func (m *mockSettlementStore) GetWithdrawableBalance(ctx context.Context, supplierID int64) (float64, error) { + if balance, ok := m.balances[supplierID]; ok { + return balance, nil + } + return 0, nil +} + +// mockEarningStore Mock收益存储 +type mockEarningStore struct { + records []*EarningRecord +} + +func newMockEarningStore() *mockEarningStore { + return &mockEarningStore{ + records: make([]*EarningRecord, 0), + } +} + +func (m *mockEarningStore) ListRecords(ctx context.Context, supplierID int64, startDate, endDate string, page, pageSize int) ([]*EarningRecord, int, error) { + var result []*EarningRecord + for _, r := range m.records { + if r.SupplierID == supplierID { + result = append(result, r) + } + } + return result, len(result), nil +} + +func (m *mockEarningStore) GetBillingSummary(ctx context.Context, supplierID int64, startDate, endDate string) (*BillingSummary, error) { + return &BillingSummary{ + Period: BillingPeriod{ + Start: startDate, + End: endDate, + }, + Summary: BillingTotal{ + TotalRevenue: 1000.00, + TotalOrders: 100, + TotalUsage: 5000, + TotalRequests: 10000, + AvgSuccessRate: 99.5, + PlatformFee: 10.00, + NetEarnings: 990.00, + }, + }, nil +} + +// mockAuditStoreForSettlement Mock审计存储 +type mockAuditStoreForSettlement struct{} + +func (m *mockAuditStoreForSettlement) Emit(ctx context.Context, event audit.Event) error { + return nil +} + +func (m *mockAuditStoreForSettlement) Query(ctx context.Context, filter audit.EventFilter) ([]audit.Event, error) { + return nil, nil +} + +func (m *mockAuditStoreForSettlement) QueryWithTotal(ctx context.Context, filter audit.EventFilter) ([]audit.Event, int64, error) { + return nil, 0, nil +} + +func (m *mockAuditStoreForSettlement) GetByID(ctx context.Context, eventID string) (audit.Event, error) { + return audit.Event{}, errors.New("not found") +} + +// TestSettlementConstants 测试结算状态常量 +func TestSettlementConstants(t *testing.T) { + assert.Equal(t, SettlementStatus("pending"), SettlementStatusPending) + assert.Equal(t, SettlementStatus("processing"), SettlementStatusProcessing) + assert.Equal(t, SettlementStatus("completed"), SettlementStatusCompleted) + assert.Equal(t, SettlementStatus("failed"), SettlementStatusFailed) +} + +// TestPaymentMethodConstants 测试支付方式常量 +func TestPaymentMethodConstants(t *testing.T) { + assert.Equal(t, PaymentMethod("bank"), PaymentMethodBank) + assert.Equal(t, PaymentMethod("alipay"), PaymentMethodAlipay) + assert.Equal(t, PaymentMethod("wechat"), PaymentMethodWechat) +} + +// TestSettlementStruct 测试结算单结构体 +func TestSettlementStruct(t *testing.T) { + now := time.Now() + s := &Settlement{ + ID: 1, + SupplierID: 1001, + SettlementNo: "SET-2024-001", + Status: SettlementStatusPending, + TotalAmount: 1000.00, + FeeAmount: 10.00, + NetAmount: 990.00, + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + PeriodStart: now, + PeriodEnd: now.Add(24 * time.Hour), + TotalOrders: 100, + CurrencyCode: "CNY", + AmountUnit: "yuan", + Version: 1, + CreatedAt: now, + UpdatedAt: now, + } + + assert.Equal(t, int64(1), s.ID) + assert.Equal(t, int64(1001), s.SupplierID) + assert.Equal(t, "SET-2024-001", s.SettlementNo) + assert.Equal(t, SettlementStatusPending, s.Status) + assert.Equal(t, 1000.00, s.TotalAmount) + assert.Equal(t, 10.00, s.FeeAmount) + assert.Equal(t, 990.00, s.NetAmount) + assert.Equal(t, PaymentMethodBank, s.PaymentMethod) + assert.Equal(t, "1234567890", s.PaymentAccount) + assert.Equal(t, 100, s.TotalOrders) + assert.Equal(t, "CNY", s.CurrencyCode) + assert.Equal(t, "yuan", s.AmountUnit) + assert.Equal(t, 1, s.Version) +} + +// TestEarningRecordStruct 测试收益记录结构体 +func TestEarningRecordStruct(t *testing.T) { + now := time.Now() + e := &EarningRecord{ + ID: 1, + SupplierID: 1001, + SettlementID: 10, + EarningsType: "usage", + Amount: 500.00, + Status: "available", + Description: "usage earnings", + EarnedAt: now, + } + + assert.Equal(t, int64(1), e.ID) + assert.Equal(t, int64(1001), e.SupplierID) + assert.Equal(t, int64(10), e.SettlementID) + assert.Equal(t, "usage", e.EarningsType) + assert.Equal(t, 500.00, e.Amount) + assert.Equal(t, "available", e.Status) +} + +// TestSettlementStatusTransitions 测试结算状态转换 +func TestSettlementStatusTransitions(t *testing.T) { + // 测试有效状态 + s := &Settlement{Status: SettlementStatusPending} + assert.Equal(t, SettlementStatusPending, s.Status) + + s.Status = SettlementStatusProcessing + assert.Equal(t, SettlementStatusProcessing, s.Status) + + s.Status = SettlementStatusCompleted + assert.Equal(t, SettlementStatusCompleted, s.Status) + + s.Status = SettlementStatusFailed + assert.Equal(t, SettlementStatusFailed, s.Status) +} + +// TestInvariantErrors 测试结算相关不变量错误 +func TestSettlementInvariantErrors(t *testing.T) { + // ERRORS from invariants.go related to settlements + assert.Contains(t, ErrSettlementCannotCancel.Error(), "cannot cancel") + assert.Contains(t, ErrWithdrawExceedsBalance.Error(), "exceeds available balance") + assert.Contains(t, ErrSettlementBalanceMismatch.Error(), "does not match balance") +} + +// TestNewSettlementService 测试创建结算服务 +func TestNewSettlementService(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + assert.NotNil(t, svc) +} + +// TestSettlementService_Withdraw 测试提现 +func TestSettlementService_Withdraw(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + + // 设置余额 + store.balances[1001] = 5000.0 + + tests := []struct { + name string + req *WithdrawRequest + wantErr bool + errMsg string + }{ + { + name: "invalid sms code", + req: &WithdrawRequest{ + Amount: 1000, + SMSCode: "000000", + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + }, + wantErr: true, + errMsg: "invalid sms code", + }, + { + name: "negative amount", + req: &WithdrawRequest{ + Amount: -100, + SMSCode: "123456", + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + }, + wantErr: true, + errMsg: "must be positive", + }, + { + name: "zero amount", + req: &WithdrawRequest{ + Amount: 0, + SMSCode: "123456", + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + }, + wantErr: true, + errMsg: "must be positive", + }, + { + name: "exceeds balance", + req: &WithdrawRequest{ + Amount: 10000, + SMSCode: "123456", + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + }, + wantErr: true, + errMsg: "exceeds available balance", + }, + { + name: "success", + req: &WithdrawRequest{ + Amount: 1000, + SMSCode: "123456", + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + }, + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := svc.Withdraw(context.Background(), 1001, tt.req) + if tt.wantErr { + assert.Error(t, err) + assert.Contains(t, err.Error(), tt.errMsg) + } else { + assert.NoError(t, err) + assert.NotNil(t, result) + assert.Equal(t, int64(1001), result.SupplierID) + assert.Equal(t, SettlementStatusPending, result.Status) + assert.Equal(t, 1000.0, result.TotalAmount) + assert.Equal(t, 10.0, result.FeeAmount) // 1% fee + assert.Equal(t, 990.0, result.NetAmount) // 99% + } + }) + } +} + +// TestSettlementService_Cancel 测试取消结算 +func TestSettlementService_Cancel(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + + // 创建待处理结算 + settlement := &Settlement{ + ID: 1, + SupplierID: 1001, + SettlementNo: "SET-001", + Status: SettlementStatusPending, + TotalAmount: 1000, + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + Version: 1, + } + store.Create(context.Background(), settlement) + + // 取消待处理结算应该成功 + canceled, err := svc.Cancel(context.Background(), 1001, 1) + assert.NoError(t, err) + assert.NotNil(t, canceled) + assert.Equal(t, SettlementStatusFailed, canceled.Status) +} + +// TestSettlementService_Cancel_ProcessingFails 测试取消处理中结算失败 +func TestSettlementService_Cancel_ProcessingFails(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + + // 创建处理中结算 + settlement := &Settlement{ + ID: 1, + SupplierID: 1001, + SettlementNo: "SET-001", + Status: SettlementStatusProcessing, + TotalAmount: 1000, + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + Version: 1, + } + store.Create(context.Background(), settlement) + + // 取消处理中结算应该失败 + _, err := svc.Cancel(context.Background(), 1001, 1) + assert.Error(t, err) + assert.Contains(t, err.Error(), "cannot cancel") +} + +// TestSettlementService_GetByID 测试获取结算单 +func TestSettlementService_GetByID(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + + // 创建结算单 + settlement := &Settlement{ + SupplierID: 1001, + SettlementNo: "SET-001", + Status: SettlementStatusPending, + TotalAmount: 1000, + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + Version: 1, + } + store.Create(context.Background(), settlement) + + // 获取 + found, err := svc.GetByID(context.Background(), 1001, settlement.ID) + assert.NoError(t, err) + assert.NotNil(t, found) + assert.Equal(t, settlement.ID, found.ID) +} + +// TestSettlementService_GetByID_NotFound 测试获取不存在的结算单 +func TestSettlementService_GetByID_NotFound(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + + _, err := svc.GetByID(context.Background(), 1001, 9999) + assert.Error(t, err) +} + +// TestSettlementService_List 测试列出结算单 +func TestSettlementService_List(t *testing.T) { + store := newMockSettlementStore() + earningStore := newMockEarningStore() + auditStore := &mockAuditStoreForSettlement{} + + svc := NewSettlementService(store, earningStore, auditStore) + + // 创建结算单 + for i := 0; i < 3; i++ { + settlement := &Settlement{ + SupplierID: 1001, + SettlementNo: "SET-00" + string(rune('1'+i)), + Status: SettlementStatusPending, + TotalAmount: 1000 + float64(i)*100, + PaymentMethod: PaymentMethodBank, + PaymentAccount: "1234567890", + Version: 1, + } + store.Create(context.Background(), settlement) + } + + list, err := svc.List(context.Background(), 1001) + assert.NoError(t, err) + assert.Len(t, list, 3) +} + +// TestNewEarningService 测试创建收益服务 +func TestNewEarningService(t *testing.T) { + earningStore := newMockEarningStore() + + svc := NewEarningService(earningStore) + assert.NotNil(t, svc) +} + +// TestEarningService_ListRecords 测试列出收益记录 +func TestEarningService_ListRecords(t *testing.T) { + earningStore := newMockEarningStore() + + svc := NewEarningService(earningStore) + + records, total, err := svc.ListRecords(context.Background(), 1001, "2024-01-01", "2024-01-31", 1, 10) + assert.NoError(t, err) + assert.Equal(t, 0, total) + assert.Len(t, records, 0) +} + +// TestEarningService_GetBillingSummary 测试获取账单摘要 +func TestEarningService_GetBillingSummary(t *testing.T) { + earningStore := newMockEarningStore() + + svc := NewEarningService(earningStore) + + summary, err := svc.GetBillingSummary(context.Background(), 1001, "2024-01-01", "2024-01-31") + assert.NoError(t, err) + assert.NotNil(t, summary) + assert.Equal(t, "2024-01-01", summary.Period.Start) + assert.Equal(t, "2024-01-31", summary.Period.End) + assert.Equal(t, float64(1000), summary.Summary.TotalRevenue) +} + +// TestGenerateSettlementNo 测试生成结算单号 +func TestGenerateSettlementNo(t *testing.T) { + no := generateSettlementNo() + + assert.NotEmpty(t, no) + // 格式为时间戳 20060102150405 + assert.Equal(t, 14, len(no)) +} diff --git a/supply-api/internal/repository/package.go b/supply-api/internal/repository/package.go index 81f48235..9a060814 100644 --- a/supply-api/internal/repository/package.go +++ b/supply-api/internal/repository/package.go @@ -50,7 +50,7 @@ func (r *PackageRepository) Create(ctx context.Context, pkg *domain.Package, req } err := r.pool.QueryRow(ctx, query, - pkg.SupplierID, pkg.SupplierID, pkg.Platform, pkg.Model, + pkg.SupplierID, pkg.AccountID, pkg.Platform, pkg.Model, pkg.TotalQuota, pkg.AvailableQuota, pkg.SoldQuota, pkg.ReservedQuota, pkg.PricePer1MInput, pkg.PricePer1MOutput, pkg.MinPurchase, startAt, endAt, pkg.ValidDays, @@ -85,7 +85,7 @@ func (r *PackageRepository) GetByID(ctx context.Context, supplierID, id int64) ( pkg := &domain.Package{} var startAt, endAt *time.Time err := r.pool.QueryRow(ctx, query, id, supplierID).Scan( - &pkg.ID, &pkg.SupplierID, &pkg.SupplierID, &pkg.Platform, &pkg.Model, + &pkg.ID, &pkg.SupplierID, &pkg.AccountID, &pkg.Platform, &pkg.Model, &pkg.TotalQuota, &pkg.AvailableQuota, &pkg.SoldQuota, &pkg.ReservedQuota, &pkg.PricePer1MInput, &pkg.PricePer1MOutput, &pkg.MinPurchase, &startAt, &endAt, &pkg.ValidDays, @@ -169,7 +169,7 @@ func (r *PackageRepository) GetForUpdate(ctx context.Context, tx pgxpool.Tx, sup pkg := &domain.Package{} err := tx.QueryRow(ctx, query, id, supplierID).Scan( - &pkg.ID, &pkg.SupplierID, &pkg.SupplierID, &pkg.Platform, &pkg.Model, + &pkg.ID, &pkg.SupplierID, &pkg.AccountID, &pkg.Platform, &pkg.Model, &pkg.TotalQuota, &pkg.AvailableQuota, &pkg.SoldQuota, &pkg.ReservedQuota, &pkg.PricePer1MInput, &pkg.PricePer1MOutput, &pkg.Status, &pkg.Version, @@ -210,7 +210,7 @@ func (r *PackageRepository) List(ctx context.Context, supplierID int64) ([]*doma for rows.Next() { pkg := &domain.Package{} err := rows.Scan( - &pkg.ID, &pkg.SupplierID, &pkg.SupplierID, &pkg.Platform, &pkg.Model, + &pkg.ID, &pkg.SupplierID, &pkg.AccountID, &pkg.Platform, &pkg.Model, &pkg.TotalQuota, &pkg.AvailableQuota, &pkg.SoldQuota, &pkg.PricePer1MInput, &pkg.PricePer1MOutput, &pkg.Status, &pkg.MaxConcurrent, &pkg.RateLimitRPM, diff --git a/supply-api/internal/repository/settlement.go b/supply-api/internal/repository/settlement.go index b6832a75..1ae4459a 100644 --- a/supply-api/internal/repository/settlement.go +++ b/supply-api/internal/repository/settlement.go @@ -120,7 +120,9 @@ func (r *SettlementRepository) Update(ctx context.Context, s *domain.Settlement, return nil } -// GetForUpdate 获取结算单并加行锁 +// GetForUpdate 获取结算单并加行锁（悲观锁） +// 注意：在高并发场景下，建议使用 GetForUpdateNoWait 或 乐观锁 +// P1-005: 已添加 NOWAIT 变体和乐观锁支持 func (r *SettlementRepository) GetForUpdate(ctx context.Context, tx pgxpool.Tx, supplierID, id int64) (*domain.Settlement, error) { query := ` SELECT id, settlement_no, user_id, total_amount, fee_amount, net_amount, @@ -148,6 +150,36 @@ func (r *SettlementRepository) GetForUpdate(ctx context.Context, tx pgxpool.Tx, return s, nil } +// GetForUpdateNoWait 获取结算单并加行锁（不等待锁） +// P1-005: NOWAIT变体 - 如果无法获取锁立即返回错误，适用于高并发场景 +func (r *SettlementRepository) GetForUpdateNoWait(ctx context.Context, tx pgxpool.Tx, supplierID, id int64) (*domain.Settlement, error) { + query := ` + SELECT id, settlement_no, user_id, total_amount, fee_amount, net_amount, + status, payment_method, payment_account, version, + created_at, updated_at + FROM supply_settlements + WHERE id = $1 AND user_id = $2 + FOR UPDATE NOWAIT + ` + + s := &domain.Settlement{} + err := tx.QueryRow(ctx, query, id, supplierID).Scan( + &s.ID, &s.SettlementNo, &s.SupplierID, &s.TotalAmount, &s.FeeAmount, &s.NetAmount, + &s.Status, &s.PaymentMethod, &s.PaymentAccount, &s.Version, + &s.CreatedAt, &s.UpdatedAt, + ) + + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + // NOWAIT会导致锁不可用时立即返回错误，而不是等待 + return nil, fmt.Errorf("failed to get settlement for update (nowait): %w", err) + } + + return s, nil +} + // GetProcessing 获取处理中的结算单（用于单一性约束） func (r *SettlementRepository) GetProcessing(ctx context.Context, tx pgxpool.Tx, supplierID int64) (*domain.Settlement, error) { query := ` diff --git a/supply-api/internal/storage/store.go b/supply-api/internal/storage/store.go index af707dc5..d84dfc4d 100644 --- a/supply-api/internal/storage/store.go +++ b/supply-api/internal/storage/store.go @@ -7,6 +7,7 @@ import ( "time" "lijiaoqiao/supply-api/internal/domain" + "lijiaoqiao/supply-api/internal/repository" ) // 错误定义 @@ -175,7 +176,7 @@ func (s *InMemorySettlementStore) GetByID(ctx context.Context, supplierID, id in return settlement, nil } -func (s *InMemorySettlementStore) Update(ctx context.Context, settlement *domain.Settlement) error { +func (s *InMemorySettlementStore) Update(ctx context.Context, settlement *domain.Settlement, expectedVersion int) error { s.mu.Lock() defer s.mu.Unlock() @@ -183,6 +184,13 @@ func (s *InMemorySettlementStore) Update(ctx context.Context, settlement *domain if !ok || existing.SupplierID != settlement.SupplierID { return ErrNotFound } + + // P1-005: 乐观锁检查 + if existing.Version != expectedVersion { + return repository.ErrConcurrencyConflict + } + + settlement.Version = expectedVersion + 1 settlement.UpdatedAt = time.Now() s.settlements[settlement.ID] = settlement return nil diff --git a/supply-api/supply-api b/supply-api/supply-api index 91050793..d4754013 100755 Binary files a/supply-api/supply-api and b/supply-api/supply-api differ