718 lines
24 KiB
Go
718 lines
24 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/kandev/kandev/internal/user/models"
|
|
)
|
|
|
|
func ptr[T any](v T) *T { return &v }
|
|
|
|
func rawPatch(v json.RawMessage) **json.RawMessage {
|
|
return ptr(ptr(v))
|
|
}
|
|
|
|
func rawClear() **json.RawMessage {
|
|
return ptr((*json.RawMessage)(nil))
|
|
}
|
|
|
|
func makeLayouts(n int) []models.SavedLayout {
|
|
layouts := make([]models.SavedLayout, n)
|
|
for i := range layouts {
|
|
layouts[i] = models.SavedLayout{
|
|
ID: fmt.Sprintf("layout-%d", i),
|
|
Name: fmt.Sprintf("Layout %d", i),
|
|
IsDefault: false,
|
|
Layout: json.RawMessage(`{}`),
|
|
CreatedAt: "2026-01-01T00:00:00Z",
|
|
}
|
|
}
|
|
return layouts
|
|
}
|
|
|
|
func TestApplyBasicSettings_ReleaseNotes(t *testing.T) {
|
|
t.Run("nil fields leave settings unchanged", func(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
ShowReleaseNotification: true,
|
|
ReleaseNotesLastSeenVersion: "1.0.0",
|
|
}
|
|
req := &UpdateUserSettingsRequest{}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ShowReleaseNotification != true {
|
|
t.Fatalf("expected ShowReleaseNotification=true, got %v", settings.ShowReleaseNotification)
|
|
}
|
|
if settings.ReleaseNotesLastSeenVersion != "1.0.0" {
|
|
t.Fatalf("expected ReleaseNotesLastSeenVersion=1.0.0, got %s", settings.ReleaseNotesLastSeenVersion)
|
|
}
|
|
})
|
|
|
|
t.Run("ShowReleaseNotification set to false", func(t *testing.T) {
|
|
settings := &models.UserSettings{ShowReleaseNotification: true}
|
|
req := &UpdateUserSettingsRequest{ShowReleaseNotification: ptr(false)}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ShowReleaseNotification != false {
|
|
t.Fatalf("expected ShowReleaseNotification=false, got %v", settings.ShowReleaseNotification)
|
|
}
|
|
})
|
|
|
|
t.Run("ShowReleaseNotification set to true", func(t *testing.T) {
|
|
settings := &models.UserSettings{ShowReleaseNotification: false}
|
|
req := &UpdateUserSettingsRequest{ShowReleaseNotification: ptr(true)}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ShowReleaseNotification != true {
|
|
t.Fatalf("expected ShowReleaseNotification=true, got %v", settings.ShowReleaseNotification)
|
|
}
|
|
})
|
|
|
|
t.Run("ReleaseNotesLastSeenVersion updated", func(t *testing.T) {
|
|
settings := &models.UserSettings{ReleaseNotesLastSeenVersion: "1.0.0"}
|
|
req := &UpdateUserSettingsRequest{ReleaseNotesLastSeenVersion: ptr("2.0.0")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ReleaseNotesLastSeenVersion != "2.0.0" {
|
|
t.Fatalf("expected ReleaseNotesLastSeenVersion=2.0.0, got %s", settings.ReleaseNotesLastSeenVersion)
|
|
}
|
|
})
|
|
|
|
t.Run("ReleaseNotesLastSeenVersion cleared with empty string", func(t *testing.T) {
|
|
settings := &models.UserSettings{ReleaseNotesLastSeenVersion: "1.0.0"}
|
|
req := &UpdateUserSettingsRequest{ReleaseNotesLastSeenVersion: ptr("")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ReleaseNotesLastSeenVersion != "" {
|
|
t.Fatalf("expected empty ReleaseNotesLastSeenVersion, got %s", settings.ReleaseNotesLastSeenVersion)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestApplyBasicSettings_TerminalFontFamily(t *testing.T) {
|
|
t.Run("nil leaves settings unchanged", func(t *testing.T) {
|
|
settings := &models.UserSettings{TerminalFontFamily: "Fira Code"}
|
|
req := &UpdateUserSettingsRequest{}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontFamily != "Fira Code" {
|
|
t.Fatalf("expected TerminalFontFamily=Fira Code, got %s", settings.TerminalFontFamily)
|
|
}
|
|
})
|
|
|
|
t.Run("sets value when provided", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{TerminalFontFamily: ptr("JetBrains Mono")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontFamily != "JetBrains Mono" {
|
|
t.Fatalf("expected TerminalFontFamily=JetBrains Mono, got %s", settings.TerminalFontFamily)
|
|
}
|
|
})
|
|
|
|
t.Run("trims whitespace", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{TerminalFontFamily: ptr(" Fira Code ")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontFamily != "Fira Code" {
|
|
t.Fatalf("expected TerminalFontFamily=Fira Code, got %q", settings.TerminalFontFamily)
|
|
}
|
|
})
|
|
|
|
t.Run("clears with empty string", func(t *testing.T) {
|
|
settings := &models.UserSettings{TerminalFontFamily: "Fira Code"}
|
|
req := &UpdateUserSettingsRequest{TerminalFontFamily: ptr("")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontFamily != "" {
|
|
t.Fatalf("expected empty TerminalFontFamily, got %s", settings.TerminalFontFamily)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestApplyChangesPanelLayout(t *testing.T) {
|
|
t.Run("nil leaves settings unchanged", func(t *testing.T) {
|
|
settings := &models.UserSettings{ChangesPanelLayout: "tree"}
|
|
req := &UpdateUserSettingsRequest{}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ChangesPanelLayout != "tree" {
|
|
t.Fatalf("expected ChangesPanelLayout=tree, got %s", settings.ChangesPanelLayout)
|
|
}
|
|
})
|
|
|
|
t.Run("sets tree when provided", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{ChangesPanelLayout: ptr("tree")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ChangesPanelLayout != "tree" {
|
|
t.Fatalf("expected ChangesPanelLayout=tree, got %s", settings.ChangesPanelLayout)
|
|
}
|
|
})
|
|
|
|
t.Run("sets flat when provided", func(t *testing.T) {
|
|
settings := &models.UserSettings{ChangesPanelLayout: "tree"}
|
|
req := &UpdateUserSettingsRequest{ChangesPanelLayout: ptr("flat")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ChangesPanelLayout != "flat" {
|
|
t.Fatalf("expected ChangesPanelLayout=flat, got %s", settings.ChangesPanelLayout)
|
|
}
|
|
})
|
|
|
|
t.Run("rejects invalid value", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{ChangesPanelLayout: ptr("grid")}
|
|
if err := applyBasicSettings(settings, req); err == nil {
|
|
t.Fatal("expected error for invalid layout, got nil")
|
|
}
|
|
})
|
|
|
|
t.Run("trims whitespace before validation", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{ChangesPanelLayout: ptr(" tree ")}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.ChangesPanelLayout != "tree" {
|
|
t.Fatalf("expected ChangesPanelLayout=tree, got %q", settings.ChangesPanelLayout)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestApplyBasicSettings_TerminalFontSize(t *testing.T) {
|
|
t.Run("nil leaves settings unchanged", func(t *testing.T) {
|
|
settings := &models.UserSettings{TerminalFontSize: 14}
|
|
req := &UpdateUserSettingsRequest{}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontSize != 14 {
|
|
t.Fatalf("expected TerminalFontSize=14, got %d", settings.TerminalFontSize)
|
|
}
|
|
})
|
|
|
|
t.Run("sets value when provided", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{TerminalFontSize: ptr(16)}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontSize != 16 {
|
|
t.Fatalf("expected TerminalFontSize=16, got %d", settings.TerminalFontSize)
|
|
}
|
|
})
|
|
|
|
t.Run("value below 8 returns error", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{TerminalFontSize: ptr(7)}
|
|
if err := applyBasicSettings(settings, req); err == nil {
|
|
t.Fatal("expected error for font size 7, got nil")
|
|
}
|
|
})
|
|
|
|
t.Run("value above 24 returns error", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{TerminalFontSize: ptr(25)}
|
|
if err := applyBasicSettings(settings, req); err == nil {
|
|
t.Fatal("expected error for font size 25, got nil")
|
|
}
|
|
})
|
|
|
|
t.Run("resets to 0 when 0 is provided", func(t *testing.T) {
|
|
settings := &models.UserSettings{TerminalFontSize: 14}
|
|
req := &UpdateUserSettingsRequest{TerminalFontSize: ptr(0)}
|
|
if err := applyBasicSettings(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.TerminalFontSize != 0 {
|
|
t.Fatalf("expected TerminalFontSize=0, got %d", settings.TerminalFontSize)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestApplySavedLayouts(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
req *UpdateUserSettingsRequest
|
|
wantErr string
|
|
wantCount int
|
|
wantApplied bool
|
|
}{
|
|
{
|
|
name: "nil request is a no-op",
|
|
req: &UpdateUserSettingsRequest{SavedLayouts: nil},
|
|
wantApplied: false,
|
|
},
|
|
{
|
|
name: "empty slice is accepted",
|
|
req: &UpdateUserSettingsRequest{SavedLayouts: ptr([]models.SavedLayout{})},
|
|
wantCount: 0,
|
|
wantApplied: true,
|
|
},
|
|
{
|
|
name: "valid single layout is applied",
|
|
req: &UpdateUserSettingsRequest{
|
|
SavedLayouts: ptr(makeLayouts(1)),
|
|
},
|
|
wantCount: 1,
|
|
wantApplied: true,
|
|
},
|
|
{
|
|
name: "exactly max layouts is accepted",
|
|
req: &UpdateUserSettingsRequest{
|
|
SavedLayouts: ptr(makeLayouts(maxSavedLayouts)),
|
|
},
|
|
wantCount: maxSavedLayouts,
|
|
wantApplied: true,
|
|
},
|
|
{
|
|
name: "exceeding max layouts returns error",
|
|
req: &UpdateUserSettingsRequest{
|
|
SavedLayouts: ptr(makeLayouts(maxSavedLayouts + 1)),
|
|
},
|
|
wantErr: fmt.Sprintf("saved_layouts: max %d layouts allowed", maxSavedLayouts),
|
|
},
|
|
{
|
|
name: "empty name returns error",
|
|
req: &UpdateUserSettingsRequest{
|
|
SavedLayouts: ptr([]models.SavedLayout{
|
|
{ID: "l1", Name: "", Layout: json.RawMessage(`{}`)},
|
|
}),
|
|
},
|
|
wantErr: "saved_layouts: layout name must not be empty",
|
|
},
|
|
{
|
|
name: "whitespace-only name returns error",
|
|
req: &UpdateUserSettingsRequest{
|
|
SavedLayouts: ptr([]models.SavedLayout{
|
|
{ID: "l1", Name: " ", Layout: json.RawMessage(`{}`)},
|
|
}),
|
|
},
|
|
wantErr: "saved_layouts: layout name must not be empty",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
SavedLayouts: makeLayouts(2), // pre-existing layouts
|
|
}
|
|
err := applySavedLayouts(settings, tt.req)
|
|
|
|
if tt.wantErr != "" {
|
|
if err == nil {
|
|
t.Fatalf("expected error %q, got nil", tt.wantErr)
|
|
}
|
|
if !strings.Contains(err.Error(), tt.wantErr) {
|
|
t.Fatalf("expected error containing %q, got %q", tt.wantErr, err.Error())
|
|
}
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if !tt.wantApplied {
|
|
// Nil request should leave settings unchanged
|
|
if len(settings.SavedLayouts) != 2 {
|
|
t.Fatalf("expected settings unchanged (2 layouts), got %d", len(settings.SavedLayouts))
|
|
}
|
|
return
|
|
}
|
|
|
|
if len(settings.SavedLayouts) != tt.wantCount {
|
|
t.Fatalf("expected %d layouts, got %d", tt.wantCount, len(settings.SavedLayouts))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func makeSidebarViews(n int) []models.SidebarView {
|
|
views := make([]models.SidebarView, n)
|
|
for i := range views {
|
|
views[i] = models.SidebarView{
|
|
ID: fmt.Sprintf("view-%d", i),
|
|
Name: fmt.Sprintf("View %d", i),
|
|
Filters: []models.SidebarViewClause{},
|
|
Sort: models.SidebarViewSort{Key: "state", Direction: "asc"},
|
|
Group: "repository",
|
|
CollapsedGroups: []string{},
|
|
}
|
|
}
|
|
return views
|
|
}
|
|
|
|
func TestApplySidebarViews(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
req *UpdateUserSettingsRequest
|
|
wantErr string
|
|
wantCount int
|
|
wantApplied bool
|
|
}{
|
|
{
|
|
name: "nil request is a no-op",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: nil},
|
|
wantApplied: false,
|
|
},
|
|
{
|
|
name: "empty slice is accepted",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr([]models.SidebarView{})},
|
|
wantCount: 0,
|
|
wantApplied: true,
|
|
},
|
|
{
|
|
name: "valid single view is applied",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr(makeSidebarViews(1))},
|
|
wantCount: 1,
|
|
wantApplied: true,
|
|
},
|
|
{
|
|
name: "exactly max views is accepted",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr(makeSidebarViews(maxSidebarViews))},
|
|
wantCount: maxSidebarViews,
|
|
wantApplied: true,
|
|
},
|
|
{
|
|
name: "exceeding max views returns error",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr(makeSidebarViews(maxSidebarViews + 1))},
|
|
wantErr: fmt.Sprintf("sidebar_views: max %d views allowed", maxSidebarViews),
|
|
},
|
|
{
|
|
name: "empty id returns error",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr([]models.SidebarView{
|
|
{ID: "", Name: "X"},
|
|
})},
|
|
wantErr: "sidebar_views: view id must not be empty",
|
|
},
|
|
{
|
|
name: "empty name returns error",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr([]models.SidebarView{
|
|
{ID: "v1", Name: ""},
|
|
})},
|
|
wantErr: "sidebar_views: view name must not be empty",
|
|
},
|
|
{
|
|
name: "duplicate ids return error",
|
|
req: &UpdateUserSettingsRequest{SidebarViews: ptr([]models.SidebarView{
|
|
{ID: "v1", Name: "A"},
|
|
{ID: "v1", Name: "B"},
|
|
})},
|
|
wantErr: `sidebar_views: duplicate view id "v1"`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
settings := &models.UserSettings{SidebarViews: makeSidebarViews(2)}
|
|
err := applySidebarViews(settings, tt.req)
|
|
|
|
if tt.wantErr != "" {
|
|
if err == nil {
|
|
t.Fatalf("expected error %q, got nil", tt.wantErr)
|
|
}
|
|
if !strings.Contains(err.Error(), tt.wantErr) {
|
|
t.Fatalf("expected error containing %q, got %q", tt.wantErr, err.Error())
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !tt.wantApplied {
|
|
if len(settings.SidebarViews) != 2 {
|
|
t.Fatalf("expected settings unchanged (2 views), got %d", len(settings.SidebarViews))
|
|
}
|
|
return
|
|
}
|
|
if len(settings.SidebarViews) != tt.wantCount {
|
|
t.Fatalf("expected %d views, got %d", tt.wantCount, len(settings.SidebarViews))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestApplySidebarViewState(t *testing.T) {
|
|
t.Run("nil fields leave active view and draft unchanged", func(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
SidebarActiveViewID: "view-existing",
|
|
SidebarDraft: &models.SidebarViewDraft{
|
|
BaseViewID: "view-existing",
|
|
Filters: []models.SidebarViewClause{},
|
|
Sort: models.SidebarViewSort{Key: "state", Direction: "asc"},
|
|
Group: "state",
|
|
},
|
|
}
|
|
if err := applySidebarViewState(settings, &UpdateUserSettingsRequest{}); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.SidebarActiveViewID != "view-existing" {
|
|
t.Fatalf("expected active view unchanged, got %q", settings.SidebarActiveViewID)
|
|
}
|
|
if settings.SidebarDraft == nil || settings.SidebarDraft.BaseViewID != "view-existing" {
|
|
t.Fatalf("expected draft unchanged, got %+v", settings.SidebarDraft)
|
|
}
|
|
})
|
|
|
|
t.Run("applies active view and draft", func(t *testing.T) {
|
|
draft := &models.SidebarViewDraft{
|
|
BaseViewID: "view-1",
|
|
Filters: []models.SidebarViewClause{{
|
|
ID: "clause-1",
|
|
Dimension: "titleMatch",
|
|
Op: "matches",
|
|
Value: json.RawMessage(`"bug"`),
|
|
}},
|
|
Sort: models.SidebarViewSort{Key: "updatedAt", Direction: "desc"},
|
|
Group: "workflow",
|
|
}
|
|
settings := &models.UserSettings{SidebarViews: []models.SidebarView{{ID: "view-1", Name: "View 1"}}}
|
|
req := &UpdateUserSettingsRequest{
|
|
SidebarActiveViewID: ptr("view-1"),
|
|
SidebarDraft: &draft,
|
|
}
|
|
if err := applySidebarViewState(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.SidebarActiveViewID != "view-1" {
|
|
t.Fatalf("expected active view view-1, got %q", settings.SidebarActiveViewID)
|
|
}
|
|
if settings.SidebarDraft == nil || settings.SidebarDraft.Group != "workflow" {
|
|
t.Fatalf("expected draft to be applied, got %+v", settings.SidebarDraft)
|
|
}
|
|
})
|
|
|
|
t.Run("clears draft when null is provided", func(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
SidebarDraft: &models.SidebarViewDraft{BaseViewID: "view-1"},
|
|
}
|
|
req := &UpdateUserSettingsRequest{SidebarDraft: ptr((*models.SidebarViewDraft)(nil))}
|
|
if err := applySidebarViewState(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.SidebarDraft != nil {
|
|
t.Fatalf("expected draft cleared, got %+v", settings.SidebarDraft)
|
|
}
|
|
})
|
|
|
|
t.Run("rejects whitespace-only active view id", func(t *testing.T) {
|
|
req := &UpdateUserSettingsRequest{SidebarActiveViewID: ptr(" ")}
|
|
if err := applySidebarViewState(&models.UserSettings{}, req); err == nil {
|
|
t.Fatal("expected validation error, got nil")
|
|
}
|
|
})
|
|
|
|
t.Run("rejects active view id missing from saved views", func(t *testing.T) {
|
|
settings := &models.UserSettings{SidebarViews: []models.SidebarView{{ID: "view-1", Name: "View 1"}}}
|
|
req := &UpdateUserSettingsRequest{SidebarActiveViewID: ptr("missing")}
|
|
if err := applySidebarViewState(settings, req); err == nil {
|
|
t.Fatal("expected validation error, got nil")
|
|
}
|
|
if settings.SidebarActiveViewID != "" {
|
|
t.Fatalf("expected active view unchanged, got %q", settings.SidebarActiveViewID)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestApplyUserPreferenceBlobs(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
TaskCreateLastUsed: models.TaskCreateLastUsed{
|
|
RepositoryID: "repo-1",
|
|
Branch: "main",
|
|
AgentProfileID: "agent-1",
|
|
ExecutorProfileID: "exec-1",
|
|
},
|
|
}
|
|
patch := models.TaskCreateLastUsed{Branch: "feature"}
|
|
|
|
if err := applyUserPreferenceBlobs(settings, &UpdateUserSettingsRequest{
|
|
TaskCreateLastUsed: &patch,
|
|
GitHubSavedPresets: rawPatch(json.RawMessage(`[{"id":"p1"}]`)),
|
|
}); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if settings.TaskCreateLastUsed.RepositoryID != "repo-1" {
|
|
t.Fatalf("expected repository id to be preserved, got %q", settings.TaskCreateLastUsed.RepositoryID)
|
|
}
|
|
if settings.TaskCreateLastUsed.Branch != "feature" {
|
|
t.Fatalf("expected branch to update, got %q", settings.TaskCreateLastUsed.Branch)
|
|
}
|
|
if string(settings.GitHubSavedPresets) != `[{"id":"p1"}]` {
|
|
t.Fatalf("expected GitHub presets to apply, got %s", string(settings.GitHubSavedPresets))
|
|
}
|
|
}
|
|
|
|
func TestApplyUserPreferenceBlobsValidation(t *testing.T) {
|
|
t.Run("accepts arrays objects and null", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{
|
|
JiraSavedViews: rawPatch(json.RawMessage(`[]`)),
|
|
GitHubDefaultQueryPresets: rawPatch(json.RawMessage(`{"pr":[],"issue":[]}`)),
|
|
GitLabSavedPresets: rawClear(),
|
|
}
|
|
if err := applyUserPreferenceBlobs(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("rejects scalar blobs", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
req := &UpdateUserSettingsRequest{GitHubSavedPresets: rawPatch(json.RawMessage(`"bad"`))}
|
|
err := applyUserPreferenceBlobs(settings, req)
|
|
if err == nil || !strings.Contains(err.Error(), "github_saved_presets") {
|
|
t.Fatalf("expected github_saved_presets validation error, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("rejects oversized blobs", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
raw := json.RawMessage(`["` + strings.Repeat("x", maxUserPreferenceBlobBytes) + `"]`)
|
|
req := &UpdateUserSettingsRequest{JiraSavedViews: rawPatch(raw)}
|
|
err := applyUserPreferenceBlobs(settings, req)
|
|
if err == nil || !strings.Contains(err.Error(), "max") {
|
|
t.Fatalf("expected size validation error, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("explicit null clears blob", func(t *testing.T) {
|
|
settings := &models.UserSettings{JiraSavedViews: json.RawMessage(`[{"id":"view"}]`)}
|
|
req := &UpdateUserSettingsRequest{JiraSavedViews: rawClear()}
|
|
if err := applyUserPreferenceBlobs(settings, req); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.JiraSavedViews != nil {
|
|
t.Fatalf("expected explicit null to clear blob, got %s", string(settings.JiraSavedViews))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestApplyVoiceMode(t *testing.T) {
|
|
t.Run("nil value leaves settings unchanged", func(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
VoiceMode: models.VoiceModeSettings{Engine: "webSpeech", Language: "en-US"},
|
|
}
|
|
if err := applyVoiceMode(settings, nil); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.VoiceMode.Engine != "webSpeech" || settings.VoiceMode.Language != "en-US" {
|
|
t.Fatalf("expected unchanged, got %+v", settings.VoiceMode)
|
|
}
|
|
})
|
|
|
|
t.Run("happy path: applies a full update", func(t *testing.T) {
|
|
settings := &models.UserSettings{}
|
|
err := applyVoiceMode(settings, &models.VoiceModeSettings{
|
|
Enabled: true,
|
|
Engine: "whisperWeb",
|
|
Language: "pt-PT",
|
|
Mode: "hold",
|
|
AutoSend: true,
|
|
WhisperWebModel: "small",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
want := models.VoiceModeSettings{
|
|
Enabled: true,
|
|
Engine: "whisperWeb",
|
|
Language: "pt-PT",
|
|
Mode: "hold",
|
|
AutoSend: true,
|
|
WhisperWebModel: "small",
|
|
}
|
|
if settings.VoiceMode != want {
|
|
t.Fatalf("expected %+v, got %+v", want, settings.VoiceMode)
|
|
}
|
|
})
|
|
|
|
t.Run("enabled=false is honored (user disabled the feature)", func(t *testing.T) {
|
|
settings := &models.UserSettings{VoiceMode: models.VoiceModeSettings{Enabled: true}}
|
|
if err := applyVoiceMode(settings, &models.VoiceModeSettings{Enabled: false}); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.VoiceMode.Enabled {
|
|
t.Fatalf("expected Enabled=false after disable, got true")
|
|
}
|
|
})
|
|
|
|
t.Run("invalid engine is rejected", func(t *testing.T) {
|
|
err := applyVoiceMode(&models.UserSettings{}, &models.VoiceModeSettings{Engine: "bogus"})
|
|
if err == nil || !strings.Contains(err.Error(), "voice_mode.engine") {
|
|
t.Fatalf("expected engine validation error, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid mode is rejected", func(t *testing.T) {
|
|
err := applyVoiceMode(&models.UserSettings{}, &models.VoiceModeSettings{Mode: "tap"})
|
|
if err == nil || !strings.Contains(err.Error(), "voice_mode.mode") {
|
|
t.Fatalf("expected mode validation error, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid whisper_web_model is rejected", func(t *testing.T) {
|
|
err := applyVoiceMode(&models.UserSettings{}, &models.VoiceModeSettings{WhisperWebModel: "huge"})
|
|
if err == nil || !strings.Contains(err.Error(), "voice_mode.whisper_web_model") {
|
|
t.Fatalf("expected model validation error, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("partial update preserves string fields but zeroes booleans", func(t *testing.T) {
|
|
settings := &models.UserSettings{
|
|
VoiceMode: models.VoiceModeSettings{
|
|
Enabled: true,
|
|
Engine: "whisperServer",
|
|
Language: "en-GB",
|
|
Mode: "toggle",
|
|
AutoSend: true,
|
|
WhisperWebModel: "tiny",
|
|
},
|
|
}
|
|
// Empty strings on the new payload mean "no change" for the string fields,
|
|
// but bools have no "unset" sentinel — every PATCH carries them. The settings
|
|
// UI always sends the full VoiceMode object so partial updates here would
|
|
// only happen in test or hand-crafted requests; the assertions below lock in
|
|
// that explicit behavior so it doesn't drift silently.
|
|
err := applyVoiceMode(settings, &models.VoiceModeSettings{Engine: "webSpeech"})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if settings.VoiceMode.Engine != "webSpeech" {
|
|
t.Fatalf("expected engine=webSpeech, got %q", settings.VoiceMode.Engine)
|
|
}
|
|
if settings.VoiceMode.Language != "en-GB" {
|
|
t.Fatalf("expected language preserved, got %q", settings.VoiceMode.Language)
|
|
}
|
|
if settings.VoiceMode.Mode != "toggle" {
|
|
t.Fatalf("expected mode preserved, got %q", settings.VoiceMode.Mode)
|
|
}
|
|
if settings.VoiceMode.WhisperWebModel != "tiny" {
|
|
t.Fatalf("expected whisper model preserved, got %q", settings.VoiceMode.WhisperWebModel)
|
|
}
|
|
if settings.VoiceMode.Enabled {
|
|
t.Fatalf("expected Enabled zeroed on partial update, got true")
|
|
}
|
|
if settings.VoiceMode.AutoSend {
|
|
t.Fatalf("expected AutoSend zeroed on partial update, got true")
|
|
}
|
|
})
|
|
}
|