Skip to content

Modern Docker Management, Designed for Everyone

50.8 KB
Raw Blame
package settings

import (
	"context"
	"encoding/base64"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"sync/atomic"
	"testing"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/features"
	"github.com/getarcaneapp/arcane/types/v2/settings"
	"github.com/libtnb/sqlite"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/sys/crypto"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/config"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
)

func setupSettingsTestDB(t *testing.T) *database.DB {
	t.Helper()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&SettingVariable{}))
	return &database.DB{DB: db}
}

func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*SettingsService, error) {
	t.Helper()
	crypto.InitEncryption(&crypto.Config{Environment: "development"})
	svc, err := NewSettingsService(ctx, db, config.Load())
	if err == nil {
		t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
	}
	return svc, err
}

func waitForSettingsNotifications(t *testing.T, svc *SettingsService) {
	t.Helper()
	done := make(chan struct{})
	svc.writes.Lock()
	err := svc.enqueueEffect(func() { close(done) })
	svc.writes.Unlock()
	require.NoError(t, err)
	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("settings effects did not finish")
	}
}

func TestSettingsService_EnsureDefaultSettings_ReplacesRetiredDefaults(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, db.Create(&SettingVariable{Key: "dockerClientRefreshInterval", Value: "*/30 * * * * *"}).Error)
	require.NoError(t, db.Create(&SettingVariable{Key: "autoHealInterval", Value: "*/10 * * * * *"}).Error)

	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var retired, custom SettingVariable
	require.NoError(t, db.First(&retired, "key = ?", "dockerClientRefreshInterval").Error)
	require.Equal(t, "0 */5 * * * *", retired.Value, "the retired default moves to the current default")
	require.NoError(t, db.First(&custom, "key = ?", "autoHealInterval").Error)
	require.Equal(t, "*/10 * * * * *", custom.Value, "a customised value is left alone")
}

func TestSettingsService_EnsureDefaultSettings_Idempotent(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var count1 int64
	require.NoError(t, svc.db.WithContext(ctx).Model(&SettingVariable{}).Count(&count1).Error)
	require.Positive(t, count1)

	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var count2 int64
	require.NoError(t, svc.db.WithContext(ctx).Model(&SettingVariable{}).Count(&count2).Error)
	require.Equal(t, count1, count2)

	// Spot-check core and automation defaults exist with correct values
	for _, key := range []string{
		"authLocalEnabled",
		"projectsDirectory",
		"followProjectSymlinks",
		"autoUpdateExcludedContainers",
		"imageEventWatcherEnabled",
		"vulnerabilityScanEnabled",
		"vulnerabilityScanInterval",
		"toolsImageRegistry",
		"updateCheckRegistry",
		"trivyDbRegistry",
		"trivyNetwork",
		"trivySecurityOpts",
		"trivyPrivileged",
		"trivyResourceLimitsEnabled",
		"trivyCpuLimit",
		"trivyMemoryLimitMb",
		"trivyConcurrentScanContainers",
		"gitSyncMaxFiles",
		"gitSyncMaxTotalSizeMb",
		"gitSyncMaxBinarySizeMb",
		"lifecycleDefaultRunnerImage",
	} {
		var sv SettingVariable
		lookupSettingErr := svc.db.WithContext(ctx).Where("key = ?", key).First(&sv).Error
		require.NoErrorf(t, lookupSettingErr, "missing default key %s", key)

		switch key {
		case "followProjectSymlinks":
			require.Equal(t, "false", sv.Value)
		case "autoUpdateExcludedContainers":
			require.Empty(t, sv.Value)
		case "imageEventWatcherEnabled":
			require.Equal(t, "false", sv.Value)
		case "vulnerabilityScanEnabled":
			require.Equal(t, "false", sv.Value)
		case "vulnerabilityScanInterval":
			require.Equal(t, "0 0 0 * * *", sv.Value)
		case "toolsImageRegistry":
			require.Equal(t, "ghcr.io", sv.Value)
		case "updateCheckRegistry":
			require.Equal(t, "auto", sv.Value)
		case "trivyDbRegistry":
			require.Equal(t, "ghcr.io", sv.Value)
		case "lifecycleDefaultRunnerImage":
			require.Equal(t, "alpine:latest", sv.Value)
		case "trivyNetwork":
			require.Empty(t, sv.Value)
		case "trivySecurityOpts":
			require.Empty(t, sv.Value)
		case "trivyPrivileged":
			require.Equal(t, "false", sv.Value)
		case "trivyResourceLimitsEnabled":
			require.Equal(t, "true", sv.Value)
		case "trivyCpuLimit":
			require.Equal(t, "1", sv.Value)
		case "trivyMemoryLimitMb":
			require.Equal(t, "0", sv.Value)
		case "trivyConcurrentScanContainers":
			require.Equal(t, "1", sv.Value)
		case "gitSyncMaxFiles":
			require.Equal(t, "500", sv.Value)
		case "gitSyncMaxTotalSizeMb":
			require.Equal(t, "50", sv.Value)
		case "gitSyncMaxBinarySizeMb":
			require.Equal(t, "10", sv.Value)
		}
	}
}

func TestSettingsService_ImageEventWatcherSettingPersists(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))
	require.False(t, svc.GetBoolSetting(ctx, "imageEventWatcherEnabled", true))

	_, err = svc.UpdateSettings(ctx, settings.Update{ImageEventWatcherEnabled: new("true")})
	require.NoError(t, err)
	require.True(t, svc.GetBoolSetting(ctx, "imageEventWatcherEnabled", false))

	var stored SettingVariable
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "imageEventWatcherEnabled").First(&stored).Error)
	require.Equal(t, "true", stored.Value)
}

