Skip to content

Modern Docker Management, Designed for Everyone

chore: add service unit tests

Kyle Mendell99e8a68d87dc
diff --git a/backend/internal/services/auth_service_test.go b/backend/internal/services/auth_service_test.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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)
+ }
+}