Skip to content

Fully autonomous AI Agents system capable of performing complex penetration testing tasks

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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,
+ 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,
+ 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,
+ 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,
+ 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())
+ })
+}