func TestSettingsService_GetSettings_UnknownKeysIgnored(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.db.WithContext(ctx).
		Create(&SettingVariable{Key: "someUnknownKey", Value: "x"}).Error)

	_, err = svc.GetSettings(ctx)
	require.NoError(t, err)
}

func TestSettingsService_GetSettings_UsesCachedSnapshotWithoutDatabase(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.SetStringSetting(ctx, "baseServerUrl", "http://cached"))

	// GetSettings should clone the in-memory snapshot and not touch the database.
	svc.db = nil

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, "http://cached", settingsCfg.BaseServerURL.Value)
}

func TestSettingsService_AvatarMaxUploadSizeDefaultAndUpdate(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	current, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, "2", current.AvatarMaxUploadSizeMb.Value)

	updatedValue := "8"
	_, err = svc.UpdateSettings(ctx, settings.Update{
		AvatarMaxUploadSizeMb: &updatedValue,
	})
	require.NoError(t, err)

	current, err = svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, "8", current.AvatarMaxUploadSizeMb.Value)
}

func TestSettingsServiceUpdateSettingsRejectsOIDCIssuerChangeWithStoredSecret(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "oidcIssuerUrl", "https://issuer.example.com"))
	require.NoError(t, svc.UpdateSetting(ctx, "oidcClientSecret", "old-client-secret"))

	_, err = svc.UpdateSettings(ctx, settings.Update{
		OidcIssuerUrl: new("https://attacker.example.com"),
	})
	require.ErrorIs(t, err, common.ErrValidation)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "https://issuer.example.com", current.OidcIssuerUrl.Value)
	require.Equal(t, "old-client-secret", current.OidcClientSecret.Value)
}

func TestSettingsServiceUpdateSettingsAllowsOIDCIssuerChangeWhenClearingSecret(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "oidcIssuerUrl", "https://issuer.example.com"))
	require.NoError(t, svc.UpdateSetting(ctx, "oidcClientSecret", "old-client-secret"))

	_, err = svc.UpdateSettings(ctx, settings.Update{
		OidcIssuerUrl:    new("https://replacement.example.com"),
		OidcClientSecret: new(""),
	})
	require.NoError(t, err)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "https://replacement.example.com", current.OidcIssuerUrl.Value)
	require.Empty(t, current.OidcClientSecret.Value)
}

func TestSettingsServiceUpdateSettingsRejectsEnablingOIDCWithoutSecret(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	_, err = svc.UpdateSettings(ctx, settings.Update{
		OidcEnabled:   new("true"),
		OidcClientId:  new("arcane"),
		OidcIssuerUrl: new("https://issuer.example.com"),
	})
	require.ErrorIs(t, err, common.ErrValidation)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "false", current.OidcEnabled.Value)
}

func TestSettingsServiceUpdateSettingsAllowsOIDCIssuerChangeWithReplacementSecret(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "oidcIssuerUrl", "https://issuer.example.com"))
	require.NoError(t, svc.UpdateSetting(ctx, "oidcClientSecret", "old-client-secret"))

	require.NoError(t, svc.UpdateSetting(ctx, "oidcProviderName", "  Cafe\u0301 SSO  "))
	before, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "Café SSO", before.OidcProviderName.Value)

	_, err = svc.UpdateSettings(ctx, settings.Update{
		OidcProviderName: new("  Cafe\u0301 Login  "),
		OidcIssuerUrl:    new("https://replacement.example.com"),
		OidcClientSecret: new("new-client-secret"),
	})
	require.NoError(t, err)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "https://replacement.example.com", current.OidcIssuerUrl.Value)
	require.Equal(t, "new-client-secret", current.OidcClientSecret.Value)
	require.Equal(t, "Café Login", current.OidcProviderName.Value)
}

func TestSettingsServiceUpdateSettingsRejectsTrivyServerChangeWithStoredToken(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerUrl", "https://trivy.example.com"))
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerToken", "old-trivy-token"))

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivyServerUrl: new("https://attacker.example.com"),
	})
	require.ErrorIs(t, err, common.ErrValidation)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "https://trivy.example.com", current.TrivyServerUrl.Value)
	require.Equal(t, "old-trivy-token", current.TrivyServerToken.Value)
}

func TestSettingsServiceUpdateSettingsAllowsTrivyServerChangeWithReplacementToken(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerUrl", "https://trivy.example.com"))
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerToken", "old-trivy-token"))

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivyServerUrl:   new("https://replacement.example.com"),
		TrivyServerToken: new("new-trivy-token"),
	})
	require.NoError(t, err)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "https://replacement.example.com", current.TrivyServerUrl.Value)
	require.Equal(t, "new-trivy-token", current.TrivyServerToken.Value)
}

func TestSettingsServiceUpdateSettingsAllowsClearingTrivyServerWithStoredToken(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerUrl", "https://trivy.example.com"))
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerToken", "old-trivy-token"))

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivyServerUrl: new(""),
	})
	require.NoError(t, err)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Empty(t, current.TrivyServerUrl.Value)
	require.Equal(t, "old-trivy-token", current.TrivyServerToken.Value)
}

func TestSettingsServiceUpdateSettingsAllowsTrivyServerChangeWithoutStoredToken(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "trivyServerUrl", "https://trivy.example.com"))

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivyServerUrl: new("https://replacement.example.com"),
	})
	require.NoError(t, err)

	current, loadErr := svc.GetSettings(ctx)
	require.NoError(t, loadErr)
	require.Equal(t, "https://replacement.example.com", current.TrivyServerUrl.Value)
}

