Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
chore: add service unit tests
Kyle Mendell99e8a68d87dc
diff --git a/backend/internal/services/auth_service_test.go b/backend/internal/services/auth_service_test.gonew file mode 100644index 000000000..4b8f3e0cb--- /dev/null+++ b/backend/internal/services/auth_service_test.go@@ -0,0 +1,196 @@+package services++import (+ "context"+ "errors"+ "testing"+ "time"++ "github.com/golang-jwt/jwt/v5"+ "github.com/ofkm/arcane-backend/internal/config"+ "github.com/ofkm/arcane-backend/internal/dto"+ "github.com/ofkm/arcane-backend/internal/models"+)++func newTestAuthService(secret string) *AuthService {+ if secret == "" {+ secret = "test-secret-32-bytes-minimum-length!"+ }+ return &AuthService{+ jwtSecret: []byte(secret),+ refreshExpiry: 24 * time.Hour,+ config: &config.Config{},+ }+}++func makeAccessToken(t *testing.T, secret []byte, subject string, id string, username string, roles []string, email, displayName string, exp time.Time) string {+ t.Helper()+ claims := UserClaims{+ RegisteredClaims: jwt.RegisteredClaims{+ ID: id,+ Subject: subject,+ IssuedAt: jwt.NewNumericDate(time.Now()),+ ExpiresAt: jwt.NewNumericDate(exp),+ },+ UserID: id,+ Username: username,+ Roles: roles,+ Email: email,+ DisplayName: displayName,+ }+ tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)+ signed, err := tok.SignedString(secret)+ if err != nil {+ t.Fatalf("sign: %v", err)+ }+ return signed+}++func TestVerifyToken_ValidClaims(t *testing.T) {+ s := newTestAuthService("")+ exp := time.Now().Add(5 * time.Minute)+ token := makeAccessToken(t, s.jwtSecret, "access", "u123", "alice", []string{"user", "admin"}, "[email protected]", "Alice", exp)++ user, err := s.VerifyToken(context.Background(), token)+ if err != nil {+ t.Fatalf("VerifyToken error: %v", err)+ }+ if user.ID != "u123" {+ t.Errorf("id %q", user.ID)+ }+ if user.Username != "alice" {+ t.Errorf("username %q", user.Username)+ }+ if len(user.Roles) != 2 || user.Roles[0] != "user" || user.Roles[1] != "admin" {+ t.Errorf("roles %v", user.Roles)+ }+ if user.Email == nil || *user.Email != "[email protected]" {+ t.Errorf("email %v", user.Email)+ }+ if user.DisplayName == nil || *user.DisplayName != "Alice" {+ t.Errorf("displayName %v", user.DisplayName)+ }+}++func TestVerifyToken_Expired(t *testing.T) {+ s := newTestAuthService("")+ exp := time.Now().Add(-1 * time.Minute)+ token := makeAccessToken(t, s.jwtSecret, "access", "u1", "bob", []string{"user"}, "", "", exp)++ _, err := s.VerifyToken(context.Background(), token)+ if !errors.Is(err, ErrExpiredToken) {+ t.Errorf("want ErrExpiredToken, got %v", err)+ }+}++func TestVerifyToken_InvalidSubject(t *testing.T) {+ s := newTestAuthService("")+ exp := time.Now().Add(5 * time.Minute)+ token := makeAccessToken(t, s.jwtSecret, "refresh", "u1", "bob", []string{"user"}, "", "", exp)++ _, err := s.VerifyToken(context.Background(), token)+ if err == nil || err.Error() != "not an access token" {+ t.Errorf("want 'not an access token', got %v", err)+ }+}++func TestVerifyToken_InvalidSignature(t *testing.T) {+ s := newTestAuthService("")+ exp := time.Now().Add(5 * time.Minute)+ otherSecret := []byte("another-secret-32-bytes-long!!")+ token := makeAccessToken(t, otherSecret, "access", "u1", "bob", []string{"user"}, "", "", exp)++ _, err := s.VerifyToken(context.Background(), token)+ if !errors.Is(err, ErrInvalidToken) {+ t.Errorf("want ErrInvalidToken, got %v", err)+ }+}++func TestVerifyToken_MissingUserID(t *testing.T) {+ s := newTestAuthService("")+ exp := time.Now().Add(5 * time.Minute)+ token := makeAccessToken(t, s.jwtSecret, "access", "", "bob", []string{"user"}, "", "", exp)++ _, err := s.VerifyToken(context.Background(), token)+ if err == nil || err.Error() != "missing user ID in token" {+ t.Errorf("want 'missing user ID in token', got %v", err)+ }+}++func TestGenerateUsernameFromEmail(t *testing.T) {+ u := generateUsernameFromEmail("[email protected]", "sub-abcdef01")+ if u != "john.doe" {+ t.Errorf("username %q", u)+ }+ u2 := generateUsernameFromEmail("", "1234567890abcdef")+ if u2 != "user_90abcdef" {+ t.Errorf("fallback username %q", u2)+ }+ u3 := generateUsernameFromEmail("", "short")+ if u3 != "user_short" {+ t.Errorf("short subject username %q", u3)+ }+}++func TestPersistOidcTokens_SetsFields(t *testing.T) {+ s := newTestAuthService("")+ user := &models.User{}+ start := time.Now()+ resp := &dto.OidcTokenResponse{+ AccessToken: "at-123",+ RefreshToken: "rt-456",+ ExpiresIn: 7,+ IDToken: "",+ }+ s.persistOidcTokens(user, resp)++ if user.OidcAccessToken == nil || *user.OidcAccessToken != "at-123" {+ t.Errorf("access token %v", user.OidcAccessToken)+ }+ if user.OidcRefreshToken == nil || *user.OidcRefreshToken != "rt-456" {+ t.Errorf("refresh token %v", user.OidcRefreshToken)+ }+ if user.OidcAccessTokenExpiresAt == nil {+ t.Errorf("expiresAt nil")+ }+ // Check approx expiry within [start+7s, start+12s] to allow CI slop+ min := start.Add(7 * time.Second)+ max := start.Add(12 * time.Second)+ if user.OidcAccessTokenExpiresAt.Before(min) || user.OidcAccessTokenExpiresAt.After(max) {+ t.Errorf("expiresAt %v not in [%v,%v]", user.OidcAccessTokenExpiresAt, min, max)+ }+}++func TestGetOidcConfigurationStatus(t *testing.T) {+ // Disabled+ s := newTestAuthService("")+ s.config = &config.Config{}+ status, err := s.GetOidcConfigurationStatus(context.Background())+ if err != nil {+ t.Fatalf("GetOidcConfigurationStatus error: %v", err)+ }+ if status.EnvForced || status.EnvConfigured {+ t.Errorf("expected disabled, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)+ }++ // Enabled but missing fields+ s.config.OidcEnabled = true+ status, err = s.GetOidcConfigurationStatus(context.Background())+ if err != nil {+ t.Fatalf("GetOidcConfigurationStatus error: %v", err)+ }+ if !status.EnvForced || status.EnvConfigured {+ t.Errorf("expected enabled but not configured, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)+ }++ // Enabled and configured+ s.config.OidcClientID = "client-id"+ s.config.OidcIssuerURL = "https://example.com"+ status, err = s.GetOidcConfigurationStatus(context.Background())+ if err != nil {+ t.Fatalf("GetOidcConfigurationStatus error: %v", err)+ }+ if !status.EnvForced || !status.EnvConfigured {+ t.Errorf("expected enabled and configured, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)+ }+}diff --git a/backend/internal/services/oidc_service_test.go b/backend/internal/services/oidc_service_test.gonew file mode 100644index 000000000..28df855e7--- /dev/null+++ b/backend/internal/services/oidc_service_test.go@@ -0,0 +1,342 @@+package services++import (+ "context"+ "encoding/base64"+ "encoding/json"+ "io"+ "net/http"+ "net/http/httptest"+ "net/url"+ "strings"+ "testing"+ "time"++ "github.com/ofkm/arcane-backend/internal/config"+ "github.com/ofkm/arcane-backend/internal/dto"+ "github.com/ofkm/arcane-backend/internal/models"+)++func newTestOidcService() *OidcService {+ return &OidcService{+ authService: nil, // not used in these tests+ config: &config.Config{}, // redirect URI may be empty; that's fine for these unit tests+ httpClient: &http.Client{}, // overridden per-test with server.Client()+ }+}++func TestDiscoverOidcEndpoints_Success(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json; charset=utf-8")+ json.NewEncoder(w).Encode(dto.OidcDiscoveryDocument{+ AuthorizationEndpoint: "https://example/authorize",+ TokenEndpoint: "https://example/token",+ UserinfoEndpoint: "https://example/userinfo",+ JwksURI: "https://example/jwks",+ })+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ doc, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)+ if err != nil {+ t.Fatalf("discoverOidcEndpoints: %v", err)+ }+ if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.UserinfoEndpoint == "" || doc.JwksURI == "" {+ t.Fatalf("unexpected discovery doc: %+v", doc)+ }+}++func TestDiscoverOidcEndpoints_NonJSON(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "text/plain")+ w.WriteHeader(http.StatusOK)+ w.Write([]byte("not json"))+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ _, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)+ if err == nil || !strings.Contains(err.Error(), "non-JSON") {+ t.Fatalf("expected non-JSON error, got %v", err)+ }+}++func TestDiscoverOidcEndpoints_HTTPError(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {+ http.Error(w, "boom", http.StatusBadGateway)+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ _, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)+ if err == nil || !strings.Contains(err.Error(), "returned 502") {+ t.Fatalf("expected status error, got %v", err)+ }+}++func TestDiscoverOidcEndpoints_MissingEndpoints(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ // Missing token endpoint+ w.Write([]byte(`{"authorization_endpoint":"https://example/auth"}`))+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ _, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)+ if err == nil || !strings.Contains(err.Error(), "missing required endpoints") {+ t.Fatalf("expected missing endpoints error, got %v", err)+ }+}++func TestExchangeCodeForTokens_Success(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {+ if err := r.ParseForm(); err != nil {+ http.Error(w, "bad form", http.StatusBadRequest)+ return+ }+ if r.Form.Get("grant_type") != "authorization_code" || r.Form.Get("code") != "abc123" {+ http.Error(w, "invalid grant", http.StatusBadRequest)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ json.NewEncoder(w).Encode(dto.OidcTokenResponse{+ AccessToken: "access-1",+ RefreshToken: "refresh-1",+ ExpiresIn: 3600,+ IDToken: "id-1",+ TokenType: "Bearer",+ })+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ cfg := &models.OidcConfig{+ TokenEndpoint: srv.URL + "/token",+ ClientID: "client",+ ClientSecret: "secret",+ }+ tok, err := svc.exchangeCodeForTokens(context.Background(), cfg, "abc123", "verifier")+ if err != nil {+ t.Fatalf("exchangeCodeForTokens: %v", err)+ }+ if tok.AccessToken != "access-1" || tok.RefreshToken != "refresh-1" || tok.TokenType != "Bearer" {+ t.Fatalf("unexpected token response: %+v", tok)+ }+}++func TestExchangeCodeForTokens_Non200(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {+ http.Error(w, "bad", http.StatusBadRequest)+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ cfg := &models.OidcConfig{TokenEndpoint: srv.URL + "/token"}+ _, err := svc.exchangeCodeForTokens(context.Background(), cfg, "x", "y")+ if err == nil || !strings.Contains(err.Error(), "returned 400") {+ t.Fatalf("expected 400 error, got %v", err)+ }+}++func TestGetUserInfo_Success(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/userinfo", func(w http.ResponseWriter, r *http.Request) {+ if got := r.Header.Get("Authorization"); !strings.HasPrefix(got, "Bearer ") {+ http.Error(w, "no bearer", http.StatusUnauthorized)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ w.Write([]byte(`{+ "sub": "user-1",+ "name": "Alice",+ "email": "[email protected]",+ "preferred_username": "alice",+ "given_name": "Alice",+ "family_name": "A",+ "admin": true,+ "roles": ["admin","user"],+ "groups": ["devs","ops"]+ }`))+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ cfg := &models.OidcConfig{UserinfoEndpoint: srv.URL + "/userinfo"}+ ui, err := svc.getUserInfo(context.Background(), cfg, "token-123")+ if err != nil {+ t.Fatalf("getUserInfo: %v", err)+ }+ if ui.Subject != "user-1" || ui.Email != "[email protected]" || !ui.Admin {+ t.Fatalf("unexpected user info: %+v", ui)+ }+ if len(ui.Roles) != 2 || ui.Roles[0] != "admin" {+ t.Fatalf("roles not parsed: %+v", ui.Roles)+ }+ if len(ui.Groups) != 2 || ui.Groups[1] != "ops" {+ t.Fatalf("groups not parsed: %+v", ui.Groups)+ }+}++func TestGetUserInfo_MissingSub(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/userinfo", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ w.Write([]byte(`{"email":"[email protected]"}`)) // no sub+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ cfg := &models.OidcConfig{UserinfoEndpoint: srv.URL + "/userinfo"}+ _, err := svc.getUserInfo(context.Background(), cfg, "t")+ if err == nil || !strings.Contains(err.Error(), "missing required 'sub'") {+ t.Fatalf("expected missing sub error, got %v", err)+ }+}++func TestGetUserInfo_Non200(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/userinfo", func(w http.ResponseWriter, r *http.Request) {+ http.Error(w, "nope", http.StatusUnauthorized)+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()++ cfg := &models.OidcConfig{UserinfoEndpoint: srv.URL + "/userinfo"}+ _, err := svc.getUserInfo(context.Background(), cfg, "t")+ if err == nil || !strings.Contains(err.Error(), "returned 401") {+ t.Fatalf("expected 401 error, got %v", err)+ }+}++func TestDecodeState_Success(t *testing.T) {+ now := time.Now().Round(time.Second)+ state := OidcState{+ State: "s123",+ CodeVerifier: "v456",+ RedirectTo: "/home",+ CreatedAt: now,+ }+ raw, _ := json.Marshal(state)+ enc := base64.URLEncoding.EncodeToString(raw)++ svc := newTestOidcService()+ got, err := svc.decodeState(enc)+ if err != nil {+ t.Fatalf("decodeState: %v", err)+ }+ if got.State != "s123" || got.CodeVerifier != "v456" || got.RedirectTo != "/home" || got.CreatedAt.IsZero() {+ t.Fatalf("unexpected decoded state: %+v", got)+ }+}++func TestDecodeState_InvalidBase64(t *testing.T) {+ svc := newTestOidcService()+ _, err := svc.decodeState("###not-base64###")+ if err == nil {+ t.Fatalf("expected base64 error")+ }+}++func TestHandleCallback_StateMismatch(t *testing.T) {+ stored := OidcState{+ State: "good",+ CodeVerifier: "cv",+ RedirectTo: "/",+ CreatedAt: time.Now(),+ }+ raw, _ := json.Marshal(stored)+ enc := base64.URLEncoding.EncodeToString(raw)++ svc := newTestOidcService()+ _, _, err := svc.HandleCallback(context.Background(), "code", "bad", enc)+ if err == nil || !strings.Contains(err.Error(), "invalid state parameter") {+ t.Fatalf("expected invalid state error, got %v", err)+ }+}++func TestHandleCallback_ExpiredState(t *testing.T) {+ stored := OidcState{+ State: "s",+ CodeVerifier: "cv",+ RedirectTo: "/",+ CreatedAt: time.Now().Add(-11 * time.Minute),+ }+ raw, _ := json.Marshal(stored)+ enc := base64.URLEncoding.EncodeToString(raw)++ svc := newTestOidcService()+ _, _, err := svc.HandleCallback(context.Background(), "code", "s", enc)+ if err == nil || !strings.Contains(err.Error(), "state has expired") {+ t.Fatalf("expected expired state error, got %v", err)+ }+}++// Helper to ensure form bodies are parsed as expected (optional smoke test)+func TestTokenEndpoint_FormShape(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {+ if ct := r.Header.Get("Content-Type"); !strings.HasPrefix(ct, "application/x-www-form-urlencoded") {+ http.Error(w, "bad content-type", http.StatusUnsupportedMediaType)+ return+ }+ body, _ := url.ParseQuery(readAll(t, r))+ if body.Get("grant_type") == "" {+ http.Error(w, "missing grant_type", http.StatusBadRequest)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ w.Write([]byte(`{"access_token":"a","token_type":"Bearer","expires_in":1,"refresh_token":"r"}`))+ })+ srv := httptest.NewServer(mux)+ defer srv.Close()++ svc := newTestOidcService()+ svc.httpClient = srv.Client()+ cfg := &models.OidcConfig{TokenEndpoint: srv.URL + "/token"}++ if _, err := svc.exchangeCodeForTokens(context.Background(), cfg, "c", "v"); err != nil {+ t.Fatalf("exchangeCodeForTokens: %v", err)+ }+}+func readAll(t *testing.T, r *http.Request) string {+ t.Helper()+ defer r.Body.Close()+ b := new(strings.Builder)+ _, _ = io.Copy(b, r.Body)+ return b.String()+}diff --git a/backend/internal/services/settings_service_test.go b/backend/internal/services/settings_service_test.gonew file mode 100644index 000000000..998f0583e--- /dev/null+++ b/backend/internal/services/settings_service_test.go@@ -0,0 +1,261 @@+package services++import (+ "context"+ "encoding/json"+ "testing"++ glsqlite "github.com/glebarez/sqlite"+ "github.com/ofkm/arcane-backend/internal/config"+ "github.com/ofkm/arcane-backend/internal/database"+ "github.com/ofkm/arcane-backend/internal/dto"+ "github.com/ofkm/arcane-backend/internal/models"+ "gorm.io/gorm"+)++func setupSettingsTestDB(t *testing.T) *database.DB {+ t.Helper()+ db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})+ if err != nil {+ t.Fatalf("open db: %v", err)+ }+ if err := db.AutoMigrate(&models.SettingVariable{}); err != nil {+ t.Fatalf("migrate: %v", err)+ }+ return &database.DB{DB: db}+}++func TestSettingsService_EnsureDefaultSettings_Idempotent(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ svc := NewSettingsService(db, &config.Config{})++ if err := svc.EnsureDefaultSettings(ctx); err != nil {+ t.Fatalf("EnsureDefaultSettings: %v", err)+ }++ var count1 int64+ if err := svc.db.WithContext(ctx).Model(&models.SettingVariable{}).Count(&count1).Error; err != nil {+ t.Fatalf("count: %v", err)+ }+ if count1 == 0 {+ t.Fatalf("expected defaults inserted")+ }++ // Run again (should not duplicate)+ if err := svc.EnsureDefaultSettings(ctx); err != nil {+ t.Fatalf("EnsureDefaultSettings 2nd run: %v", err)+ }++ var count2 int64+ if err := svc.db.WithContext(ctx).Model(&models.SettingVariable{}).Count(&count2).Error; err != nil {+ t.Fatalf("count2: %v", err)+ }+ if count2 != count1 {+ t.Fatalf("defaults not idempotent: first=%d second=%d", count1, count2)+ }++ // Spot-check a couple keys exist+ for _, key := range []string{"authLocalEnabled", "stacksDirectory"} {+ var sv models.SettingVariable+ err := svc.db.WithContext(ctx).Where("key = ?", key).First(&sv).Error+ if err != nil {+ t.Fatalf("missing default key %s: %v", key, err)+ }+ }+}++func TestSettingsService_GetSettings_UnknownKeysIgnored(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ svc := NewSettingsService(db, &config.Config{})++ // Unknown key should not break loading+ if err := svc.db.WithContext(ctx).Create(&models.SettingVariable{Key: "someUnknownKey", Value: "x"}).Error; err != nil {+ t.Fatalf("seed: %v", err)+ }+ if _, err := svc.GetSettings(ctx); err != nil {+ t.Fatalf("GetSettings should ignore unknown key: %v", err)+ }+}++func TestSettingsService_GetSetHelpers(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ svc := NewSettingsService(db, &config.Config{})++ // Defaults for missing keys+ if got := svc.GetBoolSetting(ctx, "nonexistentBool", true); got != true {+ t.Fatalf("GetBoolSetting default mismatch: got %v", got)+ }+ if got := svc.GetIntSetting(ctx, "nonexistentInt", 42); got != 42 {+ t.Fatalf("GetIntSetting default mismatch: got %v", got)+ }+ if got := svc.GetStringSetting(ctx, "nonexistentStr", "def"); got != "def" {+ t.Fatalf("GetStringSetting default mismatch: got %v", got)+ }++ // Set and read back+ if err := svc.SetBoolSetting(ctx, "enableGravatar", true); err != nil {+ t.Fatalf("SetBoolSetting: %v", err)+ }+ if got := svc.GetBoolSetting(ctx, "enableGravatar", false); !got {+ t.Fatalf("GetBoolSetting persisted mismatch")+ }++ if err := svc.SetIntSetting(ctx, "authSessionTimeout", 123); err != nil {+ t.Fatalf("SetIntSetting: %v", err)+ }+ if got := svc.GetIntSetting(ctx, "authSessionTimeout", 0); got != 123 {+ t.Fatalf("GetIntSetting persisted mismatch: %v", got)+ }++ if err := svc.SetStringSetting(ctx, "baseServerUrl", "http://localhost"); err != nil {+ t.Fatalf("SetStringSetting: %v", err)+ }+ if got := svc.GetStringSetting(ctx, "baseServerUrl", ""); got != "http://localhost" {+ t.Fatalf("GetStringSetting persisted mismatch: %q", got)+ }+}++func TestSettingsService_UpdateSetting(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ svc := NewSettingsService(db, &config.Config{})++ if err := svc.UpdateSetting(ctx, "dockerPruneMode", "all"); err != nil {+ t.Fatalf("UpdateSetting: %v", err)+ }+ var sv models.SettingVariable+ if err := svc.db.WithContext(ctx).Where("key = ?", "dockerPruneMode").First(&sv).Error; err != nil {+ t.Fatalf("query: %v", err)+ }+ if sv.Value != "all" {+ t.Fatalf("value mismatch: %q", sv.Value)+ }+}++func TestSettingsService_EnsureEncryptionKey(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ svc := NewSettingsService(db, &config.Config{})++ k1, err := svc.EnsureEncryptionKey(ctx)+ if err != nil {+ t.Fatalf("EnsureEncryptionKey: %v", err)+ }+ if k1 == "" {+ t.Fatalf("empty key")+ }++ // Key should be persisted and reused+ k2, err := svc.EnsureEncryptionKey(ctx)+ if err != nil {+ t.Fatalf("EnsureEncryptionKey 2nd: %v", err)+ }+ if k2 != k1 {+ t.Fatalf("key not stable: first=%q second=%q", k1, k2)+ }++ var sv models.SettingVariable+ if err := svc.db.WithContext(ctx).Where("key = ?", "encryptionKey").First(&sv).Error; err != nil {+ t.Fatalf("query encryptionKey: %v", err)+ }+ if sv.Value != k1 {+ t.Fatalf("stored key mismatch")+ }+}++func TestSettingsService_SyncOidcEnvToDatabase(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ cfg := &config.Config{+ OidcEnabled: true,+ OidcClientID: "cid",+ OidcClientSecret: "csec",+ OidcIssuerURL: "https://issuer.example",+ OidcScopes: "openid profile email",+ OidcAdminClaim: "roles",+ OidcAdminValue: "admin",+ }+ svc := NewSettingsService(db, cfg)++ vars, err := svc.SyncOidcEnvToDatabase(ctx)+ if err != nil {+ t.Fatalf("SyncOidcEnvToDatabase: %v", err)+ }+ if len(vars) == 0 {+ t.Fatalf("expected settings slice returned")+ }++ // Verify persisted values+ var enabled models.SettingVariable+ if err := svc.db.WithContext(ctx).Where("key = ?", "authOidcEnabled").First(&enabled).Error; err != nil {+ t.Fatalf("query authOidcEnabled: %v", err)+ }+ if enabled.Value != "true" {+ t.Fatalf("authOidcEnabled not true: %q", enabled.Value)+ }++ var cfgVar models.SettingVariable+ if err := svc.db.WithContext(ctx).Where("key = ?", "authOidcConfig").First(&cfgVar).Error; err != nil {+ t.Fatalf("query authOidcConfig: %v", err)+ }+ var oc models.OidcConfig+ if err := json.Unmarshal([]byte(cfgVar.Value), &oc); err != nil {+ t.Fatalf("unmarshal oidc cfg: %v", err)+ }+ if oc.ClientID != "cid" || oc.ClientSecret != "csec" || oc.IssuerURL != "https://issuer.example" {+ t.Fatalf("oidc cfg mismatch: %+v", oc)+ }+ if oc.Scopes != "openid profile email" || oc.AdminClaim != "roles" || oc.AdminValue != "admin" {+ t.Fatalf("oidc cfg extras mismatch: %+v", oc)+ }+}++func TestSettingsService_UpdateSettings_MergeOidcSecret(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)+ svc := NewSettingsService(db, &config.Config{})++ // Seed existing OIDC config with a secret+ existing := models.OidcConfig{+ ClientID: "old",+ ClientSecret: "keep-this",+ IssuerURL: "https://issuer",+ }+ b, _ := json.Marshal(existing)+ if err := svc.UpdateSetting(ctx, "authOidcConfig", string(b)); err != nil {+ t.Fatalf("seed: %v", err)+ }++ // Incoming update missing clientSecret should preserve existing one+ incoming := models.OidcConfig{+ ClientID: "new",+ IssuerURL: "https://issuer",+ }+ nb, _ := json.Marshal(incoming)+ s := string(nb)++ updates := dto.UpdateSettingsDto{+ AuthOidcConfig: &s,+ }+ if _, err := svc.UpdateSettings(ctx, updates); err != nil {+ t.Fatalf("UpdateSettings: %v", err)+ }++ var cfgVar models.SettingVariable+ if err := svc.db.WithContext(ctx).Where("key = ?", "authOidcConfig").First(&cfgVar).Error; err != nil {+ t.Fatalf("query: %v", err)+ }+ var merged models.OidcConfig+ if err := json.Unmarshal([]byte(cfgVar.Value), &merged); err != nil {+ t.Fatalf("unmarshal merged: %v", err)+ }+ if merged.ClientID != "new" {+ t.Fatalf("clientId not updated: %q", merged.ClientID)+ }+ if merged.ClientSecret != "keep-this" {+ t.Fatalf("clientSecret not preserved: %q", merged.ClientSecret)+ }+}