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: fill coverage gaps in server/models validation tests
mason505262dbefdd2535
diff --git a/backend/pkg/server/models/api_tokens_test.go b/backend/pkg/server/models/api_tokens_test.goindex b0874738..a2dcf16a 100644--- a/backend/pkg/server/models/api_tokens_test.go+++ b/backend/pkg/server/models/api_tokens_test.go@@ -164,6 +164,52 @@ func TestUpdateAPITokenRequestValid(t *testing.T) {})}+func TestAPITokenWithSecretValid(t *testing.T) {+ t.Parallel()++ now := time.Now()+ validJWT := "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.POstGetfAytaZS82wHcjoTyoqhMyxXiWdR7Nn7A29DNSl0EiXLdwJ6xC6AfgZWF1bOsS_TuYI3OG85AmiExREkrS6tDfTQ2B3WXlrr-wp5AokiRbz3_oB4OxG-W9KcEEbDRcZc0nH3L7LzYptiy1PtAylQGxHTWZXtGz4ht0bAecBgmpdgXMguEIcoqPJ1n3pIWk_dUZegpqx0Lka21H6XxUTxiy8OcaarA8zdnPUnV6AmNP3ecFawIFYdvJB_cm-GvpCSbr8G8y_Mllj8f4x9nBH8pQux89_6gUY618iYv7tuPWBFfEbLxtF2pZS6YC1aSfLQxaOoaBSTNRg"++ baseToken := APIToken{+ TokenID: "abcdefghij",+ UserID: 1,+ RoleID: 1,+ TTL: 3600,+ Status: TokenStatusActive,+ CreatedAt: now,+ UpdatedAt: now,+ }++ t.Run("valid token with secret", func(t *testing.T) {+ t.Parallel()+ ats := APITokenWithSecret{+ APIToken: baseToken,+ Token: validJWT,+ }+ assert.NoError(t, ats.Valid())+ })++ t.Run("invalid embedded api token", func(t *testing.T) {+ t.Parallel()+ badToken := baseToken+ badToken.Status = TokenStatus("invalid")+ ats := APITokenWithSecret{+ APIToken: badToken,+ Token: validJWT,+ }+ assert.Error(t, ats.Valid())+ })++ t.Run("invalid jwt token string", func(t *testing.T) {+ t.Parallel()+ ats := APITokenWithSecret{+ APIToken: baseToken,+ Token: "not-a-jwt",+ }+ assert.Error(t, ats.Valid())+ })+}+func TestAPITokenClaimsValid(t *testing.T) {t.Parallel()diff --git a/backend/pkg/server/models/assistants_test.go b/backend/pkg/server/models/assistants_test.gonew file mode 100644index 00000000..80c4e66a--- /dev/null+++ b/backend/pkg/server/models/assistants_test.go@@ -0,0 +1,210 @@+package models++import (+ "testing"++ "github.com/stretchr/testify/assert"+)++func TestAssistantStatusValid(t *testing.T) {+ t.Parallel()++ tests := []struct {+ name string+ status AssistantStatus+ wantErr bool+ }{+ {"valid created", AssistantStatusCreated, false},+ {"valid running", AssistantStatusRunning, false},+ {"valid waiting", AssistantStatusWaiting, false},+ {"valid finished", AssistantStatusFinished, false},+ {"valid failed", AssistantStatusFailed, false},+ {"invalid empty", AssistantStatus(""), true},+ {"invalid unknown", AssistantStatus("unknown"), true},+ {"invalid paused", AssistantStatus("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 AssistantStatus")+ } else {+ assert.NoError(t, err)+ }+ })+ }+}++func TestAssistantStatusString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "created", AssistantStatusCreated.String())+ assert.Equal(t, "running", AssistantStatusRunning.String())+ assert.Equal(t, "finished", AssistantStatusFinished.String())+}++func TestAssistantValid(t *testing.T) {+ t.Parallel()++ traceID := "trace-123"+ msgchainID := uint64(1)+ validAssistant := Assistant{+ Status: AssistantStatusCreated,+ Title: "test assistant",+ Model: "gpt-4",+ ModelProviderName: "openai",+ ModelProviderType: ProviderType("openai"),+ Language: "en",+ ToolCallIDTemplate: "call_{id}",+ TraceID: &traceID,+ FlowID: 1,+ MsgchainID: &msgchainID,+ }++ t.Run("valid assistant", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validAssistant.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ a := validAssistant+ a.Status = AssistantStatus("invalid")+ assert.Error(t, a.Valid())+ })++ t.Run("missing title", func(t *testing.T) {+ t.Parallel()+ a := validAssistant+ a.Title = ""+ assert.Error(t, a.Valid())+ })++ t.Run("missing model", func(t *testing.T) {+ t.Parallel()+ a := validAssistant+ a.Model = ""+ assert.Error(t, a.Valid())+ })+}++func TestAssistantTableName(t *testing.T) {+ t.Parallel()+ a := &Assistant{}+ assert.Equal(t, "assistants", a.TableName())+}++func TestCreateAssistantValid(t *testing.T) {+ t.Parallel()++ t.Run("valid create assistant", func(t *testing.T) {+ t.Parallel()+ ca := CreateAssistant{Input: "hello", Provider: "openai"}+ assert.NoError(t, ca.Valid())+ })++ t.Run("missing input", func(t *testing.T) {+ t.Parallel()+ ca := CreateAssistant{Input: "", Provider: "openai"}+ assert.Error(t, ca.Valid())+ })++ t.Run("missing provider", func(t *testing.T) {+ t.Parallel()+ ca := CreateAssistant{Input: "hello", Provider: ""}+ assert.Error(t, ca.Valid())+ })+}++func TestPatchAssistantValid(t *testing.T) {+ t.Parallel()++ t.Run("valid stop action", func(t *testing.T) {+ t.Parallel()+ pa := PatchAssistant{Action: "stop"}+ assert.NoError(t, pa.Valid())+ })++ t.Run("valid input action with input", func(t *testing.T) {+ t.Parallel()+ input := "user response"+ pa := PatchAssistant{Action: "input", Input: &input}+ assert.NoError(t, pa.Valid())+ })++ t.Run("invalid action", func(t *testing.T) {+ t.Parallel()+ pa := PatchAssistant{Action: "restart"}+ assert.Error(t, pa.Valid())+ })++ t.Run("input action without input", func(t *testing.T) {+ t.Parallel()+ pa := PatchAssistant{Action: "input"}+ assert.Error(t, pa.Valid())+ })+}++func TestAssistantFlowValid(t *testing.T) {+ t.Parallel()++ traceID := "trace-123"+ mcID := uint64(1)+ validAssistant := Assistant{+ Status: AssistantStatusCreated,+ Title: "test",+ Model: "gpt-4",+ ModelProviderName: "openai",+ ModelProviderType: ProviderType("openai"),+ Language: "en",+ ToolCallIDTemplate: "call_{id}",+ TraceID: &traceID,+ FlowID: 1,+ MsgchainID: &mcID,+ }+ validFlow := Flow{+ Status: FlowStatusCreated,+ Title: "flow",+ Model: "gpt-4",+ ModelProviderName: "openai",+ ModelProviderType: ProviderType("openai"),+ Language: "en",+ ToolCallIDTemplate: "call_{id}",+ TraceID: &traceID,+ UserID: 1,+ }++ t.Run("valid assistant flow", func(t *testing.T) {+ t.Parallel()+ af := AssistantFlow{+ Flow: validFlow,+ Assistant: validAssistant,+ }+ assert.NoError(t, af.Valid())+ })++ t.Run("invalid flow", func(t *testing.T) {+ t.Parallel()+ badFlow := validFlow+ badFlow.Title = ""+ af := AssistantFlow{+ Flow: badFlow,+ Assistant: validAssistant,+ }+ assert.Error(t, af.Valid())+ })++ t.Run("invalid assistant", func(t *testing.T) {+ t.Parallel()+ badAssistant := validAssistant+ badAssistant.Title = ""+ af := AssistantFlow{+ Flow: validFlow,+ Assistant: badAssistant,+ }+ assert.Error(t, af.Valid())+ })+}diff --git a/backend/pkg/server/models/flows_test.go b/backend/pkg/server/models/flows_test.goindex 5cec4726..7ce908d2 100644--- a/backend/pkg/server/models/flows_test.go+++ b/backend/pkg/server/models/flows_test.go@@ -348,20 +348,359 @@ func TestRolePrivilegesTableName(t *testing.T) {assert.Equal(t, "roles", rp.TableName())}+func TestFlowValid(t *testing.T) {+ t.Parallel()++ traceID := "trace-123"+ validFlow := Flow{+ Status: FlowStatusCreated,+ Title: "test flow",+ Model: "gpt-4",+ ModelProviderName: "openai",+ ModelProviderType: ProviderType("openai"),+ Language: "en",+ ToolCallIDTemplate: "call_{id}",+ TraceID: &traceID,+ UserID: 1,+ }++ t.Run("valid flow", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validFlow.Valid())+ })++ t.Run("missing title", func(t *testing.T) {+ t.Parallel()+ f := validFlow+ f.Title = ""+ assert.Error(t, f.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ f := validFlow+ f.Status = FlowStatus("invalid")+ assert.Error(t, f.Valid())+ })++ t.Run("invalid provider type", func(t *testing.T) {+ t.Parallel()+ f := validFlow+ f.ModelProviderType = ProviderType("invalid")+ assert.Error(t, f.Valid())+ })+}++func TestFlowTasksSubtasksValid(t *testing.T) {+ t.Parallel()++ traceID := "trace-123"+ validFlow := Flow{+ Status: FlowStatusCreated,+ Title: "test flow",+ Model: "gpt-4",+ ModelProviderName: "openai",+ ModelProviderType: ProviderType("openai"),+ Language: "en",+ ToolCallIDTemplate: "call_{id}",+ TraceID: &traceID,+ UserID: 1,+ }++ validTask := Task{+ Status: TaskStatusCreated,+ Title: "task1",+ Input: "input1",+ FlowID: 1,+ }+ validSubtask := Subtask{+ Status: SubtaskStatusCreated,+ Title: "subtask1",+ Description: "desc1",+ TaskID: 1,+ }++ t.Run("valid flow tasks subtasks", func(t *testing.T) {+ t.Parallel()+ fts := FlowTasksSubtasks{+ Tasks: []TaskSubtasks{{+ Subtasks: []Subtask{validSubtask},+ Task: validTask,+ }},+ Flow: validFlow,+ }+ assert.NoError(t, fts.Valid())+ })++ t.Run("invalid flow", func(t *testing.T) {+ t.Parallel()+ badFlow := validFlow+ badFlow.Title = ""+ fts := FlowTasksSubtasks{+ Tasks: []TaskSubtasks{{+ Subtasks: []Subtask{validSubtask},+ Task: validTask,+ }},+ Flow: badFlow,+ }+ assert.Error(t, fts.Valid())+ })++ t.Run("invalid nested subtask", func(t *testing.T) {+ t.Parallel()+ badSubtask := validSubtask+ badSubtask.Title = ""+ fts := FlowTasksSubtasks{+ Tasks: []TaskSubtasks{{+ Subtasks: []Subtask{badSubtask},+ Task: validTask,+ }},+ Flow: validFlow,+ }+ assert.Error(t, fts.Valid())+ })+}+func TestFlowTasksSubtasksTableName(t *testing.T) {t.Parallel()fts := &FlowTasksSubtasks{}assert.Equal(t, "flows", fts.TableName())}+func TestFlowContainersValid(t *testing.T) {+ t.Parallel()++ traceID := "trace-123"+ validFlow := Flow{+ Status: FlowStatusCreated,+ Title: "test flow",+ Model: "gpt-4",+ ModelProviderName: "openai",+ ModelProviderType: ProviderType("openai"),+ Language: "en",+ ToolCallIDTemplate: "call_{id}",+ TraceID: &traceID,+ UserID: 1,+ }+ validContainer := Container{+ Type: ContainerTypePrimary,+ Name: "test-container",+ Image: "alpine:latest",+ Status: ContainerStatusRunning,+ LocalID: "abc123",+ LocalDir: "/tmp/test",+ FlowID: 1,+ }++ t.Run("valid flow containers", func(t *testing.T) {+ t.Parallel()+ fc := FlowContainers{+ Containers: []Container{validContainer},+ Flow: validFlow,+ }+ assert.NoError(t, fc.Valid())+ })++ t.Run("invalid flow", func(t *testing.T) {+ t.Parallel()+ badFlow := validFlow+ badFlow.Title = ""+ fc := FlowContainers{+ Containers: []Container{validContainer},+ Flow: badFlow,+ }+ assert.Error(t, fc.Valid())+ })++ t.Run("invalid container", func(t *testing.T) {+ t.Parallel()+ badContainer := validContainer+ badContainer.Name = ""+ fc := FlowContainers{+ Containers: []Container{badContainer},+ Flow: validFlow,+ }+ assert.Error(t, fc.Valid())+ })+}+func TestFlowContainersTableName(t *testing.T) {t.Parallel()fc := &FlowContainers{}assert.Equal(t, "flows", fc.TableName())}+func TestTaskValid(t *testing.T) {+ t.Parallel()++ validTask := Task{+ Status: TaskStatusCreated,+ Title: "test task",+ Input: "test input",+ FlowID: 1,+ }++ t.Run("valid task", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validTask.Valid())+ })++ t.Run("missing title", func(t *testing.T) {+ t.Parallel()+ tk := validTask+ tk.Title = ""+ assert.Error(t, tk.Valid())+ })++ t.Run("missing input", func(t *testing.T) {+ t.Parallel()+ tk := validTask+ tk.Input = ""+ assert.Error(t, tk.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ tk := validTask+ tk.Status = TaskStatus("invalid")+ assert.Error(t, tk.Valid())+ })+}++func TestTaskSubtasksValid(t *testing.T) {+ t.Parallel()++ validTask := Task{+ Status: TaskStatusCreated,+ Title: "task1",+ Input: "input1",+ FlowID: 1,+ }+ validSubtask := Subtask{+ Status: SubtaskStatusCreated,+ Title: "subtask1",+ Description: "desc1",+ TaskID: 1,+ }++ t.Run("valid task subtasks", func(t *testing.T) {+ t.Parallel()+ ts := TaskSubtasks{+ Subtasks: []Subtask{validSubtask},+ Task: validTask,+ }+ assert.NoError(t, ts.Valid())+ })++ t.Run("invalid task", func(t *testing.T) {+ t.Parallel()+ badTask := validTask+ badTask.Title = ""+ ts := TaskSubtasks{+ Subtasks: []Subtask{validSubtask},+ Task: badTask,+ }+ assert.Error(t, ts.Valid())+ })++ t.Run("invalid subtask", func(t *testing.T) {+ t.Parallel()+ badSubtask := validSubtask+ badSubtask.Title = ""+ ts := TaskSubtasks{+ Subtasks: []Subtask{badSubtask},+ Task: validTask,+ }+ assert.Error(t, ts.Valid())+ })+}+func TestTaskSubtasksTableName(t *testing.T) {t.Parallel()ts := &TaskSubtasks{}assert.Equal(t, "tasks", ts.TableName())}++func TestSubtaskValid(t *testing.T) {+ t.Parallel()++ validSubtask := Subtask{+ Status: SubtaskStatusCreated,+ Title: "subtask1",+ Description: "description1",+ TaskID: 1,+ }++ t.Run("valid subtask", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validSubtask.Valid())+ })++ t.Run("missing title", func(t *testing.T) {+ t.Parallel()+ s := validSubtask+ s.Title = ""+ assert.Error(t, s.Valid())+ })++ t.Run("missing description", func(t *testing.T) {+ t.Parallel()+ s := validSubtask+ s.Description = ""+ assert.Error(t, s.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ s := validSubtask+ s.Status = SubtaskStatus("invalid")+ assert.Error(t, s.Valid())+ })+}++func TestContainerValid(t *testing.T) {+ t.Parallel()++ validContainer := Container{+ Type: ContainerTypePrimary,+ Name: "test-container",+ Image: "alpine:latest",+ Status: ContainerStatusRunning,+ LocalID: "abc123",+ LocalDir: "/tmp/test",+ FlowID: 1,+ }++ t.Run("valid container", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validContainer.Valid())+ })++ t.Run("missing name", func(t *testing.T) {+ t.Parallel()+ c := validContainer+ c.Name = ""+ assert.Error(t, c.Valid())+ })++ t.Run("missing image", func(t *testing.T) {+ t.Parallel()+ c := validContainer+ c.Image = ""+ assert.Error(t, c.Valid())+ })++ t.Run("invalid status", func(t *testing.T) {+ t.Parallel()+ c := validContainer+ c.Status = ContainerStatus("invalid")+ assert.Error(t, c.Valid())+ })++ t.Run("invalid type", func(t *testing.T) {+ t.Parallel()+ c := validContainer+ c.Type = ContainerType("invalid")+ assert.Error(t, c.Valid())+ })+}diff --git a/backend/pkg/server/models/prompts_test.go b/backend/pkg/server/models/prompts_test.gonew file mode 100644index 00000000..8aa55b15--- /dev/null+++ b/backend/pkg/server/models/prompts_test.go@@ -0,0 +1,109 @@+package models++import (+ "testing"++ "pentagi/pkg/templates"++ "github.com/stretchr/testify/assert"+)++func TestPromptTypeValid(t *testing.T) {+ t.Parallel()++ validTypes := []struct {+ name string+ pt PromptType+ }{+ {"primary_agent", PromptType(templates.PromptTypePrimaryAgent)},+ {"assistant", PromptType(templates.PromptTypeAssistant)},+ {"pentester", PromptType(templates.PromptTypePentester)},+ {"coder", PromptType(templates.PromptTypeCoder)},+ {"searcher", PromptType(templates.PromptTypeSearcher)},+ {"summarizer", PromptType(templates.PromptTypeSummarizer)},+ {"reporter", PromptType(templates.PromptTypeReporter)},+ {"tool_call_id_detector", PromptType(templates.PromptTypeToolCallIDDetector)},+ }++ 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 PromptType+ }{+ {"empty", PromptType("")},+ {"unknown", PromptType("unknown")},+ {"typo", PromptType("primarry_agent")},+ }++ 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 PromptType")+ })+ }+}++func TestPromptTypeString(t *testing.T) {+ t.Parallel()++ assert.Equal(t, "primary_agent", PromptType(templates.PromptTypePrimaryAgent).String())+ assert.Equal(t, "assistant", PromptType(templates.PromptTypeAssistant).String())+}++func TestPromptValid(t *testing.T) {+ t.Parallel()++ validPrompt := Prompt{+ Type: PromptType(templates.PromptTypePrimaryAgent),+ Prompt: "You are a security assistant.",+ }++ t.Run("valid prompt", func(t *testing.T) {+ t.Parallel()+ assert.NoError(t, validPrompt.Valid())+ })++ t.Run("invalid type", func(t *testing.T) {+ t.Parallel()+ p := validPrompt+ p.Type = PromptType("invalid")+ assert.Error(t, p.Valid())+ })++ t.Run("missing prompt text", func(t *testing.T) {+ t.Parallel()+ p := validPrompt+ p.Prompt = ""+ assert.Error(t, p.Valid())+ })+}++func TestPromptTableName(t *testing.T) {+ t.Parallel()+ p := &Prompt{}+ assert.Equal(t, "prompts", p.TableName())+}++func TestPatchPromptValid(t *testing.T) {+ t.Parallel()++ t.Run("valid patch", func(t *testing.T) {+ t.Parallel()+ pp := PatchPrompt{Prompt: "updated prompt text"}+ assert.NoError(t, pp.Valid())+ })++ t.Run("missing prompt", func(t *testing.T) {+ t.Parallel()+ pp := PatchPrompt{Prompt: ""}+ assert.Error(t, pp.Valid())+ })+}diff --git a/backend/pkg/server/models/users_test.go b/backend/pkg/server/models/users_test.goindex b0a14dab..5d8a8c47 100644--- a/backend/pkg/server/models/users_test.go+++ b/backend/pkg/server/models/users_test.go@@ -398,8 +398,9 @@ func TestUserPreferencesValid(t *testing.T) {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")+ err := up.Valid()+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "user_id")})}@@ -421,11 +422,25 @@ func TestNewUserPreferences(t *testing.T) {func TestAuthCallbackValid(t *testing.T) {t.Parallel()+ // JWT token with 3 dot-separated base64 segments (header.payload.signature)+ validJWT := "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.POstGetfAytaZS82wHcjoTyoqhMyxXiWdR7Nn7A29DNSl0EiXLdwJ6xC6AfgZWF1bOsS_TuYI3OG85AmiExREkrS6tDfTQ2B3WXlrr-wp5AokiRbz3_oB4OxG-W9KcEEbDRcZc0nH3L7LzYptiy1PtAylQGxHTWZXtGz4ht0bAecBgmpdgXMguEIcoqPJ1n3pIWk_dUZegpqx0Lka21H6XxUTxiy8OcaarA8zdnPUnV6AmNP3ecFawIFYdvJB_cm-GvpCSbr8G8y_Mllj8f4x9nBH8pQux89_6gUY618iYv7tuPWBFfEbLxtF2pZS6YC1aSfLQxaOoaBSTNRg"++ t.Run("valid callback", func(t *testing.T) {+ t.Parallel()+ ac := AuthCallback{+ Code: "auth-code-123",+ IdToken: validJWT,+ Scope: "openid email profile",+ State: "random-state-value",+ }+ assert.NoError(t, ac.Valid())+ })+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",+ IdToken: validJWT,Scope: "openid email",State: "state123",}@@ -436,7 +451,7 @@ func TestAuthCallbackValid(t *testing.T) {t.Parallel()ac := AuthCallback{Code: "code123",- IdToken: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.POstGetfAytaZS82wHcjoTyoqhMyxXiWdR7Nn7A29DNSl0EiXLdwJ6xC6AfgZWF1bOsS_TuYI3OG85AmiExREkrS6tDfTQ2B3WXlrr-wp5AokiRbz3_oB4OxG-W9KcEEbDRcZc0nH3L7LzYptiy1PtAylQGxHTWZXtGz4ht0bAecBgmpdgXMguEIcoqPJ1n3pIWk_dUZegpqx0Lka21H6XxUTxiy8OcaarA8zdnPUnV6AmNP3ecFawIFYdvJB_cm-GvpCSbr8G8y_Mllj8f4x9nBH8pQux89_6gUY618iYv7tuPWBFfEbLxtF2pZS6YC1aSfLQxaOoaBSTNRg",+ IdToken: validJWT,Scope: "email profile",State: "state123",}@@ -493,3 +508,51 @@ func TestUserRoleValid(t *testing.T) {assert.Error(t, ur.Valid())})}++func TestUserRolePrivilegesValid(t *testing.T) {+ t.Parallel()++ validUserForRole := User{+ Hash: "abcdef1234567890abcdef1234567890",+ Type: UserTypeLocal,+ Mail: "[email protected]",+ Status: UserStatusActive,+ RoleID: RoleUser,+ }++ t.Run("valid user role privileges", func(t *testing.T) {+ t.Parallel()+ urp := UserRolePrivileges{+ Role: RolePrivileges{+ Privileges: []Privilege{{Name: "read"}},+ Role: Role{ID: 1, Name: "admin"},+ },+ User: validUserForRole,+ }+ assert.NoError(t, urp.Valid())+ })++ t.Run("invalid role privileges", func(t *testing.T) {+ t.Parallel()+ urp := UserRolePrivileges{+ Role: RolePrivileges{+ Privileges: []Privilege{{Name: ""}},+ Role: Role{ID: 1, Name: "admin"},+ },+ User: validUserForRole,+ }+ assert.Error(t, urp.Valid())+ })++ t.Run("invalid user", func(t *testing.T) {+ t.Parallel()+ urp := UserRolePrivileges{+ Role: RolePrivileges{+ Privileges: []Privilege{{Name: "read"}},+ Role: Role{ID: 1, Name: "admin"},+ },+ User: User{Mail: ""},+ }+ assert.Error(t, urp.Valid())+ })+}