func TestSettingsService_PruneUnknownSettings_RemovesStaleKeys(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", "/tmp/projects"))
	require.NoError(t, svc.UpdateSetting(ctx, "encryptionKey", "test-encryption-key"))
	require.NoError(t, svc.UpdateSetting(ctx, "unknownKey", "value"))

	require.NoError(t, svc.PruneUnknownSettings(ctx))

	var sv SettingVariable
	err = svc.db.WithContext(ctx).Where("key = ?", "unknownKey").First(&sv).Error
	require.ErrorIs(t, err, gorm.ErrRecordNotFound)

	var sv2 SettingVariable
	err = svc.db.WithContext(ctx).Where("key = ?", "projectsDirectory").First(&sv2).Error
	require.NoError(t, err)

	var sv3 SettingVariable
	err = svc.db.WithContext(ctx).Where("key = ?", "encryptionKey").First(&sv3).Error
	require.NoError(t, err)
}

func TestSettingsService_GetSettings_EnvOverride_OidcMergeAccounts(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("OIDC_MERGE_ACCOUNTS", "true")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.True(t, settingsCfg.OidcMergeAccounts.IsTrue())
}

func TestSettingsService_GetSettings_EnvOverride_TrivyScanTimeout(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("TRIVY_SCAN_TIMEOUT", "1800")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, 1800, settingsCfg.TrivyScanTimeout.AsInt())
}

func TestSettingsService_GetSettings_EnvOverride_TrivyResourceLimits(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("TRIVY_RESOURCE_LIMITS_ENABLED", "false")
	t.Setenv("TRIVY_CPU_LIMIT", "2.5")
	t.Setenv("TRIVY_MEMORY_LIMIT_MB", "2048")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.False(t, settingsCfg.TrivyResourceLimitsEnabled.IsTrue())
	require.Equal(t, "2.5", settingsCfg.TrivyCpuLimit.Value)
	require.Equal(t, 2048, settingsCfg.TrivyMemoryLimitMb.AsInt())
}

func TestSettingsService_GetSettings_EnvOverride_TrivyNetwork(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("TRIVY_NETWORK", "arcane-external")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, "arcane-external", settingsCfg.TrivyNetwork.Value)
}

func TestSettingsService_GetSettings_EnvOverride_FollowProjectSymlinks(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("FOLLOW_PROJECT_SYMLINKS", "true")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.True(t, settingsCfg.FollowProjectSymlinks.IsTrue())
}

func TestSettingsService_GetSettings_EnvOverride_TrivyRuntimeSecurity(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("TRIVY_SECURITY_OPTS", "label=disable,\nlabel=type:container_runtime_t")
	t.Setenv("TRIVY_PRIVILEGED", "true")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, "label=disable,\nlabel=type:container_runtime_t", settingsCfg.TrivySecurityOpts.Value)
	require.True(t, settingsCfg.TrivyPrivileged.IsTrue())
}

func TestSettingsService_GetStringSetting_EnvOverride_SwarmStackSourcesDirectory(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	t.Setenv("SWARM_STACK_SOURCES_DIRECTORY", "/mnt/swarm-from-env")

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.UpdateSetting(ctx, "swarmStackSourcesDirectory", "/tmp/swarm-from-db"))

	require.Equal(t, "/mnt/swarm-from-env", svc.GetStringSetting(ctx, "swarmStackSourcesDirectory", "/fallback"))
	require.Equal(t, "/mnt/swarm-from-env", svc.GetSettingsConfig().SwarmStackSourcesDirectory.Value)
}

func TestSettingsService_isEnvOverrideActive(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.False(t, svc.IsEnvOverrideActive("oidcEnabled"))

	t.Setenv("OIDC_ENABLED", "false")
	svcWithOverride, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.True(t, svcWithOverride.IsEnvOverrideActive("oidcEnabled"))

	t.Setenv("AUTH_SESSION_TIMEOUT", "120")
	svcWithNonOverrideEnv, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.False(t, svcWithNonOverrideEnv.IsEnvOverrideActive("authSessionTimeout"))
}

func TestSettingsService_GetSetHelpers(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Defaults for missing keys
	require.True(t, svc.GetBoolSetting(ctx, "nonexistentBool", true))
	require.Equal(t, 42, svc.GetIntSetting(ctx, "nonexistentInt", 42))
	require.Equal(t, "def", svc.GetStringSetting(ctx, "nonexistentStr", "def"))

	// Set and read back
	require.NoError(t, svc.SetBoolSetting(ctx, "enableGravatar", true))
	require.True(t, svc.GetBoolSetting(ctx, "enableGravatar", false))

	require.NoError(t, svc.SetIntSetting(ctx, "authSessionTimeout", 123))
	require.Equal(t, 123, svc.GetIntSetting(ctx, "authSessionTimeout", 0))

	require.NoError(t, svc.SetStringSetting(ctx, "baseServerUrl", "http://localhost"))
	require.Equal(t, "http://localhost", svc.GetStringSetting(ctx, "baseServerUrl", ""))
}

func TestSettingsService_UpdateSetting(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.UpdateSetting(ctx, "pruneImageMode", "all"))

	var sv SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "pruneImageMode").First(&sv).Error)
	require.Equal(t, "all", sv.Value)
}

func TestSettingsService_UpdateSettingRejectsInvalidCronBeforePersistence(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.UpdateSetting(ctx, "pollingInterval", "*/5 * * * * *"))
	require.Error(t, svc.UpdateSetting(ctx, "pollingInterval", "not a cron schedule"))

	var setting SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "pollingInterval").First(&setting).Error)
	require.Equal(t, "*/5 * * * * *", setting.Value)
}

