test: add unit and integration tests for scan settings

- Add unit tests for MediaScanner.GetPollInterval and GetAutoScanEnabled
- Add integration tests for scan-settings API endpoints
- Update validation test cases to use seconds (1-3600) instead of minutes
- Fix worker.go to use new NewMediaScanner signature

cmd/server/tests/scan_settings_integration_test.go

@@ -0,0 +1,179 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestScanSettings_GetSettings(t *testing.T) {
+	setup := setupTestServer(t)
+	defer setup.Close()
+
+	t.Run("Get settings as admin", func(t *testing.T) {
+		token := setup.Token
+
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/libraries/scan-settings", nil)
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var response map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&response)
+		resp.Body.Close()
+
+		assert.Contains(t, response, "scan_poll_interval_seconds")
+		assert.Contains(t, response, "auto_scan_enabled")
+		assert.Equal(t, float64(60), response["scan_poll_interval_seconds"])
+		assert.Equal(t, true, response["auto_scan_enabled"])
+	})
+}
+
+func TestScanSettings_UpdateSettings(t *testing.T) {
+	setup := setupTestServer(t)
+	defer setup.Close()
+
+	t.Run("Update scan_poll_interval_seconds", func(t *testing.T) {
+		token := setup.Token
+
+		updateReq := map[string]interface{}{
+			"scan_poll_interval_seconds": 45,
+			"auto_scan_enabled":          true,
+		}
+		body, _ := json.Marshal(updateReq)
+
+		req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/libraries/scan-settings", bytes.NewBuffer(body))
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var response map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&response)
+		resp.Body.Close()
+
+		assert.Equal(t, float64(45), response["scan_poll_interval_seconds"])
+		assert.Equal(t, true, response["auto_scan_enabled"])
+
+		getReq, _ := http.NewRequest("GET", setup.Server.URL+"/api/libraries/scan-settings", nil)
+		getReq.Header.Set("Authorization", "Bearer "+token)
+		getResp, _ := client.Do(getReq)
+
+		var getResponse map[string]interface{}
+		json.NewDecoder(getResp.Body).Decode(&getResponse)
+		getResp.Body.Close()
+
+		assert.Equal(t, float64(45), getResponse["scan_poll_interval_seconds"])
+	})
+
+	t.Run("Update auto_scan_enabled to false", func(t *testing.T) {
+		token := setup.Token
+
+		updateReq := map[string]interface{}{
+			"scan_poll_interval_seconds": 30,
+			"auto_scan_enabled":          false,
+		}
+		body, _ := json.Marshal(updateReq)
+
+		req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/libraries/scan-settings", bytes.NewBuffer(body))
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var response map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&response)
+		resp.Body.Close()
+
+		assert.Equal(t, false, response["auto_scan_enabled"])
+	})
+
+	t.Run("Validation rejects values below minimum", func(t *testing.T) {
+		token := setup.Token
+
+		updateReq := map[string]interface{}{
+			"scan_poll_interval_seconds": 0,
+			"auto_scan_enabled":          true,
+		}
+		body, _ := json.Marshal(updateReq)
+
+		req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/libraries/scan-settings", bytes.NewBuffer(body))
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+
+	t.Run("Validation rejects values above maximum", func(t *testing.T) {
+		token := setup.Token
+
+		updateReq := map[string]interface{}{
+			"scan_poll_interval_seconds": 4000,
+			"auto_scan_enabled":          true,
+		}
+		body, _ := json.Marshal(updateReq)
+
+		req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/libraries/scan-settings", bytes.NewBuffer(body))
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+}
+
+func TestScanSettings_RequireAdmin(t *testing.T) {
+	setup := setupTestServer(t)
+	defer setup.Close()
+
+	t.Run("Get settings without auth returns 401", func(t *testing.T) {
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/libraries/scan-settings", nil)
+		client := &http.Client{}
+		resp, _ := client.Do(req)
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})
+
+	t.Run("Get settings as non-admin returns 403", func(t *testing.T) {
+		token := setup.RegularToken
+
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/libraries/scan-settings", nil)
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, _ := client.Do(req)
+		assert.Equal(t, http.StatusForbidden, resp.StatusCode)
+	})
+
+	t.Run("Update settings without auth returns 401", func(t *testing.T) {
+		updateReq := map[string]interface{}{
+			"scan_poll_interval_seconds": 30,
+			"auto_scan_enabled":          true,
+		}
+		body, _ := json.Marshal(updateReq)
+
+		req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/libraries/scan-settings", bytes.NewBuffer(body))
+		req.Header.Set("Content-Type", "application/json")
+
+		client := &http.Client{}
+		resp, _ := client.Do(req)
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})
+}

cmd/server/tests/system_settings_test.go

@@ -91,9 +91,8 @@ func TestSystemSettingsHandler(t *testing.T) {
 			name                    string
 			ScanPollIntervalSeconds int
 		}{
-			{"Frequency too low (14 minutes)", 14},
+			{"Frequency too low (0 seconds)", 0},
-			{"Frequency too high (1441 minutes)", 1441},
+			{"Frequency too high (3601 seconds)", 3601},
-			{"Frequency too low (0 minutes)", 0},
 			{"Frequency negative (-10)", -10},
 		}
 
@@ -141,11 +140,11 @@ func TestSystemSettingsHandler(t *testing.T) {
 			ScanPollIntervalSeconds int
 			autoScanEnabled         bool
 		}{
-			{"Valid frequency (15 minutes)", 15, true},
+			{"Valid frequency (1 second)", 1, true},
-			{"Valid frequency (60 minutes)", 60, true},
+			{"Valid frequency (60 seconds)", 60, true},
-			{"Valid frequency (1440 minutes)", 1440, true},
+			{"Valid frequency (3600 seconds)", 3600, true},
-			{"Valid frequency (120 minutes)", 120, false},
+			{"Valid frequency (30 seconds)", 30, false},
-			{"Valid frequency (30 minutes)", 30, true},
+			{"Valid frequency (300 seconds)", 300, true},
 		}
 
 		for _, tc := range testCases {
@@ -210,15 +209,15 @@ func TestSystemSettingsIntegration(t *testing.T) {
 	})
 
 	t.Run("Valid frequency range enforcement", func(t *testing.T) {
-		validFrequencies := []int{15, 30, 60, 120, 240, 480, 720, 1440}
+		validFrequencies := []int{1, 30, 60, 300, 600, 1800, 3600}
-		invalidFrequencies := []int{0, 1, 14, 1441, 2000}
+		invalidFrequencies := []int{0, -1, 3601, 5000}
 
 		for _, freq := range validFrequencies {
-			assert.True(t, freq >= 15 && freq <= 1440, "Frequency %d should be valid", freq)
+			assert.True(t, freq >= 1 && freq <= 3600, "Frequency %d should be valid", freq)
 		}
 
 		for _, freq := range invalidFrequencies {
-			assert.False(t, freq >= 15 && freq <= 1440, "Frequency %d should be invalid", freq)
+			assert.False(t, freq >= 1 && freq <= 3600, "Frequency %d should be invalid", freq)
 		}
 	})
 }

internal/services/media_scanner_settings_test.go

@@ -0,0 +1,26 @@
+package services
+
+import (
+	"testing"
+	"time"
+)
+
+func TestMediaScanner_GetPollInterval(t *testing.T) {
+	t.Run("nil db returns default", func(t *testing.T) {
+		scanner := &MediaScanner{db: nil}
+		interval := scanner.GetPollInterval()
+		if interval != 30*time.Second {
+			t.Errorf("expected 30s, got %v", interval)
+		}
+	})
+}
+
+func TestMediaScanner_GetAutoScanEnabled(t *testing.T) {
+	t.Run("nil db returns default true", func(t *testing.T) {
+		scanner := &MediaScanner{db: nil}
+		enabled := scanner.GetAutoScanEnabled()
+		if enabled != true {
+			t.Errorf("expected true, got %v", enabled)
+		}
+	})
+}

internal/services/worker.go

@@ -199,7 +199,7 @@ func (w *Worker) processScanJob(job *Job) (interface{}, error) {
 		force = forceVal
 	}
 
-	scanner := NewMediaScanner(db, 0)
+	scanner := NewMediaScanner(db)
 	scanner.job = job
 
 	job.ProgressCallback = func(progress float64, filesScanned, newItems, errors int) {