Added tests for shutdown and fixed a failing case

Author: junaid2005p

cmd/lock_test.go

@@ -14,6 +14,7 @@ func TestAcquireLock(t *testing.T) {
 	// Setup isolation
 	tempDir := t.TempDir()
 	t.Setenv("XDG_CONFIG_HOME", tempDir)
+	t.Setenv("APPDATA", tempDir)
 
 	// Ensure dirs exist (mocking what root.go does)
 	err := config.EnsureDirs()

cmd/main_test.go

@@ -9,6 +9,7 @@ func TestMain(m *testing.M) {
 	tmpDir, err := os.MkdirTemp("", "surge-cmd-test-*")
 	if err == nil {
 		_ = os.Setenv("XDG_CONFIG_HOME", tmpDir)
+		_ = os.Setenv("APPDATA", tmpDir)
 	}
 
 	code := m.Run()

cmd/shutdown_test.go

@@ -0,0 +1,32 @@
+package cmd
+
+import (
+	"sync"
+	"sync/atomic"
+	"testing"
+)
+
+func TestExecuteGlobalShutdown_Once(t *testing.T) {
+	var calls int32
+	resetGlobalShutdownCoordinatorForTest(func() error {
+		atomic.AddInt32(&calls, 1)
+		return nil
+	})
+	t.Cleanup(func() { resetGlobalShutdownCoordinatorForTest(nil) })
+
+	var wg sync.WaitGroup
+	for i := 0; i < 8; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := executeGlobalShutdown("test"); err != nil {
+				t.Errorf("executeGlobalShutdown returned error: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if got := atomic.LoadInt32(&calls); got != 1 {
+		t.Fatalf("shutdown function calls = %d, want 1", got)
+	}
+}

internal/core/local_service_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/surge-downloader/surge/internal/engine/events"
 	"github.com/surge-downloader/surge/internal/engine/state"
 	"github.com/surge-downloader/surge/internal/engine/types"
+	"github.com/surge-downloader/surge/internal/testutil"
 )
 
 func TestLocalDownloadService_Delete_DBOnlyBroadcastsRemoved(t *testing.T) {
@@ -81,3 +82,113 @@ func TestLocalDownloadService_Delete_DBOnlyBroadcastsRemoved(t *testing.T) {
 		t.Fatalf("expected entry to be removed, got %+v", entry)
 	}
 }
+
+func TestLocalDownloadService_Shutdown_Idempotent(t *testing.T) {
+	ch := make(chan interface{}, 1)
+	svc := NewLocalDownloadServiceWithInput(nil, ch)
+
+	if err := svc.Shutdown(); err != nil {
+		t.Fatalf("first shutdown failed: %v", err)
+	}
+
+	select {
+	case _, ok := <-ch:
+		if ok {
+			t.Fatal("expected input channel to be closed after shutdown")
+		}
+	case <-time.After(500 * time.Millisecond):
+		t.Fatal("timed out waiting for input channel to close")
+	}
+
+	if err := svc.Shutdown(); err != nil {
+		t.Fatalf("second shutdown failed: %v", err)
+	}
+}
+
+func TestLocalDownloadService_Shutdown_PersistsPausedState(t *testing.T) {
+	tempDir := t.TempDir()
+	state.CloseDB()
+	state.Configure(filepath.Join(tempDir, "surge.db"))
+	defer state.CloseDB()
+
+	ch := make(chan interface{}, 100)
+	pool := download.NewWorkerPool(ch, 1)
+	svc := NewLocalDownloadServiceWithInput(pool, ch)
+	defer func() { _ = svc.Shutdown() }()
+
+	server := testutil.NewStreamingMockServerT(t,
+		500*1024*1024,
+		testutil.WithRangeSupport(true),
+		testutil.WithLatency(10*time.Millisecond),
+	)
+	defer server.Close()
+
+	outputDir := t.TempDir()
+	const filename = "persist.bin"
+	id, err := svc.Add(server.URL(), outputDir, filename, nil, nil)
+	if err != nil {
+		t.Fatalf("failed to add download: %v", err)
+	}
+
+	deadline := time.Now().Add(8 * time.Second)
+	progressed := false
+	for time.Now().Before(deadline) {
+		st, err := svc.GetStatus(id)
+		if err == nil && st != nil && st.Downloaded > 0 {
+			progressed = true
+			break
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	if !progressed {
+		t.Fatal("download did not make progress before shutdown")
+	}
+
+	if err := svc.Shutdown(); err != nil {
+		t.Fatalf("shutdown failed: %v", err)
+	}
+
+	entry, err := state.GetDownload(id)
+	if err != nil {
+		t.Fatalf("failed to fetch persisted download: %v", err)
+	}
+	if entry == nil {
+		t.Fatal("expected persisted download entry after shutdown")
+	}
+	if entry.Status != "paused" {
+		t.Fatalf("status = %q, want paused", entry.Status)
+	}
+	if entry.Downloaded == 0 {
+		t.Fatal("expected persisted paused download to have non-zero progress")
+	}
+
+	statuses, err := svc.List()
+	if err != nil {
+		t.Fatalf("failed to list downloads after shutdown: %v", err)
+	}
+	foundInList := false
+	for _, st := range statuses {
+		if st.ID == id {
+			foundInList = true
+			if st.Status != "paused" && st.Status != "pausing" {
+				t.Fatalf("list status = %q, want paused/pausing", st.Status)
+			}
+			break
+		}
+	}
+	if !foundInList {
+		t.Fatal("expected paused download to remain visible in list after shutdown")
+	}
+
+	destPath := filepath.Join(outputDir, filename)
+	saved, err := state.LoadState(server.URL(), destPath)
+	if err != nil {
+		t.Fatalf("failed to load saved state: %v", err)
+	}
+	if saved.ID != id {
+		t.Fatalf("saved state id = %q, want %q", saved.ID, id)
+	}
+	if len(saved.Tasks) == 0 {
+		t.Fatal("expected saved state to include remaining tasks")
+	}
+}