func TestSettingsService_UpdateSetting_RefreshesCachedSnapshot(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.Equal(t, "http://localhost", svc.GetSettingsConfig().BaseServerURL.Value)
	require.NoError(t, svc.UpdateSetting(ctx, "baseServerUrl", "https://arcane.test"))

	require.Equal(t, "https://arcane.test", svc.GetSettingsConfig().BaseServerURL.Value)

	settingsCfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, "https://arcane.test", settingsCfg.BaseServerURL.Value)
}

func TestSettingsService_UpdateSettings_PruneModesDoNotTriggerScheduledPruneCallback(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	callbackCalls := 0
	svc.SubscribeSettingsChanges([]string{"scheduledPruneEnabled", "scheduledPruneInterval"}, func([]libarcane.SettingUpdate) {
		callbackCalls++
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{
		PruneImageMode:      new("all"),
		PruneContainerUntil: new("24h"),
	})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.Equal(t, 0, callbackCalls)
}

func TestSettingsService_UpdateSettings_ScheduledPruneScheduleTriggersCallback(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	callbackCalls := 0
	svc.SubscribeSettingsChanges([]string{"scheduledPruneEnabled", "scheduledPruneInterval"}, func([]libarcane.SettingUpdate) {
		callbackCalls++
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{
		ScheduledPruneEnabled: new("true"),
	})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.Equal(t, 1, callbackCalls)
}

func TestSettingsServiceActorSerializesConcurrentUpdates(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	start := make(chan struct{})
	results := make(chan error, 2)
	go func() {
		<-start
		_, updateErr := svc.UpdateSettings(ctx, settings.Update{ProjectsDirectory: new("/data/projects-a")})
		results <- updateErr
	}()
	go func() {
		<-start
		_, updateErr := svc.UpdateSettings(ctx, settings.Update{TemplatesDirectory: new("/data/templates-b")})
		results <- updateErr
	}()
	close(start)

	require.NoError(t, <-results)
	require.NoError(t, <-results)
	current := svc.GetSettingsConfig()
	require.Equal(t, "/data/projects-a", current.ProjectsDirectory.Value)
	require.Equal(t, "/data/templates-b", current.TemplatesDirectory.Value)
}

func TestSettingsServiceActorPublishesSnapshotBeforeAsynchronousNotification(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	callbackStarted := make(chan string, 1)
	releaseCallback := make(chan struct{})
	svc.SubscribeSettingsChanges([]string{"baseServerUrl"}, func(_ []libarcane.SettingUpdate) {
		callbackStarted <- svc.GetSettingsConfig().BaseServerURL.Value
		<-releaseCallback
	})

	updateResult := make(chan error, 1)
	go func() {
		_, updateErr := svc.UpdateSettings(ctx, settings.Update{BaseServerURL: new("https://actor.example")})
		updateResult <- updateErr
	}()

	require.Equal(t, "https://actor.example", <-callbackStarted)
	select {
	case updateErr := <-updateResult:
		require.NoError(t, updateErr)
	case <-time.After(time.Second):
		require.FailNow(t, "settings update waited for notification callback")
	}

	secondUpdate := make(chan error, 1)
	go func() {
		_, updateErr := svc.UpdateSettings(ctx, settings.Update{ProjectsDirectory: new("/data/unblocked")})
		secondUpdate <- updateErr
	}()
	select {
	case secondUpdateErr := <-secondUpdate:
		require.NoError(t, secondUpdateErr)
	case <-time.After(time.Second):
		require.FailNow(t, "settings subscriber blocked the next settings writer")
	}
	close(releaseCallback)
}

func TestSettingsServiceActorNotifiesSubscriberOnceForMultipleMatchingKeys(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var calls atomic.Int32
	notified := make(chan []libarcane.SettingUpdate, 1)
	svc.SubscribeSettingsChanges([]string{"pollingEnabled", "pollingInterval"}, func(updates []libarcane.SettingUpdate) {
		calls.Add(1)
		notified <- updates
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{
		PollingEnabled:  new("false"),
		PollingInterval: new("0 */5 * * * *"),
	})
	require.NoError(t, err)
	require.Len(t, <-notified, 2)
	require.Equal(t, int32(1), calls.Load())
}

func TestSettingsServiceActorDoesNotPublishSensitiveValues(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var calls atomic.Int32
	svc.SubscribeSettingsChanges([]string{"oidcClientSecret"}, func([]libarcane.SettingUpdate) {
		calls.Add(1)
	})
	_, err = svc.UpdateSettings(ctx, settings.Update{OidcClientSecret: new("should-not-leave-settings-service")})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.Zero(t, calls.Load())
}

func TestSettingsServiceActorSerializesContainerExclusionUpdates(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	start := make(chan struct{})
	results := make(chan error, 2)
	for _, name := range []string{"api", "worker"} {
		go func() {
			<-start
			results <- svc.SetContainerAutoUpdateExclusionInternal(ctx, name, true)
		}()
	}
	close(start)

	require.NoError(t, <-results)
	require.NoError(t, <-results)
	require.ElementsMatch(t, []string{"api", "worker"}, strings.Split(svc.GetStringSetting(ctx, "autoUpdateExcludedContainers", ""), ","))
}

func BenchmarkSettingsService_GetSettings(b *testing.B) {
	ctx := b.Context()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	if err != nil {
		require.FailNowf(b, "benchmark database setup failed", "%v", err)
	}
	if autoMigrateErr := db.AutoMigrate(&SettingVariable{}); autoMigrateErr != nil {
		require.FailNowf(b, "benchmark database migration failed", "%v", autoMigrateErr)
	}
	settingsDB := &database.DB{DB: db}
	svc, err := newSettingsServiceForTest(b, ctx, settingsDB)
	if err != nil {
		require.FailNowf(b, "benchmark service setup failed", "%v", err)
	}

	b.ReportAllocs()
	b.ResetTimer()

	for b.Loop() {
		settingsCfg, getSettingsErr := svc.GetSettings(ctx)
		if getSettingsErr != nil {
			require.FailNowf(b, "benchmark GetSettings failed", "%v", getSettingsErr)
		}
		if settingsCfg == nil {
			require.FailNow(b, "GetSettings returned nil settings")
		}
	}
}

func TestSettingsService_EnsureEncryptionKey(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	k1, err := svc.EnsureEncryptionKey(ctx)
	require.NoError(t, err)
	require.NotEmpty(t, k1)

	k2, err := svc.EnsureEncryptionKey(ctx)
	require.NoError(t, err)
	require.Equal(t, k1, k2, "encryption key should be stable between calls")

	var sv SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "encryptionKey").First(&sv).Error)
	require.Equal(t, k1, sv.Value)
	crypto.InitEncryption(&crypto.Config{EncryptionKey: k1, Environment: "development"})

	browserKey1, err := svc.EnsureBrowserSessionSigningKey(ctx)
	require.NoError(t, err)
	require.Len(t, browserKey1, browserSessionSigningKeySize)
	browserKey2, err := svc.EnsureBrowserSessionSigningKey(ctx)
	require.NoError(t, err)
	require.Equal(t, browserKey1, browserKey2, "browser signing key should be stable between calls")

	var browserSetting SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "browserSessionSigningKey").First(&browserSetting).Error)
	require.NotEmpty(t, browserSetting.Value)
	require.NotEqual(t, base64.StdEncoding.EncodeToString(browserKey1), browserSetting.Value)
}

