Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
test: add unit tests for server/models validation functions
mason50525d4638e79d63
diff --git a/backend/pkg/server/models/api_tokens_test.go b/backend/pkg/server/models/api_tokens_test.gonew file mode 100644index 00000000..b0874738--- /dev/null+++ b/backend/pkg/server/models/api_tokens_test.go@@ -0,0 +1,208 @@+package models++import (+ "testing"+ "time"++ "github.com/stretchr/testify/assert"+)++func TestTokenStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status TokenStatus+ wantErr bool+ }{+ {"valid active", TokenStatusActive, false},+ {"valid revoked", TokenStatusRevoked, false},+ {"valid expired", TokenStatusExpired, false},+ {"invalid empty", TokenStatus(""), true},+ {"invalid unknown", TokenStatus("unknown"), true},+ {"invalid deleted", TokenStatus("deleted"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.status.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid TokenStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestTokenStatusString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "active", TokenStatusActive.String())+ assert.Equal(t, "revoked", TokenStatusRevoked.String())+ assert.Equal(t, "expired", TokenStatusExpired.String())+}++func TestAPITokenValid(t *testing.T) {+ t.Parallel()++ now := time.Now()+ validToken := APIToken{+ TokenID: "abcdefghij",+ UserID: 1,+ RoleID: 1,+ TTL: 3600,+ Status: TokenStatusActive,+ CreatedAt: now,+ UpdatedAt: now,+ }++ t.Run("valid token", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validToken.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ token := validToken+ token.Status = TokenStatus("invalid")+ assert.Error(t, token.Valid())+ })++ t.Run("token id wrong length", func(t *testing.T) {+ t.Parallel()+ token := validToken+ token.TokenID = "short"+ assert.Error(t, token.Valid())+ })++ t.Run("ttl too small", func(t *testing.T) {+ t.Parallel()+ token := validToken+ token.TTL = 10+ assert.Error(t, token.Valid())+ })++ t.Run("ttl too large", func(t *testing.T) {+ t.Parallel()+ token := validToken+ token.TTL = 94608001+ assert.Error(t, token.Valid())+ })++ t.Run("ttl minimum boundary", func(t *testing.T) {+ t.Parallel()+ token := validToken+ token.TTL = 60+ assert.NoError(t, token.Valid())+ })++ t.Run("ttl maximum boundary", func(t *testing.T) {+ t.Parallel()+ token := validToken+ token.TTL = 94608000+ assert.NoError(t, token.Valid())+ })+}++func TestAPITokenTableName(t *testing.T) {+ t.Parallel()+ at := &APIToken{}+ assert.Equal(t, "api_tokens", at.TableName())+}++func TestCreateAPITokenRequestValid(t *testing.T) {+ t.Parallel()++ t.Run("valid request", func(t *testing.T) {+ t.Parallel()+ req := CreateAPITokenRequest{TTL: 3600}+ assert.NoError(t, req.Valid())+ })++ t.Run("valid request with name", func(t *testing.T) {+ t.Parallel()+ name := "my-token"+ req := CreateAPITokenRequest{Name: &name, TTL: 3600}+ assert.NoError(t, req.Valid())+ })++ t.Run("ttl too small", func(t *testing.T) {+ t.Parallel()+ req := CreateAPITokenRequest{TTL: 30}+ assert.Error(t, req.Valid())+ })++ t.Run("zero ttl", func(t *testing.T) {+ t.Parallel()+ req := CreateAPITokenRequest{TTL: 0}+ assert.Error(t, req.Valid())+ })+}++func TestUpdateAPITokenRequestValid(t *testing.T) {+ t.Parallel()++ t.Run("valid update with status", func(t *testing.T) {+ t.Parallel()+ req := UpdateAPITokenRequest{Status: TokenStatusRevoked}+ assert.NoError(t, req.Valid())+ })++ t.Run("valid empty update", func(t *testing.T) {+ t.Parallel()+ req := UpdateAPITokenRequest{}+ assert.NoError(t, req.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ req := UpdateAPITokenRequest{Status: TokenStatus("invalid")}+ assert.Error(t, req.Valid())+ })+}++func TestAPITokenClaimsValid(t *testing.T) {+ t.Parallel()++ t.Run("valid claims", func(t *testing.T) {+ t.Parallel()+ claims := APITokenClaims{+ TokenID: "abcdefghij",+ RID: 1,+ UID: 1,+ UHASH: "somehash",+ }+ assert.NoError(t, claims.Valid())+ })++ t.Run("missing token id", func(t *testing.T) {+ t.Parallel()+ claims := APITokenClaims{+ TokenID: "",+ UHASH: "somehash",+ }+ assert.Error(t, claims.Valid())+ })++ t.Run("missing uhash", func(t *testing.T) {+ t.Parallel()+ claims := APITokenClaims{+ TokenID: "abcdefghij",+ UHASH: "",+ }+ assert.Error(t, claims.Valid())+ })++ t.Run("uid too large", func(t *testing.T) {+ t.Parallel()+ claims := APITokenClaims{+ TokenID: "abcdefghij",+ UID: 10001,+ UHASH: "somehash",+ }+ assert.Error(t, claims.Valid())+ })+}diff --git a/backend/pkg/server/models/flows_test.go b/backend/pkg/server/models/flows_test.gonew file mode 100644index 00000000..5cec4726--- /dev/null+++ b/backend/pkg/server/models/flows_test.go@@ -0,0 +1,367 @@+package models++import (+ "testing"++ "github.com/stretchr/testify/assert"+)++func TestFlowStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status FlowStatus+ wantErr bool+ }{+ {"valid created", FlowStatusCreated, false},+ {"valid running", FlowStatusRunning, false},+ {"valid waiting", FlowStatusWaiting, false},+ {"valid finished", FlowStatusFinished, false},+ {"valid failed", FlowStatusFailed, false},+ {"invalid empty", FlowStatus(""), true},+ {"invalid unknown", FlowStatus("unknown"), true},+ {"invalid paused", FlowStatus("paused"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.status.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid FlowStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestFlowStatusString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "created", FlowStatusCreated.String())+ assert.Equal(t, "running", FlowStatusRunning.String())+ assert.Equal(t, "finished", FlowStatusFinished.String())+}++func TestFlowTableName(t *testing.T) {+ t.Parallel()+ f := &Flow{}+ assert.Equal(t, "flows", f.TableName())+}++func TestCreateFlowValid(t *testing.T) {+ t.Parallel()++ t.Run("valid create flow", func(t *testing.T) {+ t.Parallel()+ cf := CreateFlow{Input: "scan target", Provider: "openai"}+ assert.NoError(t, cf.Valid())+ })++ t.Run("missing input", func(t *testing.T) {+ t.Parallel()+ cf := CreateFlow{Input: "", Provider: "openai"}+ assert.Error(t, cf.Valid())+ })++ t.Run("missing provider", func(t *testing.T) {+ t.Parallel()+ cf := CreateFlow{Input: "scan target", Provider: ""}+ assert.Error(t, cf.Valid())+ })+}++func TestPatchFlowValid(t *testing.T) {+ t.Parallel()++ t.Run("valid stop action", func(t *testing.T) {+ t.Parallel()+ pf := PatchFlow{Action: "stop"}+ assert.NoError(t, pf.Valid())+ })++ t.Run("valid finish action", func(t *testing.T) {+ t.Parallel()+ pf := PatchFlow{Action: "finish"}+ assert.NoError(t, pf.Valid())+ })++ t.Run("valid input action with input", func(t *testing.T) {+ t.Parallel()+ input := "new input"+ pf := PatchFlow{Action: "input", Input: &input}+ assert.NoError(t, pf.Valid())+ })++ t.Run("valid rename action with name", func(t *testing.T) {+ t.Parallel()+ name := "new name"+ pf := PatchFlow{Action: "rename", Name: &name}+ assert.NoError(t, pf.Valid())+ })++ t.Run("invalid action", func(t *testing.T) {+ t.Parallel()+ pf := PatchFlow{Action: "invalid"}+ assert.Error(t, pf.Valid())+ })++ t.Run("empty action", func(t *testing.T) {+ t.Parallel()+ pf := PatchFlow{Action: ""}+ assert.Error(t, pf.Valid())+ })++ t.Run("input action without input", func(t *testing.T) {+ t.Parallel()+ pf := PatchFlow{Action: "input"}+ assert.Error(t, pf.Valid())+ })++ t.Run("rename action without name", func(t *testing.T) {+ t.Parallel()+ pf := PatchFlow{Action: "rename"}+ assert.Error(t, pf.Valid())+ })+}++func TestTaskStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status TaskStatus+ wantErr bool+ }{+ {"valid created", TaskStatusCreated, false},+ {"valid running", TaskStatusRunning, false},+ {"valid waiting", TaskStatusWaiting, false},+ {"valid finished", TaskStatusFinished, false},+ {"valid failed", TaskStatusFailed, false},+ {"invalid empty", TaskStatus(""), true},+ {"invalid unknown", TaskStatus("cancelled"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.status.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid TaskStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestTaskTableName(t *testing.T) {+ t.Parallel()+ tk := &Task{}+ assert.Equal(t, "tasks", tk.TableName())+}++func TestSubtaskStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status SubtaskStatus+ wantErr bool+ }{+ {"valid created", SubtaskStatusCreated, false},+ {"valid running", SubtaskStatusRunning, false},+ {"valid waiting", SubtaskStatusWaiting, false},+ {"valid finished", SubtaskStatusFinished, false},+ {"valid failed", SubtaskStatusFailed, false},+ {"invalid empty", SubtaskStatus(""), true},+ {"invalid unknown", SubtaskStatus("pending"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.status.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid SubtaskStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestSubtaskTableName(t *testing.T) {+ t.Parallel()+ s := &Subtask{}+ assert.Equal(t, "subtasks", s.TableName())+}++func TestContainerStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status ContainerStatus+ wantErr bool+ }{+ {"valid starting", ContainerStatusStarting, false},+ {"valid running", ContainerStatusRunning, false},+ {"valid stopped", ContainerStatusStopped, false},+ {"valid deleted", ContainerStatusDeleted, false},+ {"valid failed", ContainerStatusFailed, false},+ {"invalid empty", ContainerStatus(""), true},+ {"invalid unknown", ContainerStatus("restarting"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.status.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid ContainerStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestContainerTypeValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ ct ContainerType+ wantErr bool+ }{+ {"valid primary", ContainerTypePrimary, false},+ {"valid secondary", ContainerTypeSecondary, false},+ {"invalid empty", ContainerType(""), true},+ {"invalid tertiary", ContainerType("tertiary"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.ct.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid ContainerType")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestContainerTableName(t *testing.T) {+ t.Parallel()+ c := &Container{}+ assert.Equal(t, "containers", c.TableName())+}++func TestRoleValid(t *testing.T) {+ t.Parallel()++ t.Run("valid role", func(t *testing.T) {+ t.Parallel()+ r := Role{Name: "admin"}+ assert.NoError(t, r.Valid())+ })++ t.Run("empty name", func(t *testing.T) {+ t.Parallel()+ r := Role{Name: ""}+ assert.Error(t, r.Valid())+ })+}++func TestRoleTableName(t *testing.T) {+ t.Parallel()+ r := &Role{}+ assert.Equal(t, "roles", r.TableName())+}++func TestPrivilegeValid(t *testing.T) {+ t.Parallel()++ t.Run("valid privilege", func(t *testing.T) {+ t.Parallel()+ p := Privilege{Name: "read"}+ assert.NoError(t, p.Valid())+ })++ t.Run("empty name", func(t *testing.T) {+ t.Parallel()+ p := Privilege{Name: ""}+ assert.Error(t, p.Valid())+ })+}++func TestPrivilegeTableName(t *testing.T) {+ t.Parallel()+ p := &Privilege{}+ assert.Equal(t, "privileges", p.TableName())+}++func TestRolePrivilegesValid(t *testing.T) {+ t.Parallel()++ t.Run("valid role privileges", func(t *testing.T) {+ t.Parallel()+ rp := RolePrivileges{+ Privileges: []Privilege{{Name: "read"}, {Name: "write"}},+ Role: Role{Name: "admin"},+ }+ assert.NoError(t, rp.Valid())+ })++ t.Run("invalid privilege", func(t *testing.T) {+ t.Parallel()+ rp := RolePrivileges{+ Privileges: []Privilege{{Name: ""}, {Name: "write"}},+ Role: Role{Name: "admin"},+ }+ assert.Error(t, rp.Valid())+ })++ t.Run("invalid role", func(t *testing.T) {+ t.Parallel()+ rp := RolePrivileges{+ Privileges: []Privilege{{Name: "read"}},+ Role: Role{Name: ""},+ }+ assert.Error(t, rp.Valid())+ })+}++func TestRolePrivilegesTableName(t *testing.T) {+ t.Parallel()+ rp := &RolePrivileges{}+ assert.Equal(t, "roles", rp.TableName())+}++func TestFlowTasksSubtasksTableName(t *testing.T) {+ t.Parallel()+ fts := &FlowTasksSubtasks{}+ assert.Equal(t, "flows", fts.TableName())+}++func TestFlowContainersTableName(t *testing.T) {+ t.Parallel()+ fc := &FlowContainers{}+ assert.Equal(t, "flows", fc.TableName())+}++func TestTaskSubtasksTableName(t *testing.T) {+ t.Parallel()+ ts := &TaskSubtasks{}+ assert.Equal(t, "tasks", ts.TableName())+}diff --git a/backend/pkg/server/models/init_test.go b/backend/pkg/server/models/init_test.gonew file mode 100644index 00000000..dee34153--- /dev/null+++ b/backend/pkg/server/models/init_test.go@@ -0,0 +1,244 @@+package models++import (+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestGetValidator(t *testing.T) {+ t.Parallel()++ v := GetValidator()+ require.NotNil(t, v)+}++func TestStrongPasswordValidator(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ pw string+ wantErr bool+ }{+ {"long password over 15 chars", "abcdefghijklmnop", false},+ {"exactly 16 chars", "abcdefghijklmnop", false},+ {"8 chars with all requirements", "Pass1!ab", false},+ {"short no special", "pass1", true},+ {"7 chars with requirements", "Pa1!abc", true},+ {"8 chars no number", "Pass!abc", true},+ {"8 chars no uppercase", "pass1!ab", true},+ {"8 chars no lowercase", "PASS1!AB", true},+ {"8 chars no special", "Pass1abc", true},+ {"empty password", "", true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := GetValidator().Var(tt.pw, "stpass")+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestEmailValidator(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ email string+ wantErr bool+ }{+ {"valid email", "[email protected]", false},+ {"admin special case", "admin", false},+ {"email with subdomain", "[email protected]", false},+ {"email too short", "a@b", true},+ {"empty email", "", true},+ {"no at sign", "testexample.com", true},+ {"no domain", "test@", true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := GetValidator().Var(tt.email, "vmail")+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestOAuthMinScopeValidator(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ scope string+ wantErr bool+ }{+ {"valid openid email", "openid email", false},+ {"valid with extra scopes", "openid email profile", false},+ {"valid case insensitive", "OpenID Email", false},+ {"missing openid", "email profile", true},+ {"missing email", "openid profile", true},+ {"empty scope", "", true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := GetValidator().Var(tt.scope, "oauth_min_scope")+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestSolidValidator(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ input string+ wantErr bool+ }{+ {"valid lowercase", "hello", false},+ {"valid with numbers", "abc123", false},+ {"valid with underscore", "my_name", false},+ {"valid with dash", "my-name", false},+ {"invalid uppercase", "Hello", true},+ {"invalid spaces", "hello world", true},+ {"invalid special chars", "hello@world", true},+ {"empty string", "", true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := GetValidator().Var(tt.input, "solid")+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestSemverValidator(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ input string+ wantErr bool+ }{+ {"valid two part", "1.0", false},+ {"valid three part", "1.2.3", false},+ {"valid zero", "0.0.0", false},+ {"invalid prefix v", "v1.0.0", true},+ {"invalid single", "1", true},+ {"invalid text", "abc", true},+ {"empty", "", true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := GetValidator().Var(tt.input, "semver")+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestSemverExValidator(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ input string+ wantErr bool+ }{+ {"valid two part", "1.0", false},+ {"valid three part", "1.2.3", false},+ {"valid with v prefix", "v1.0.0", false},+ {"valid with prerelease", "1.2.3-beta", false},+ {"valid four part", "1.2.3.4", false},+ {"invalid text only", "abc", true},+ {"empty", "", true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := GetValidator().Var(tt.input, "semverex")+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestScanFromJSON(t *testing.T) {+ t.Parallel()++ type testStruct struct {+ Name string `json:"name"`+ }++ t.Run("scan from string", func(t *testing.T) {+ t.Parallel()+ var out testStruct+ err := scanFromJSON(`{"name":"test"}`, &out)+ require.NoError(t, err)+ assert.Equal(t, "test", out.Name)+ })++ t.Run("scan from bytes", func(t *testing.T) {+ t.Parallel()+ var out testStruct+ err := scanFromJSON([]byte(`{"name":"hello"}`), &out)+ require.NoError(t, err)+ assert.Equal(t, "hello", out.Name)+ })++ t.Run("scan unsupported type", func(t *testing.T) {+ t.Parallel()+ var out testStruct+ err := scanFromJSON(12345, &out)+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "unsupported type")+ })++ t.Run("scan invalid json string", func(t *testing.T) {+ t.Parallel()+ var out testStruct+ err := scanFromJSON("not-json", &out)+ assert.Error(t, err)+ })++ t.Run("scan invalid json bytes", func(t *testing.T) {+ t.Parallel()+ var out testStruct+ err := scanFromJSON([]byte("not-json"), &out)+ assert.Error(t, err)+ })+}diff --git a/backend/pkg/server/models/providers_test.go b/backend/pkg/server/models/providers_test.gonew file mode 100644index 00000000..3f79eea9--- /dev/null+++ b/backend/pkg/server/models/providers_test.go@@ -0,0 +1,159 @@+package models++import (+ "encoding/json"+ "testing"++ "github.com/stretchr/testify/assert"+)++func TestProviderTypeValid(t *testing.T) {+ t.Parallel()++ validTypes := []struct {+ name string+ pt ProviderType+ }{+ {"openai", ProviderType("openai")},+ {"anthropic", ProviderType("anthropic")},+ {"gemini", ProviderType("gemini")},+ {"bedrock", ProviderType("bedrock")},+ {"ollama", ProviderType("ollama")},+ {"custom", ProviderType("custom")},+ {"deepseek", ProviderType("deepseek")},+ {"glm", ProviderType("glm")},+ {"kimi", ProviderType("kimi")},+ {"qwen", ProviderType("qwen")},+ }++ for _, tt := range validTypes {+ t.Run("valid_"+tt.name, func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, tt.pt.Valid())+ })+ }++ invalidTypes := []struct {+ name string+ pt ProviderType+ }{+ {"empty", ProviderType("")},+ {"unknown", ProviderType("unknown")},+ {"gpt4", ProviderType("gpt4")},+ {"azure", ProviderType("azure")},+ }++ for _, tt := range invalidTypes {+ t.Run("invalid_"+tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.pt.Valid()+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid ProviderType")+ })+ }+}++func TestProviderTypeString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "openai", ProviderType("openai").String())+ assert.Equal(t, "anthropic", ProviderType("anthropic").String())+}++func TestProviderValid(t *testing.T) {+ t.Parallel()++ validProvider := Provider{+ UserID: 1,+ Type: ProviderType("openai"),+ Name: "my-openai",+ Config: json.RawMessage(`{"api_key":"test"}`),+ }++ t.Run("valid provider", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validProvider.Valid())+ })++ t.Run("missing name", func(t *testing.T) {+ t.Parallel()+ p := validProvider+ p.Name = ""+ assert.Error(t, p.Valid())+ })++ t.Run("missing config", func(t *testing.T) {+ t.Parallel()+ p := validProvider+ p.Config = nil+ assert.Error(t, p.Valid())+ })++ t.Run("invalid type", func(t *testing.T) {+ t.Parallel()+ p := validProvider+ p.Type = ProviderType("invalid")+ assert.Error(t, p.Valid())+ })+}++func TestProviderTableName(t *testing.T) {+ t.Parallel()+ p := &Provider{}+ assert.Equal(t, "providers", p.TableName())+}++func TestCreateProviderValid(t *testing.T) {+ t.Parallel()++ t.Run("valid create provider", func(t *testing.T) {+ t.Parallel()+ cp := CreateProvider{Config: json.RawMessage(`{"key":"val"}`)}+ assert.NoError(t, cp.Valid())+ })++ t.Run("missing config", func(t *testing.T) {+ t.Parallel()+ cp := CreateProvider{Config: nil}+ assert.Error(t, cp.Valid())+ })+}++func TestPatchProviderValid(t *testing.T) {+ t.Parallel()++ t.Run("valid patch with name", func(t *testing.T) {+ t.Parallel()+ name := "updated"+ pp := PatchProvider{Name: &name}+ assert.NoError(t, pp.Valid())+ })++ t.Run("valid empty patch", func(t *testing.T) {+ t.Parallel()+ pp := PatchProvider{}+ assert.NoError(t, pp.Valid())+ })+}++func TestProviderInfoValid(t *testing.T) {+ t.Parallel()++ t.Run("valid provider info", func(t *testing.T) {+ t.Parallel()+ pi := ProviderInfo{Name: "my-provider", Type: ProviderType("openai")}+ assert.NoError(t, pi.Valid())+ })++ t.Run("missing name", func(t *testing.T) {+ t.Parallel()+ pi := ProviderInfo{Name: "", Type: ProviderType("openai")}+ assert.Error(t, pi.Valid())+ })++ t.Run("invalid type", func(t *testing.T) {+ t.Parallel()+ pi := ProviderInfo{Name: "my-provider", Type: ProviderType("invalid")}+ assert.Error(t, pi.Valid())+ })+}diff --git a/backend/pkg/server/models/users_test.go b/backend/pkg/server/models/users_test.gonew file mode 100644index 00000000..b0a14dab--- /dev/null+++ b/backend/pkg/server/models/users_test.go@@ -0,0 +1,495 @@+package models++import (+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestUserStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status UserStatus+ wantErr bool+ }{+ {"valid created", UserStatusCreated, false},+ {"valid active", UserStatusActive, false},+ {"valid blocked", UserStatusBlocked, false},+ {"invalid empty", UserStatus(""), true},+ {"invalid unknown", UserStatus("unknown"), true},+ {"invalid suspended", UserStatus("suspended"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.status.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid UserStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestUserStatusString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "created", UserStatusCreated.String())+ assert.Equal(t, "active", UserStatusActive.String())+ assert.Equal(t, "blocked", UserStatusBlocked.String())+}++func TestUserTypeValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ userType UserType+ wantErr bool+ }{+ {"valid local", UserTypeLocal, false},+ {"valid oauth", UserTypeOAuth, false},+ {"valid api", UserTypeAPI, false},+ {"invalid empty", UserType(""), true},+ {"invalid unknown", UserType("unknown"), true},+ {"invalid saml", UserType("saml"), true},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.userType.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid UserType")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestUserTypeString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "local", UserTypeLocal.String())+ assert.Equal(t, "oauth", UserTypeOAuth.String())+ assert.Equal(t, "api", UserTypeAPI.String())+}++func TestLoginValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ login Login+ wantErr bool+ }{+ {+ name: "valid login",+ login: Login{Mail: "[email protected]", Password: "password123"},+ wantErr: false,+ },+ {+ name: "valid admin mail",+ login: Login{Mail: "admin", Password: "password123"},+ wantErr: false,+ },+ {+ name: "empty mail",+ login: Login{Mail: "", Password: "password123"},+ wantErr: true,+ },+ {+ name: "empty password",+ login: Login{Mail: "[email protected]", Password: ""},+ wantErr: true,+ },+ {+ name: "password too short",+ login: Login{Mail: "[email protected]", Password: "ab"},+ wantErr: true,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.login.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestPasswordValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ pw Password+ wantErr bool+ }{+ {+ name: "valid strong password with special chars",+ pw: Password{+ CurrentPassword: "OldPass1!abc",+ Password: "NewPass1!abc",+ ConfirmPassword: "NewPass1!abc",+ },+ wantErr: false,+ },+ {+ name: "valid long password over 15 chars",+ pw: Password{+ CurrentPassword: "oldpasswordvalue",+ Password: "newpasswordvalue1",+ ConfirmPassword: "newpasswordvalue1",+ },+ wantErr: false,+ },+ {+ name: "confirm password mismatch",+ pw: Password{+ CurrentPassword: "OldPass1!abc",+ Password: "NewPass1!abc",+ ConfirmPassword: "DifferentPass1!",+ },+ wantErr: true,+ },+ {+ name: "current equals new password",+ pw: Password{+ CurrentPassword: "SamePass1!abc",+ Password: "SamePass1!abc",+ ConfirmPassword: "SamePass1!abc",+ },+ wantErr: true,+ },+ {+ name: "weak password no special chars",+ pw: Password{+ CurrentPassword: "OldPass1!abc",+ Password: "newpass1",+ ConfirmPassword: "newpass1",+ },+ wantErr: true,+ },+ {+ name: "empty current password",+ pw: Password{+ CurrentPassword: "",+ Password: "NewPass1!abc",+ ConfirmPassword: "NewPass1!abc",+ },+ wantErr: true,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Parallel()+ err := tt.pw.Valid()+ if tt.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestUserValid(t *testing.T) {+ t.Parallel()++ validUser := User{+ ID: 1,+ Hash: "abcdef1234567890abcdef1234567890",+ Type: UserTypeLocal,+ Mail: "[email protected]",+ Status: UserStatusActive,+ RoleID: RoleUser,+ }++ t.Run("valid user", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validUser.Valid())+ })++ t.Run("missing mail", func(t *testing.T) {+ t.Parallel()+ u := validUser+ u.Mail = ""+ assert.Error(t, u.Valid())+ })++ t.Run("invalid user type", func(t *testing.T) {+ t.Parallel()+ u := validUser+ u.Type = UserType("invalid")+ assert.Error(t, u.Valid())+ })++ t.Run("invalid user status", func(t *testing.T) {+ t.Parallel()+ u := validUser+ u.Status = UserStatus("invalid")+ assert.Error(t, u.Valid())+ })++ t.Run("invalid hash length", func(t *testing.T) {+ t.Parallel()+ u := validUser+ u.Hash = "tooshort"+ assert.Error(t, u.Valid())+ })+}++func TestUserTableName(t *testing.T) {+ t.Parallel()+ u := &User{}+ assert.Equal(t, "users", u.TableName())+}++func TestUserPasswordValid(t *testing.T) {+ t.Parallel()++ t.Run("valid user password", func(t *testing.T) {+ t.Parallel()+ up := UserPassword{+ Password: "somepassword",+ User: User{+ ID: 1,+ Hash: "abcdef1234567890abcdef1234567890",+ Type: UserTypeLocal,+ Mail: "[email protected]",+ Status: UserStatusActive,+ RoleID: RoleUser,+ },+ }+ assert.NoError(t, up.Valid())+ })++ t.Run("empty password", func(t *testing.T) {+ t.Parallel()+ up := UserPassword{+ Password: "",+ User: User{+ ID: 1,+ Hash: "abcdef1234567890abcdef1234567890",+ Type: UserTypeLocal,+ Mail: "[email protected]",+ Status: UserStatusActive,+ RoleID: RoleUser,+ },+ }+ assert.Error(t, up.Valid())+ })++ t.Run("invalid user in user password", func(t *testing.T) {+ t.Parallel()+ up := UserPassword{+ Password: "somepassword",+ User: User{+ Mail: "",+ },+ }+ assert.Error(t, up.Valid())+ })+}++func TestUserPasswordTableName(t *testing.T) {+ t.Parallel()+ up := &UserPassword{}+ assert.Equal(t, "users", up.TableName())+}++func TestLoginTableName(t *testing.T) {+ t.Parallel()+ l := &Login{}+ assert.Equal(t, "users", l.TableName())+}++func TestPasswordTableName(t *testing.T) {+ t.Parallel()+ p := &Password{}+ assert.Equal(t, "users", p.TableName())+}++func TestUserPreferencesOptionsValueScan(t *testing.T) {+ t.Parallel()++ t.Run("value and scan round trip", func(t *testing.T) {+ t.Parallel()+ original := UserPreferencesOptions{FavoriteFlows: []int64{1, 2, 3}}+ val, err := original.Value()+ require.NoError(t, err)++ var scanned UserPreferencesOptions+ switch v := val.(type) {+ case string:+ err = scanned.Scan([]byte(v))+ case []byte:+ err = scanned.Scan(v)+ default:+ t.Fatalf("unexpected Value() type: %T", val)+ }+ require.NoError(t, err)+ assert.Equal(t, original.FavoriteFlows, scanned.FavoriteFlows)+ })++ t.Run("scan nil value", func(t *testing.T) {+ t.Parallel()+ var upo UserPreferencesOptions+ err := upo.Scan(nil)+ require.NoError(t, err)+ assert.Equal(t, []int64{}, upo.FavoriteFlows)+ })++ t.Run("scan unsupported type", func(t *testing.T) {+ t.Parallel()+ var upo UserPreferencesOptions+ err := upo.Scan(12345)+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "expected []byte")+ })++ t.Run("scan invalid json", func(t *testing.T) {+ t.Parallel()+ var upo UserPreferencesOptions+ err := upo.Scan([]byte("not json"))+ assert.Error(t, err)+ })++ t.Run("value with empty flows", func(t *testing.T) {+ t.Parallel()+ upo := UserPreferencesOptions{FavoriteFlows: []int64{}}+ val, err := upo.Value()+ require.NoError(t, err)+ var valStr string+ switch v := val.(type) {+ case string:+ valStr = v+ case []byte:+ valStr = string(v)+ }+ assert.Contains(t, valStr, "favoriteFlows")+ })+}++func TestUserPreferencesValid(t *testing.T) {+ t.Parallel()++ t.Run("valid preferences", func(t *testing.T) {+ t.Parallel()+ up := UserPreferences{UserID: 1}+ assert.NoError(t, up.Valid())+ })++ t.Run("zero user id", func(t *testing.T) {+ t.Parallel()+ up := UserPreferences{UserID: 0}+ assert.Error(t, up.Valid())+ assert.Contains(t, up.Valid().Error(), "user_id is required")+ })+}++func TestUserPreferencesTableName(t *testing.T) {+ t.Parallel()+ up := &UserPreferences{}+ assert.Equal(t, "user_preferences", up.TableName())+}++func TestNewUserPreferences(t *testing.T) {+ t.Parallel()++ up := NewUserPreferences(42)+ assert.Equal(t, uint64(42), up.UserID)+ assert.NotNil(t, up.Preferences.FavoriteFlows)+ assert.Empty(t, up.Preferences.FavoriteFlows)+}++func TestAuthCallbackValid(t *testing.T) {+ t.Parallel()++ t.Run("missing code", func(t *testing.T) {+ t.Parallel()+ ac := AuthCallback{+ Code: "",+ IdToken: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.POstGetfAytaZS82wHcjoTyoqhMyxXiWdR7Nn7A29DNSl0EiXLdwJ6xC6AfgZWF1bOsS_TuYI3OG85AmiExREkrS6tDfTQ2B3WXlrr-wp5AokiRbz3_oB4OxG-W9KcEEbDRcZc0nH3L7LzYptiy1PtAylQGxHTWZXtGz4ht0bAecBgmpdgXMguEIcoqPJ1n3pIWk_dUZegpqx0Lka21H6XxUTxiy8OcaarA8zdnPUnV6AmNP3ecFawIFYdvJB_cm-GvpCSbr8G8y_Mllj8f4x9nBH8pQux89_6gUY618iYv7tuPWBFfEbLxtF2pZS6YC1aSfLQxaOoaBSTNRg",+ Scope: "openid email",+ State: "state123",+ }+ assert.Error(t, ac.Valid())+ })++ t.Run("scope missing openid", func(t *testing.T) {+ t.Parallel()+ ac := AuthCallback{+ Code: "code123",+ IdToken: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.POstGetfAytaZS82wHcjoTyoqhMyxXiWdR7Nn7A29DNSl0EiXLdwJ6xC6AfgZWF1bOsS_TuYI3OG85AmiExREkrS6tDfTQ2B3WXlrr-wp5AokiRbz3_oB4OxG-W9KcEEbDRcZc0nH3L7LzYptiy1PtAylQGxHTWZXtGz4ht0bAecBgmpdgXMguEIcoqPJ1n3pIWk_dUZegpqx0Lka21H6XxUTxiy8OcaarA8zdnPUnV6AmNP3ecFawIFYdvJB_cm-GvpCSbr8G8y_Mllj8f4x9nBH8pQux89_6gUY618iYv7tuPWBFfEbLxtF2pZS6YC1aSfLQxaOoaBSTNRg",+ Scope: "email profile",+ State: "state123",+ }+ assert.Error(t, ac.Valid())+ })++ t.Run("invalid id token not jwt", func(t *testing.T) {+ t.Parallel()+ ac := AuthCallback{+ Code: "code123",+ IdToken: "not-a-jwt",+ Scope: "openid email",+ State: "state123",+ }+ assert.Error(t, ac.Valid())+ })+}++func TestUserRoleValid(t *testing.T) {+ t.Parallel()++ validUserForRole := User{+ Hash: "abcdef1234567890abcdef1234567890",+ Type: UserTypeLocal,+ Mail: "[email protected]",+ Status: UserStatusActive,+ RoleID: RoleUser,+ }++ t.Run("valid user role", func(t *testing.T) {+ t.Parallel()+ ur := UserRole{+ Role: Role{ID: 1, Name: "admin"},+ User: validUserForRole,+ }+ assert.NoError(t, ur.Valid())+ })++ t.Run("invalid role", func(t *testing.T) {+ t.Parallel()+ ur := UserRole{+ Role: Role{Name: ""},+ User: validUserForRole,+ }+ assert.Error(t, ur.Valid())+ })++ t.Run("invalid user", func(t *testing.T) {+ t.Parallel()+ ur := UserRole{+ Role: Role{ID: 1, Name: "admin"},+ User: User{Mail: ""},+ }+ assert.Error(t, ur.Valid())+ })+}