Skip to content

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

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