func TestSettingsService_LoadDatabaseSettings_ReloadsChanges(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Initially empty DB -> defaults (not persisted yet)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	// Update a value directly in DB
	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", "custom/projects"))

	// Force reload
	require.NoError(t, svc.LoadDatabaseSettings(ctx))

	cfg := svc.GetSettingsConfig()
	require.Equal(t, "custom/projects", cfg.ProjectsDirectory.Value)
}

func TestSettingsService_LoadDatabaseSettings_UIConfigurationDisabled_Env(t *testing.T) {
	// Set env + disable flag BEFORE service init
	t.Setenv("UI_CONFIGURATION_DISABLED", "true")
	t.Setenv("PROJECTS_DIRECTORY", "env/projects")
	// One value as a variable, one as a Docker secret file.
	baseURLFile := filepath.Join(t.TempDir(), "base-server-url")
	require.NoError(t, os.WriteFile(baseURLFile, []byte("https://env.example\n"), 0o600))
	t.Setenv("BASE_SERVER_URL_FILE", baseURLFile)

	c := config.Load()
	c.UIConfigurationDisabled = true

	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Reload explicitly (NewSettingsService already did, but explicit for clarity)
	require.NoError(t, svc.LoadDatabaseSettings(ctx))

	cfg := svc.GetSettingsConfig()
	require.Equal(t, "env/projects", cfg.ProjectsDirectory.Value)
	require.Equal(t, "https://env.example", cfg.BaseServerURL.Value)
}

func TestSettingsService_UpdateSettings_RefreshesCache(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	newDir := "custom/projects2"
	req := settings.Update{
		ProjectsDirectory: &newDir,
	}

	_, err = svc.UpdateSettings(ctx, req)
	require.NoError(t, err)

	// ListSettings uses the cached snapshot; should reflect updated value
	list := svc.ListSettings(SettingVisibilityAll)
	found := false
	for _, sv := range list {
		if sv.Key == "projectsDirectory" {
			found = true
			require.Equal(t, newDir, sv.Value)
		}
	}
	require.True(t, found, "projectsDirectory setting not found in cached list")
}

func TestSettingsService_UpdateSettings_ReturnsEnvOverriddenValues(t *testing.T) {
	t.Setenv("DOCKER_HOST", "tcp://env-docker:2375")

	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	settingsList, err := svc.UpdateSettings(ctx, settings.Update{
		ProjectsDirectory: new("custom/projects2"),
	})
	require.NoError(t, err)

	found := false
	for _, sv := range settingsList {
		if sv.Key == "dockerHost" {
			found = true
			require.Equal(t, "tcp://env-docker:2375", sv.Value)
		}
	}
	require.True(t, found, "dockerHost setting not found in update response")
}

func TestSettingsService_UpdateSettings_TimeoutCallbackIncludesTrivyScanTimeout(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var callbackPayload []libarcane.SettingUpdate
	svc.SubscribeSettingsChanges(libarcane.TimeoutSettingKeys(), func(timeoutSettings []libarcane.SettingUpdate) {
		callbackPayload = timeoutSettings
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{TrivyScanTimeout: new("1200")})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)

	require.NotNil(t, callbackPayload)
	require.Contains(t, callbackPayload, libarcane.SettingUpdate{Key: "trivyScanTimeout", Value: "1200"})
}

func TestSettingsService_UpdateSettings_TimeoutCallbackIncludesTrivyResourceLimits(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var callbackPayload []libarcane.SettingUpdate
	svc.SubscribeSettingsChanges(libarcane.TimeoutSettingKeys(), func(timeoutSettings []libarcane.SettingUpdate) {
		callbackPayload = timeoutSettings
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivyResourceLimitsEnabled: new("false"),
		TrivyCpuLimit:              new("2.5"),
		TrivyMemoryLimitMb:         new("3072"),
	})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)

	require.NotNil(t, callbackPayload)
	require.Contains(t, callbackPayload, libarcane.SettingUpdate{Key: "trivyResourceLimitsEnabled", Value: "false"})
	require.Contains(t, callbackPayload, libarcane.SettingUpdate{Key: "trivyCpuLimit", Value: "2.5"})
	require.Contains(t, callbackPayload, libarcane.SettingUpdate{Key: "trivyMemoryLimitMb", Value: "3072"})
}

func TestSettingsService_UpdateSettings_TimeoutCallbackIncludesTrivyConcurrentScanContainers(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var callbackPayload []libarcane.SettingUpdate
	svc.SubscribeSettingsChanges(libarcane.TimeoutSettingKeys(), func(timeoutSettings []libarcane.SettingUpdate) {
		callbackPayload = timeoutSettings
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{TrivyConcurrentScanContainers: new("4")})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)

	require.NotNil(t, callbackPayload)
	require.Contains(t, callbackPayload, libarcane.SettingUpdate{Key: "trivyConcurrentScanContainers", Value: "4"})
}

func TestSettingsService_UpdateSettings_TrivyNetworkTriggersVulnerabilityCallback(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	callbackCalled := false
	svc.SubscribeSettingsChanges([]string{"trivyNetwork"}, func(_ []libarcane.SettingUpdate) {
		callbackCalled = true
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{TrivyNetwork: new("arcane-external")})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.True(t, callbackCalled)
}

func TestSettingsService_UpdateSettings_TrivyNetworkDoesNotTriggerTimeoutCallback(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var callbackPayload []libarcane.SettingUpdate
	svc.SubscribeSettingsChanges(libarcane.TimeoutSettingKeys(), func(timeoutSettings []libarcane.SettingUpdate) {
		callbackPayload = timeoutSettings
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{TrivyNetwork: new("arcane-external")})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.Nil(t, callbackPayload)
}

func TestSettingsService_UpdateSettings_TrivyRuntimeSecurityTriggersVulnerabilityCallback(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	callbackCalled := false
	svc.SubscribeSettingsChanges([]string{"trivySecurityOpts", "trivyPrivileged"}, func(_ []libarcane.SettingUpdate) {
		callbackCalled = true
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivySecurityOpts: new("label=disable"),
		TrivyPrivileged:   new("true"),
	})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.True(t, callbackCalled)
}

func TestSettingsService_UpdateSettings_TrivyRuntimeSecurityDoesNotTriggerTimeoutCallback(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	var callbackPayload []libarcane.SettingUpdate
	svc.SubscribeSettingsChanges(libarcane.TimeoutSettingKeys(), func(timeoutSettings []libarcane.SettingUpdate) {
		callbackPayload = timeoutSettings
	})

	_, err = svc.UpdateSettings(ctx, settings.Update{
		TrivySecurityOpts: new("label=disable"),
		TrivyPrivileged:   new("true"),
	})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.Nil(t, callbackPayload)
}

func TestSettingsService_LoadDatabaseSettings_InternalKeys_EnvMode(t *testing.T) {
	// Set env + disable flag
	t.Setenv("UI_CONFIGURATION_DISABLED", "true")

	ctx := t.Context()
	db := setupSettingsTestDB(t)

	// Pre-populate an internal setting in the DB
	internalKey := "instanceId"
	internalVal := "test-instance-id"
	require.NoError(t, db.DB.Create(&SettingVariable{Key: internalKey, Value: internalVal}).Error)

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Reload explicitly to trigger the env loading path
	require.NoError(t, svc.LoadDatabaseSettings(ctx))

	cfg := svc.GetSettingsConfig()
	// Should have loaded the internal setting from DB even in env mode
	require.Equal(t, internalVal, cfg.InstanceID.Value)
}

func TestSettingsService_NormalizeProjectsDirectory_ConvertsRelativeToAbsolute(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Seed with relative path
	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", "data/projects"))

	// Run normalization without env var set (empty string)
	err = svc.NormalizeProjectsDirectory(ctx, "")
	require.NoError(t, err)

	// Verify it was updated to absolute path
	var setting SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "projectsDirectory").First(&setting).Error)

	// Should be converted to absolute path
	expectedPath, _ := filepath.Abs("data/projects")
	require.Equal(t, expectedPath, setting.Value)
	require.True(t, filepath.IsAbs(setting.Value), "path should be absolute")
}

func TestSettingsService_NormalizeProjectsDirectory_SkipsWhenEnvSet(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Seed with relative path
	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", "data/projects"))

	// Run normalization WITH env var set
	err = svc.NormalizeProjectsDirectory(ctx, "/custom/env/path")
	require.NoError(t, err)

	// Verify it was NOT changed
	var setting SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "projectsDirectory").First(&setting).Error)
	require.Equal(t, "data/projects", setting.Value, "should not change when env var is set")
}

func TestSettingsService_NormalizeProjectsDirectory_LeavesOtherPathsUnchanged(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	customPath := "/custom/projects/path"
	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", customPath))

	// Run normalization
	err = svc.NormalizeProjectsDirectory(ctx, "")
	require.NoError(t, err)

	// Verify it was NOT changed
	var setting SettingVariable
	require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "projectsDirectory").First(&setting).Error)
	require.Equal(t, customPath, setting.Value, "should not change custom paths")
}

func TestSettingsService_NormalizeProjectsDirectory_HandlesNotFound(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Don't create the setting at all

	// Run normalization - should not error
	err = svc.NormalizeProjectsDirectory(ctx, "")
	require.NoError(t, err)
}

func TestSettingsService_NormalizeProjectsDirectory_UpdatesCacheAfterNormalization(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))

	// Set to relative path
	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", "data/projects"))
	require.NoError(t, svc.LoadDatabaseSettings(ctx))

	// Verify cache has relative path
	cfg1 := svc.GetSettingsConfig()
	require.Equal(t, "data/projects", cfg1.ProjectsDirectory.Value)

	// Run normalization
	err = svc.NormalizeProjectsDirectory(ctx, "")
	require.NoError(t, err)

	// Verify cache was updated to absolute path
	cfg2 := svc.GetSettingsConfig()
	expectedPath, _ := filepath.Abs("data/projects")
	require.Equal(t, expectedPath, cfg2.ProjectsDirectory.Value)
	require.True(t, filepath.IsAbs(cfg2.ProjectsDirectory.Value), "path should be absolute")
}

func TestSettingsService_NormalizeProjectsDirectoryPublishesChange(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, svc.EnsureDefaultSettings(ctx))
	require.NoError(t, svc.UpdateSetting(ctx, "projectsDirectory", "data/projects"))

	notified := make(chan []libarcane.SettingUpdate, 1)
	unsubscribe := svc.SubscribeSettingsChanges([]string{"projectsDirectory"}, func(updates []libarcane.SettingUpdate) {
		notified <- updates
	})
	defer unsubscribe()

	require.NoError(t, svc.NormalizeProjectsDirectory(ctx, ""))
	waitForSettingsNotifications(t, svc)
	updates := <-notified
	require.Len(t, updates, 1)
	require.Equal(t, "projectsDirectory", updates[0].Key)
	require.True(t, filepath.IsAbs(updates[0].Value))
}

// TestSettingsServiceEffectiveSnapshotMaterialized verifies reads share one env-override-applied
// snapshot per refresh, and an update rebuilds it with the override still applied.
func TestSettingsServiceEffectiveSnapshotMaterialized(t *testing.T) {
	ctx := t.Context()
	t.Setenv("PROJECTS_DIRECTORY", "/env/projects")

	db := setupSettingsTestDB(t)
	require.NoError(t, db.Create(&SettingVariable{Key: "projectsDirectory", Value: "/db/projects"}).Error)
	require.NoError(t, db.Create(&SettingVariable{Key: "baseServerUrl", Value: "http://before.example"}).Error)

	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// Env override beats the database value on the effective snapshot.
	require.Equal(t, "/env/projects", svc.GetStringSetting(ctx, "projectsDirectory", ""))

	// Reads share the materialized snapshot instead of cloning per call.
	first, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	again, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Same(t, first, again)

	// A settings update rebuilds the snapshot: the new value is visible and
	// the env override is still applied.
	require.NoError(t, svc.UpdateSetting(ctx, "baseServerUrl", "http://after.example"))
	require.Equal(t, "http://after.example", svc.GetStringSetting(ctx, "baseServerUrl", ""))
	require.Equal(t, "/env/projects", svc.GetStringSetting(ctx, "projectsDirectory", ""))

	refreshed, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.NotSame(t, first, refreshed)
}

func TestSettingsService_FeatureDefaultsAndUnknownFeature(t *testing.T) {
	var svc *SettingsService
	require.True(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
	require.NoError(t, svc.RequireFeature(t.Context(), features.VulnerabilityManagement))
	require.False(t, svc.IsFeatureEnabled(t.Context(), features.ID("unknown")))

	svc, err := newSettingsServiceForTest(t, t.Context(), setupSettingsTestDB(t))
	require.NoError(t, err)
	require.True(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
	require.NoError(t, svc.EnsureDefaultSettings(t.Context()))
	var stored SettingVariable
	require.NoError(t, svc.db.Where("key = ?", features.VulnerabilityManagementSettingKey).First(&stored).Error)
	require.Equal(t, "true", stored.Value)
	require.Contains(t, svc.ListSettings(SettingVisibilityPublic), SettingVariable{Key: features.VulnerabilityManagementSettingKey, Value: "true"})
}

func TestSettingsService_FeaturePersistenceAndEnvironmentIsolation(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	other, err := newSettingsServiceForTest(t, ctx, setupSettingsTestDB(t))
	require.NoError(t, err)

	var notifications int
	unsubscribe := svc.SubscribeSettingsChanges([]string{features.VulnerabilityManagementSettingKey}, func([]libarcane.SettingUpdate) { notifications++ })
	defer unsubscribe()
	scheduled := "true"
	ignore := "CVE-2026-12345"
	require.NoError(t, svc.UpdateSetting(ctx, "trivyIgnore", ignore))
	_, err = svc.UpdateSettings(ctx, settings.Update{VulnerabilityScanEnabled: &scheduled})
	require.NoError(t, err)
	disabled := "false"
	_, err = svc.UpdateSettings(ctx, settings.Update{FeatureVulnerabilityManagementEnabled: &disabled})
	require.NoError(t, err)
	waitForSettingsNotifications(t, svc)
	require.Equal(t, 1, notifications)
	require.False(t, svc.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
	require.True(t, other.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
	err = svc.RequireFeature(ctx, features.VulnerabilityManagement)
	require.ErrorIs(t, err, common.ErrFeatureDisabled)
	require.ErrorIs(t, err, common.ErrForbidden)
	require.Contains(t, err.Error(), string(features.VulnerabilityManagement))
	apiErr := common.ToAPIError(err)
	require.Equal(t, http.StatusForbidden, apiErr.HTTPStatus())
	require.Equal(t, common.APIErrorCodeFeatureDisabled, apiErr.Code)

	reloaded, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.False(t, reloaded.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
	enabled := "true"
	_, err = svc.UpdateSettings(ctx, settings.Update{FeatureVulnerabilityManagementEnabled: &enabled})
	require.NoError(t, err)
	require.True(t, svc.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
	cfg, err := svc.GetSettings(ctx)
	require.NoError(t, err)
	require.Equal(t, scheduled, cfg.VulnerabilityScanEnabled.Value)
	require.Equal(t, ignore, cfg.TrivyIgnore.Value)
}

func TestSettingsService_FeatureEnvironmentOverride(t *testing.T) {
	t.Setenv("FEATURE_VULNERABILITY_MANAGEMENT_ENABLED", "false")
	svc, err := newSettingsServiceForTest(t, t.Context(), setupSettingsTestDB(t))
	require.NoError(t, err)
	enabled := "true"
	_, err = svc.UpdateSettings(t.Context(), settings.Update{FeatureVulnerabilityManagementEnabled: &enabled})
	require.NoError(t, err)
	require.True(t, svc.IsEnvOverrideActive(features.VulnerabilityManagementSettingKey))
	require.False(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
	require.Contains(t, svc.ListSettings(SettingVisibilityPublic), SettingVariable{Key: features.VulnerabilityManagementSettingKey, Value: "false"})
}

func TestSettingsService_RejectInvalidFeatureBoolean(t *testing.T) {
	for _, invalid := range []string{"", "yes", "0", "TRUE"} {
		t.Run(invalid, func(t *testing.T) {
			svc, err := newSettingsServiceForTest(t, t.Context(), setupSettingsTestDB(t))
			require.NoError(t, err)
			_, err = svc.UpdateSettings(t.Context(), settings.Update{FeatureVulnerabilityManagementEnabled: &invalid})
			require.ErrorIs(t, err, common.ErrValidation)
			err = svc.UpdateSetting(t.Context(), features.VulnerabilityManagementSettingKey, invalid)
			require.ErrorIs(t, err, common.ErrValidation)
			err = svc.UpdateSettingValues(t.Context(), []libarcane.SettingUpdate{{Key: features.VulnerabilityManagementSettingKey, Value: invalid}})
			require.ErrorIs(t, err, common.ErrValidation)
			require.True(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
		})
	}
}

func TestSettingsService_SwarmFeatureDefaultsOffAndPersists(t *testing.T) {
	var nilService *SettingsService
	require.False(t, nilService.IsFeatureEnabled(t.Context(), features.Swarm))

	svc, err := newSettingsServiceForTest(t, t.Context(), setupSettingsTestDB(t))
	require.NoError(t, err)
	require.False(t, svc.IsFeatureEnabled(t.Context(), features.Swarm))
	require.Contains(t, svc.ListSettings(SettingVisibilityPublic), SettingVariable{Key: features.SwarmSettingKey, Value: "false"})

	enabled := "true"
	_, err = svc.UpdateSettings(t.Context(), settings.Update{FeatureSwarmEnabled: &enabled})
	require.NoError(t, err)
	require.True(t, svc.IsFeatureEnabled(t.Context(), features.Swarm))

	invalid := "yes"
	_, err = svc.UpdateSettings(t.Context(), settings.Update{FeatureSwarmEnabled: &invalid})
	require.ErrorIs(t, err, common.ErrValidation)
}

func TestSettingsServiceEncryptsSensitiveSettingsAtRest(t *testing.T) {
	t.Setenv("DEPOT_TOKEN", "")
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.UpdateSetting(ctx, "oidcClientSecret", "client-secret"))
	var stored SettingVariable
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "oidcClientSecret").First(&stored).Error)
	require.NotEqual(t, "client-secret", stored.Value)
	require.Equal(t, "client-secret", svc.GetSettingsConfig().OidcClientSecret.Value)

	hexToken := strings.Repeat("0123456789abcdef", 4)
	require.NoError(t, db.WithContext(ctx).Save(&SettingVariable{Key: "trivyServerToken", Value: "legacy-token"}).Error)
	require.NoError(t, db.WithContext(ctx).Save(&SettingVariable{Key: "depotToken", Value: hexToken}).Error)
	require.NoError(t, svc.EncryptStoredSensitiveSettings(ctx))
	var storedToken, storedHexToken SettingVariable
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "trivyServerToken").First(&storedToken).Error)
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "depotToken").First(&storedHexToken).Error)
	require.NotEqual(t, "legacy-token", storedToken.Value)
	require.NotEqual(t, hexToken, storedHexToken.Value)
	require.Equal(t, "legacy-token", svc.GetSettingsConfig().TrivyServerToken.Value)
	require.Equal(t, hexToken, svc.GetSettingsConfig().DepotToken.Value)

	var rerunClientSecret SettingVariable
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "oidcClientSecret").First(&rerunClientSecret).Error)
	require.Equal(t, stored.Value, rerunClientSecret.Value)
}

func TestSettingsServiceEncryptsStoredSensitiveSettingsOnlyOnce(t *testing.T) {
	ctx := t.Context()
	db := setupSettingsTestDB(t)
	svc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	require.NoError(t, svc.EncryptStoredSensitiveSettings(ctx))
	var marker SettingVariable
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "sensitiveSettingsEncrypted").First(&marker).Error)
	require.Equal(t, "true", marker.Value)

	otherKey, err := crypto.GenerateKey()
	require.NoError(t, err)
	otherEncryptor, err := crypto.New(otherKey)
	require.NoError(t, err)
	foreignCiphertext, err := otherEncryptor.Encrypt("secret-from-another-key")
	require.NoError(t, err)

	require.NoError(t, db.WithContext(ctx).Save(&SettingVariable{Key: "depotToken", Value: foreignCiphertext}).Error)
	require.NoError(t, svc.EncryptStoredSensitiveSettings(ctx))

	var stored SettingVariable
	require.NoError(t, db.WithContext(ctx).Where("key = ?", "depotToken").First(&stored).Error)
	require.Equal(t, foreignCiphertext, stored.Value)
}