diff --git a/internal/protocol/http/fetcher_test.go b/internal/protocol/http/fetcher_test.go index c709c46e..cf6575cd 100644 --- a/internal/protocol/http/fetcher_test.go +++ b/internal/protocol/http/fetcher_test.go @@ -114,45 +114,58 @@ func TestFetcher_Resolve(t *testing.T) { }, }, t) + // Test URL without file path - should use domain/host as filename + listener := test.StartTestRootServer() + defer listener.Close() fetcher := buildFetcher() err := fetcher.Resolve(&base.Request{ - URL: "http://github.com", + URL: "http://" + listener.Addr().String() + "/", }) if err != nil { t.Fatal(err) } - if fetcher.Meta().Res.Files[0].Name != "github.com" { - t.Errorf("Resolve() got = %v, want %v", fetcher.Meta().Res, "github.com") + // When no filename is provided, it should use the hostname (without port) as the name + expectedName := "127.0.0.1" + if fetcher.Meta().Res.Files[0].Name != expectedName { + t.Errorf("Resolve() got name = %v, want %v", fetcher.Meta().Res.Files[0].Name, expectedName) } } func TestFetcher_ResolveWithHostHeader(t *testing.T) { + listener := test.StartTestHostHeaderServer() + defer listener.Close() + fetcher := buildFetcher() err := fetcher.Resolve(&base.Request{ - URL: "https://bing.com", + URL: "http://" + listener.Addr().String() + "/", Extra: &http.ReqExtra{ Header: map[string]string{ "Host": "test", }, }, }) + // The server should return 400 for invalid Host header if err == nil || !strings.Contains(err.Error(), "400") { - t.Errorf("Resolve() got = %v, want %v", err, "400") + t.Errorf("Resolve() got = %v, want error containing 400", err) } } func TestFetcher_ResolveWithInvalidHeader(t *testing.T) { + listener := test.StartTestRootServer() + defer listener.Close() + fetcher := buildFetcher() err := fetcher.Resolve(&base.Request{ - URL: "https://bing.com", + URL: "http://" + listener.Addr().String() + "/", Extra: &http.ReqExtra{ Header: map[string]string{ "Referer": "\rtest", }, }, }) + // Invalid header with \r should be sanitized by Go's http client, allowing the request to succeed if err != nil { - t.Errorf("Resolve() got = %v, want nil", err) + t.Errorf("Resolve() got = %v, want nil (invalid headers should be sanitized)", err) } } diff --git a/internal/test/httptest.go b/internal/test/httptest.go index 36467851..4c5c90d8 100644 --- a/internal/test/httptest.go +++ b/internal/test/httptest.go @@ -173,6 +173,39 @@ func StartTestCustomServer() net.Listener { }) } +// StartTestHostHeaderServer starts a server that validates the Host header +// Returns 400 Bad Request if the Host header value equals "test" +func StartTestHostHeaderServer() net.Listener { + return startTestServer(func(sl *shutdownListener) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) { + // If the Host header is "test", return 400 (simulating server that validates Host) + if request.Host == "test" { + writer.WriteHeader(400) + writer.Write([]byte("Bad Request: Invalid Host header")) + return + } + writer.WriteHeader(200) + writer.Write([]byte("OK")) + }) + return mux + }) +} + +// StartTestRootServer starts a simple server at the root path +// Used to test URL resolution when no filename is provided +func StartTestRootServer() net.Listener { + return startTestServer(func(sl *shutdownListener) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) { + writer.Header().Set("Content-Type", "text/html") + writer.WriteHeader(200) + writer.Write([]byte("Test Page")) + }) + return mux + }) +} + func StartTestRetryServer() net.Listener { counter := 0 return startTestServer(func(sl *shutdownListener) http.Handler { diff --git a/pkg/download/downloader.go b/pkg/download/downloader.go index cba7ee1b..41e345b9 100644 --- a/pkg/download/downloader.go +++ b/pkg/download/downloader.go @@ -45,6 +45,20 @@ var ( type Listener func(event *Event) +// ExtractStatus represents the current status of archive extraction +type ExtractStatus string + +const ( + // ExtractStatusNone indicates extraction has not started + ExtractStatusNone ExtractStatus = "" + // ExtractStatusExtracting indicates extraction is in progress + ExtractStatusExtracting ExtractStatus = "extracting" + // ExtractStatusDone indicates extraction completed successfully + ExtractStatusDone ExtractStatus = "done" + // ExtractStatusError indicates extraction failed + ExtractStatusError ExtractStatus = "error" +) + type Progress struct { // Total download time(ns) Used int64 `json:"used"` @@ -56,6 +70,10 @@ type Progress struct { UploadSpeed int64 `json:"uploadSpeed"` // Uploaded size(bytes) Uploaded int64 `json:"uploaded"` + // ExtractStatus indicates the current status of archive extraction + ExtractStatus ExtractStatus `json:"extractStatus"` + // ExtractProgress is the percentage of extraction completed (0-100) + ExtractProgress int `json:"extractProgress"` } type Downloader struct { @@ -881,13 +899,29 @@ func (d *Downloader) watch(task *Task) { // Auto-extract archive files if e.AutoExtract && isArchiveFile(downloadFilePath) { go func() { + // Set extraction status to extracting + task.Progress.ExtractStatus = ExtractStatusExtracting + task.Progress.ExtractProgress = 0 + d.emit(EventKeyProgress, task) + d.storage.Put(bucketTask, task.ID, task.clone()) + // Extract to the same directory as the downloaded file destDir := task.Meta.Opts.Path - extractErr := extractArchive(downloadFilePath, destDir, e.ArchivePassword) + extractErr := extractArchive(downloadFilePath, destDir, e.ArchivePassword, func(extractedFiles int, totalFiles int, progress int) { + task.Progress.ExtractProgress = progress + d.emit(EventKeyProgress, task) + }) if extractErr != nil { d.Logger.Error().Err(extractErr).Msgf("auto extract archive failed, task id: %s", task.ID) + task.Progress.ExtractStatus = ExtractStatusError + d.emit(EventKeyProgress, task) + d.storage.Put(bucketTask, task.ID, task.clone()) } else { d.Logger.Info().Msgf("auto extract archive completed, task id: %s", task.ID) + task.Progress.ExtractStatus = ExtractStatusDone + task.Progress.ExtractProgress = 100 + d.emit(EventKeyProgress, task) + d.storage.Put(bucketTask, task.ID, task.clone()) // Delete archive after successful extraction if enabled if e.DeleteAfterExtract { deleteErr := os.Remove(downloadFilePath) diff --git a/pkg/download/downloader_test.go b/pkg/download/downloader_test.go index 75b1b067..0c36010d 100644 --- a/pkg/download/downloader_test.go +++ b/pkg/download/downloader_test.go @@ -1,15 +1,20 @@ package download import ( - "github.com/GopeedLab/gopeed/internal/test" - "github.com/GopeedLab/gopeed/pkg/base" - "github.com/GopeedLab/gopeed/pkg/protocol/http" + "archive/zip" + "io" + gohttp "net/http" + "net" "os" "strconv" "strings" "sync" "testing" "time" + + "github.com/GopeedLab/gopeed/internal/test" + "github.com/GopeedLab/gopeed/pkg/base" + "github.com/GopeedLab/gopeed/pkg/protocol/http" ) func TestDownloader_Resolve(t *testing.T) { @@ -643,3 +648,1065 @@ func TestDownloader_GetTasksByFilter(t *testing.T) { }) } + +func TestDownloader_Stats(t *testing.T) { + listener := test.StartTestFileServer() + defer listener.Close() + + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Test Stats for non-existent task + _, err := downloader.Stats("non-existent-id") + if err != ErrTaskNotFound { + t.Errorf("Stats() expected ErrTaskNotFound, got %v", err) + } + + // Create a task + req := &base.Request{ + URL: "http://" + listener.Addr().String() + "/" + test.BuildName, + } + rr, err := downloader.Resolve(req) + if err != nil { + t.Fatal(err) + } + + var wg sync.WaitGroup + wg.Add(1) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone { + wg.Done() + } + }) + + taskId, err := downloader.Create(rr.ID, &base.Options{ + Path: test.Dir, + Name: test.DownloadName, + Extra: http.OptsExtra{ + Connections: 4, + }, + }) + if err != nil { + t.Fatal(err) + } + + wg.Wait() + + // Test Stats for existing task + stats, err := downloader.Stats(taskId) + if err != nil { + t.Errorf("Stats() unexpected error: %v", err) + } + if stats == nil { + t.Error("Stats() returned nil stats") + } +} + +func TestDownloader_Delete(t *testing.T) { + listener := test.StartTestFileServer() + defer listener.Close() + + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Create multiple tasks + var wg sync.WaitGroup + taskCount := 3 + wg.Add(taskCount) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone { + wg.Done() + } + }) + + taskIds := make([]string, 0) + for i := 0; i < taskCount; i++ { + req := &base.Request{ + URL: "http://" + listener.Addr().String() + "/" + test.BuildName, + } + taskId, err := downloader.CreateDirect(req, &base.Options{ + Path: test.Dir, + Name: test.DownloadName, + Extra: http.OptsExtra{ + Connections: 4, + }, + }) + if err != nil { + t.Fatal(err) + } + taskIds = append(taskIds, taskId) + } + + wg.Wait() + + // Test Delete with filter (single task) + t.Run("Delete single task by ID", func(t *testing.T) { + initialCount := len(downloader.GetTasks()) + err := downloader.Delete(&TaskFilter{IDs: []string{taskIds[0]}}, true) + if err != nil { + t.Errorf("Delete() unexpected error: %v", err) + } + newCount := len(downloader.GetTasks()) + if newCount != initialCount-1 { + t.Errorf("Delete() task count got = %v, want %v", newCount, initialCount-1) + } + }) + + // Test Delete with non-matching filter (should do nothing) + t.Run("Delete with non-matching filter", func(t *testing.T) { + initialCount := len(downloader.GetTasks()) + err := downloader.Delete(&TaskFilter{IDs: []string{"non-existent-id"}}, true) + if err != nil { + t.Errorf("Delete() unexpected error: %v", err) + } + newCount := len(downloader.GetTasks()) + if newCount != initialCount { + t.Errorf("Delete() task count got = %v, want %v", newCount, initialCount) + } + }) + + // Test Delete by status + t.Run("Delete by status", func(t *testing.T) { + initialCount := len(downloader.GetTasks()) + err := downloader.Delete(&TaskFilter{Statuses: []base.Status{base.DownloadStatusDone}}, false) + if err != nil { + t.Errorf("Delete() unexpected error: %v", err) + } + newCount := len(downloader.GetTasks()) + if newCount != 0 { + t.Errorf("Delete() should have deleted all done tasks, got %v remaining", newCount) + } + _ = initialCount // suppress unused variable warning + }) +} + +func TestDownloader_ContinueBatch(t *testing.T) { + listener := test.StartTestSlowFileServer(time.Millisecond * 2000) + defer listener.Close() + + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Create multiple tasks and pause them + taskCount := 3 + taskIds := make([]string, 0) + + for i := 0; i < taskCount; i++ { + req := &base.Request{ + URL: "http://" + listener.Addr().String() + "/" + test.BuildName, + } + rr, err := downloader.Resolve(req) + if err != nil { + t.Fatal(err) + } + taskId, err := downloader.Create(rr.ID, &base.Options{ + Path: test.Dir, + Name: test.DownloadName, + Extra: http.OptsExtra{ + Connections: 4, + }, + }) + if err != nil { + t.Fatal(err) + } + taskIds = append(taskIds, taskId) + } + + // Wait a moment for tasks to start + time.Sleep(time.Millisecond * 500) + + // Pause all tasks + err := downloader.Pause(nil) + if err != nil { + t.Fatal(err) + } + + // Verify tasks are paused + for _, taskId := range taskIds { + task := downloader.GetTask(taskId) + if task.Status != base.DownloadStatusPause && task.Status != base.DownloadStatusDone { + t.Errorf("Task %s should be paused or done, got %s", taskId, task.Status) + } + } + + // Test ContinueBatch with specific IDs + t.Run("ContinueBatch with filter", func(t *testing.T) { + var wg sync.WaitGroup + wg.Add(1) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone { + wg.Done() + } + }) + + err := downloader.ContinueBatch(&TaskFilter{IDs: []string{taskIds[0]}}) + if err != nil { + t.Errorf("ContinueBatch() unexpected error: %v", err) + } + wg.Wait() + }) + + // Test ContinueBatch with nil filter (continues all) + t.Run("ContinueBatch with nil filter", func(t *testing.T) { + var wg sync.WaitGroup + // Count remaining paused tasks + pausedCount := 0 + for _, taskId := range taskIds { + task := downloader.GetTask(taskId) + if task.Status == base.DownloadStatusPause { + pausedCount++ + } + } + wg.Add(pausedCount) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone { + wg.Done() + } + }) + + err := downloader.ContinueBatch(nil) + if err != nil { + t.Errorf("ContinueBatch() unexpected error: %v", err) + } + if pausedCount > 0 { + wg.Wait() + } + }) + + // Clean up + downloader.Delete(nil, true) +} + +func TestDownloader_PauseAndContinue(t *testing.T) { + listener := test.StartTestSlowFileServer(time.Millisecond * 5000) + defer listener.Close() + + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + req := &base.Request{ + URL: "http://" + listener.Addr().String() + "/" + test.BuildName, + } + rr, err := downloader.Resolve(req) + if err != nil { + t.Fatal(err) + } + + taskId, err := downloader.Create(rr.ID, &base.Options{ + Path: test.Dir, + Name: test.DownloadName, + Extra: http.OptsExtra{ + Connections: 4, + }, + }) + if err != nil { + t.Fatal(err) + } + + // Wait for task to start + time.Sleep(time.Millisecond * 1000) + + // Test Pause with empty filter (returns nil, not error - empty filter means no op) + t.Run("Pause with empty filter", func(t *testing.T) { + err := downloader.Pause(&TaskFilter{}) + // Empty filter returns error from Pause function + if err == nil { + // This is fine - different implementations might handle this differently + } + }) + + // Test Pause with filter + t.Run("Pause with filter", func(t *testing.T) { + task := downloader.GetTask(taskId) + if task == nil { + t.Skip("Task already completed") + } + if task.Status == base.DownloadStatusDone { + t.Skip("Task already completed") + } + + err := downloader.Pause(&TaskFilter{IDs: []string{taskId}}) + if err != nil { + // Task might have finished between check and pause + t.Logf("Pause() error (task may have finished): %v", err) + } else { + task = downloader.GetTask(taskId) + if task.Status != base.DownloadStatusPause && task.Status != base.DownloadStatusDone { + t.Errorf("Task should be paused or done, got %s", task.Status) + } + } + }) + + // Test Pause with non-matching filter + t.Run("Pause with non-matching filter", func(t *testing.T) { + err := downloader.Pause(&TaskFilter{IDs: []string{"non-existent-id"}}) + if err == nil { + t.Error("Pause() with non-matching filter should return error") + } + }) + + // Test Continue with empty filter (returns error - empty filter means no op) + t.Run("Continue with empty filter", func(t *testing.T) { + err := downloader.Continue(&TaskFilter{}) + // Empty filter returns error from Continue function + if err == nil { + // This is fine - different implementations might handle this differently + } + }) + + // Test Continue with non-matching filter + t.Run("Continue with non-matching filter", func(t *testing.T) { + err := downloader.Continue(&TaskFilter{IDs: []string{"non-existent-id"}}) + if err == nil { + t.Error("Continue() with non-matching filter should return error") + } + }) + + // Test Continue with valid filter + t.Run("Continue with valid filter", func(t *testing.T) { + task := downloader.GetTask(taskId) + if task == nil { + t.Skip("Task not found") + } + if task.Status == base.DownloadStatusDone { + t.Skip("Task already completed") + } + + var wg sync.WaitGroup + wg.Add(1) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone && event.Task != nil && event.Task.ID == taskId { + wg.Done() + } + }) + + err := downloader.Continue(&TaskFilter{IDs: []string{taskId}}) + if err != nil { + // Task might have finished or not be in pausable state + t.Logf("Continue() note: %v", err) + } + wg.Wait() + + task = downloader.GetTask(taskId) + if task != nil && task.Status != base.DownloadStatusDone { + t.Errorf("Task should be done, got %s", task.Status) + } + }) + + // Clean up + downloader.Delete(nil, true) +} + +func TestDownloader_GetTask(t *testing.T) { + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Test GetTask for non-existent task + task := downloader.GetTask("non-existent-id") + if task != nil { + t.Errorf("GetTask() expected nil for non-existent task, got %v", task) + } +} + +func TestDownloader_Emit(t *testing.T) { + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Test emit with no listener (should not panic) + downloader.emit(EventKeyDone, nil) + + // Test emit with listener + eventReceived := false + downloader.Listener(func(event *Event) { + eventReceived = true + }) + downloader.emit(EventKeyDone, nil) + if !eventReceived { + t.Error("Event should have been received by listener") + } +} + +func TestDownloader_AutoExtract(t *testing.T) { + // Create a temporary directory for extraction tests + tempDir, err := os.MkdirTemp("", "downloader_extract_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a test zip file + zipPath := tempDir + "/test_archive.zip" + if err := createTestArchive(zipPath); err != nil { + t.Fatal(err) + } + + // Verify isArchiveFile works correctly + t.Run("isArchiveFile", func(t *testing.T) { + if !isArchiveFile(zipPath) { + t.Error("isArchiveFile should return true for .zip file") + } + if isArchiveFile(tempDir + "/test.txt") { + t.Error("isArchiveFile should return false for .txt file") + } + }) +} + +// TestDownloader_AutoExtractWithProgress tests the auto-extract functionality with progress tracking +// This test exercises the ExtractStatus and ExtractProgress fields in the Progress struct +func TestDownloader_AutoExtractWithProgress(t *testing.T) { + // Create a temporary directory for the test + tempDir, err := os.MkdirTemp("", "auto_extract_progress_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a test zip file to serve + zipPath := tempDir + "/archive.zip" + if err := createTestArchiveWithMultipleFiles(zipPath, 3); err != nil { + t.Fatal(err) + } + + // Start a simple HTTP server to serve the zip file + server := startTestArchiveServer(zipPath) + defer server.Close() + + // Create downloader + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Track extraction status changes + var extractStatusChanges []ExtractStatus + var extractProgressValues []int + var statusMutex sync.Mutex + extractDoneCh := make(chan struct{}) + var extractDoneOnce sync.Once + + downloader.Listener(func(event *Event) { + if event.Key == EventKeyProgress && event.Task != nil && event.Task.Progress != nil { + statusMutex.Lock() + status := event.Task.Progress.ExtractStatus + progress := event.Task.Progress.ExtractProgress + // Record status changes + if status != ExtractStatusNone { + if len(extractStatusChanges) == 0 || extractStatusChanges[len(extractStatusChanges)-1] != status { + extractStatusChanges = append(extractStatusChanges, status) + } + extractProgressValues = append(extractProgressValues, progress) + } + statusMutex.Unlock() + // Signal when extraction is done or errored + if status == ExtractStatusDone || status == ExtractStatusError { + extractDoneOnce.Do(func() { + close(extractDoneCh) + }) + } + } + }) + + // Create request to download the zip file + req := &base.Request{ + URL: "http://" + server.Addr().String() + "/archive.zip", + } + + // Create task with AutoExtract enabled + downloadDir := tempDir + "/downloads" + taskId, err := downloader.CreateDirect(req, &base.Options{ + Path: downloadDir, + Name: "archive.zip", + Extra: http.OptsExtra{ + Connections: 1, + AutoExtract: true, + }, + }) + if err != nil { + t.Fatal(err) + } + + // Wait for extraction to complete (with timeout) + select { + case <-extractDoneCh: + // Extraction completed + case <-time.After(30 * time.Second): + t.Log("Extraction timed out, checking results anyway") + } + + // Give a small buffer for final events to be processed + time.Sleep(100 * time.Millisecond) + + // Verify task exists + task := downloader.GetTask(taskId) + if task == nil { + t.Fatal("Task should exist") + } + + // Verify extraction status changes occurred + statusMutex.Lock() + defer statusMutex.Unlock() + + t.Logf("Recorded extract status changes: %v", extractStatusChanges) + t.Logf("Recorded extract progress values: %v", extractProgressValues) + + // Verify that we went through ExtractStatusExtracting + foundExtracting := false + for _, status := range extractStatusChanges { + if status == ExtractStatusExtracting { + foundExtracting = true + break + } + } + if !foundExtracting { + t.Error("Expected ExtractStatusExtracting in status changes") + } + + // Verify that we reached ExtractStatusDone + foundDone := false + for _, status := range extractStatusChanges { + if status == ExtractStatusDone { + foundDone = true + break + } + } + if !foundDone { + t.Error("Expected ExtractStatusDone in status changes") + } + + // Verify progress values include 100 (final) + found100 := false + for _, p := range extractProgressValues { + if p == 100 { + found100 = true + break + } + } + if !found100 { + t.Error("Expected progress to reach 100") + } + + // Verify extracted files exist + extractedFile := downloadDir + "/test_0.txt" + if _, err := os.Stat(extractedFile); os.IsNotExist(err) { + t.Error("Expected extracted file to exist") + } +} + +// TestDownloader_AutoExtractWithDeleteAfterExtract tests the auto-extract with DeleteAfterExtract option +func TestDownloader_AutoExtractWithDeleteAfterExtract(t *testing.T) { + // Create a temporary directory for the test + tempDir, err := os.MkdirTemp("", "auto_extract_delete_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a test zip file to serve + zipPath := tempDir + "/archive.zip" + if err := createTestArchiveWithMultipleFiles(zipPath, 2); err != nil { + t.Fatal(err) + } + + // Start a simple HTTP server to serve the zip file + server := startTestArchiveServer(zipPath) + defer server.Close() + + // Create downloader + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Track extraction status changes + extractDoneCh := make(chan struct{}) + var extractDoneOnce sync.Once + + downloader.Listener(func(event *Event) { + if event.Key == EventKeyProgress && event.Task != nil && event.Task.Progress != nil { + status := event.Task.Progress.ExtractStatus + if status == ExtractStatusDone || status == ExtractStatusError { + extractDoneOnce.Do(func() { + close(extractDoneCh) + }) + } + } + }) + + // Create request to download the zip file + req := &base.Request{ + URL: "http://" + server.Addr().String() + "/archive.zip", + } + + // Create task with AutoExtract and DeleteAfterExtract enabled + downloadDir := tempDir + "/downloads" + _, err = downloader.CreateDirect(req, &base.Options{ + Path: downloadDir, + Name: "archive.zip", + Extra: http.OptsExtra{ + Connections: 1, + AutoExtract: true, + DeleteAfterExtract: true, + }, + }) + if err != nil { + t.Fatal(err) + } + + // Wait for extraction to complete (with timeout) + select { + case <-extractDoneCh: + // Extraction completed + case <-time.After(10 * time.Second): + t.Log("Extraction timed out") + } + + // Give time for file deletion + time.Sleep(200 * time.Millisecond) + + // Verify archive was deleted + archivePath := downloadDir + "/archive.zip" + if _, err := os.Stat(archivePath); !os.IsNotExist(err) { + t.Error("Expected archive to be deleted after extraction") + } + + // Verify extracted files exist + extractedFile := downloadDir + "/test_0.txt" + if _, err := os.Stat(extractedFile); os.IsNotExist(err) { + t.Error("Expected extracted file to exist") + } +} + +// TestDownloader_AutoExtractError tests the auto-extract error handling path +func TestDownloader_AutoExtractError(t *testing.T) { + // Create a temporary directory for the test + tempDir, err := os.MkdirTemp("", "auto_extract_error_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a corrupt zip file (just invalid data with .zip extension) + corruptZipPath := tempDir + "/corrupt.zip" + if err := os.WriteFile(corruptZipPath, []byte("this is not a valid zip file"), 0644); err != nil { + t.Fatal(err) + } + + // Start a simple HTTP server to serve the corrupt zip file + server := startTestArchiveServer(corruptZipPath) + defer server.Close() + + // Create downloader + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Track extraction status changes + var extractStatusChanges []ExtractStatus + var statusMutex sync.Mutex + extractDoneCh := make(chan struct{}) + var extractDoneOnce sync.Once + + downloader.Listener(func(event *Event) { + if event.Key == EventKeyProgress && event.Task != nil && event.Task.Progress != nil { + statusMutex.Lock() + status := event.Task.Progress.ExtractStatus + if status != ExtractStatusNone { + if len(extractStatusChanges) == 0 || extractStatusChanges[len(extractStatusChanges)-1] != status { + extractStatusChanges = append(extractStatusChanges, status) + } + } + statusMutex.Unlock() + if status == ExtractStatusDone || status == ExtractStatusError { + extractDoneOnce.Do(func() { + close(extractDoneCh) + }) + } + } + }) + + // Create request to download the corrupt zip file + req := &base.Request{ + URL: "http://" + server.Addr().String() + "/corrupt.zip", + } + + // Create task with AutoExtract enabled + downloadDir := tempDir + "/downloads" + _, err = downloader.CreateDirect(req, &base.Options{ + Path: downloadDir, + Name: "corrupt.zip", + Extra: http.OptsExtra{ + Connections: 1, + AutoExtract: true, + }, + }) + if err != nil { + t.Fatal(err) + } + + // Wait for extraction to complete (with timeout) + select { + case <-extractDoneCh: + // Extraction completed (should be error) + case <-time.After(10 * time.Second): + t.Log("Extraction timed out") + } + + // Give a small buffer for final events to be processed + time.Sleep(100 * time.Millisecond) + + // Verify extraction status changes include error + statusMutex.Lock() + defer statusMutex.Unlock() + + t.Logf("Recorded extract status changes: %v", extractStatusChanges) + + // Verify that we went through ExtractStatusExtracting + foundExtracting := false + for _, status := range extractStatusChanges { + if status == ExtractStatusExtracting { + foundExtracting = true + break + } + } + if !foundExtracting { + t.Error("Expected ExtractStatusExtracting in status changes") + } + + // Verify that we reached ExtractStatusError + foundError := false + for _, status := range extractStatusChanges { + if status == ExtractStatusError { + foundError = true + break + } + } + if !foundError { + t.Error("Expected ExtractStatusError in status changes") + } +} + +// TestExtractStatus tests the ExtractStatus constants +func TestExtractStatus(t *testing.T) { + tests := []struct { + status ExtractStatus + expected string + }{ + {ExtractStatusNone, ""}, + {ExtractStatusExtracting, "extracting"}, + {ExtractStatusDone, "done"}, + {ExtractStatusError, "error"}, + } + + for _, tt := range tests { + t.Run(string(tt.status), func(t *testing.T) { + if string(tt.status) != tt.expected { + t.Errorf("ExtractStatus %v = %q, want %q", tt.status, string(tt.status), tt.expected) + } + }) + } +} + +// TestProgress_ExtractFields tests the ExtractStatus and ExtractProgress fields in Progress struct +func TestProgress_ExtractFields(t *testing.T) { + progress := &Progress{ + ExtractStatus: ExtractStatusExtracting, + ExtractProgress: 50, + } + + if progress.ExtractStatus != ExtractStatusExtracting { + t.Errorf("ExtractStatus = %v, want %v", progress.ExtractStatus, ExtractStatusExtracting) + } + if progress.ExtractProgress != 50 { + t.Errorf("ExtractProgress = %v, want %v", progress.ExtractProgress, 50) + } + + // Test status transitions + progress.ExtractStatus = ExtractStatusDone + progress.ExtractProgress = 100 + if progress.ExtractStatus != ExtractStatusDone { + t.Errorf("ExtractStatus after update = %v, want %v", progress.ExtractStatus, ExtractStatusDone) + } + if progress.ExtractProgress != 100 { + t.Errorf("ExtractProgress after update = %v, want %v", progress.ExtractProgress, 100) + } +} + +// createTestArchiveWithMultipleFiles creates a test zip file with multiple files +func createTestArchiveWithMultipleFiles(path string, count int) error { + file, err := os.Create(path) + if err != nil { + return err + } + defer file.Close() + + zipWriter := zip.NewWriter(file) + defer zipWriter.Close() + + for i := 0; i < count; i++ { + w, err := zipWriter.Create("test_" + strconv.Itoa(i) + ".txt") + if err != nil { + return err + } + _, err = w.Write([]byte("test content " + strconv.Itoa(i))) + if err != nil { + return err + } + } + return nil +} + +// startTestArchiveServer starts a simple HTTP server that serves a zip file +func startTestArchiveServer(zipPath string) net.Listener { + listener, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + panic(err) + } + + go func() { + gohttp.Serve(listener, gohttp.HandlerFunc(func(w gohttp.ResponseWriter, r *gohttp.Request) { + file, err := os.Open(zipPath) + if err != nil { + gohttp.Error(w, err.Error(), gohttp.StatusInternalServerError) + return + } + defer file.Close() + + stat, _ := file.Stat() + w.Header().Set("Content-Type", "application/zip") + w.Header().Set("Content-Length", strconv.FormatInt(stat.Size(), 10)) + io.Copy(w, file) + })) + }() + + return listener +} + +// createTestArchive creates a simple test zip file for testing +func createTestArchive(path string) error { + file, err := os.Create(path) + if err != nil { + return err + } + defer file.Close() + + // Create a simple zip archive + zipWriter := zip.NewWriter(file) + defer zipWriter.Close() + + // Add a test file + w, err := zipWriter.Create("test.txt") + if err != nil { + return err + } + _, err = w.Write([]byte("test content")) + return err +} + +func TestDownloader_Close(t *testing.T) { + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + + // Close should not error + err := downloader.Close() + if err != nil { + t.Errorf("Close() unexpected error: %v", err) + } + + // Calling Close again should not panic + err = downloader.Close() + if err != nil { + t.Errorf("Close() second call unexpected error: %v", err) + } +} + +func TestDownloader_DeleteAll(t *testing.T) { + listener := test.StartTestFileServer() + defer listener.Close() + + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Create multiple tasks + var wg sync.WaitGroup + taskCount := 3 + wg.Add(taskCount) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone { + wg.Done() + } + }) + + for i := 0; i < taskCount; i++ { + req := &base.Request{ + URL: "http://" + listener.Addr().String() + "/" + test.BuildName, + } + _, err := downloader.CreateDirect(req, &base.Options{ + Path: test.Dir, + Name: test.DownloadName, + Extra: http.OptsExtra{ + Connections: 4, + }, + }) + if err != nil { + t.Fatal(err) + } + } + + wg.Wait() + + // Verify tasks were created + if len(downloader.GetTasks()) != taskCount { + t.Errorf("Expected %d tasks, got %d", taskCount, len(downloader.GetTasks())) + } + + // Delete all tasks with nil filter + err := downloader.Delete(nil, true) + if err != nil { + t.Errorf("Delete(nil) unexpected error: %v", err) + } + + // Verify all tasks are deleted + if len(downloader.GetTasks()) != 0 { + t.Errorf("All tasks should be deleted, got %d remaining", len(downloader.GetTasks())) + } +} + +func TestDownloader_ContinueAll(t *testing.T) { + listener := test.StartTestFileServer() + defer listener.Close() + + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Create a task and wait for completion + req := &base.Request{ + URL: "http://" + listener.Addr().String() + "/" + test.BuildName, + } + + var wg sync.WaitGroup + wg.Add(1) + downloader.Listener(func(event *Event) { + if event.Key == EventKeyDone { + wg.Done() + } + }) + + taskId, err := downloader.CreateDirect(req, &base.Options{ + Path: test.Dir, + Name: test.DownloadName, + Extra: http.OptsExtra{ + Connections: 4, + }, + }) + if err != nil { + t.Fatal(err) + } + + wg.Wait() + + // Verify task completed + task := downloader.GetTask(taskId) + if task == nil { + t.Fatal("Task should exist") + } + if task.Status != base.DownloadStatusDone { + t.Errorf("Task should be done, got %s", task.Status) + } + + // Test ContinueBatch with nil on an already done task (should be a no-op) + err = downloader.ContinueBatch(nil) + if err != nil { + t.Logf("ContinueBatch(nil) on done tasks returned: %v", err) + } + + // Clean up + downloader.Delete(nil, true) +} + +func TestDownloader_ProtocolConfigNotExist(t *testing.T) { + downloader := NewDownloader(nil) + if err := downloader.Setup(); err != nil { + t.Fatal(err) + } + defer downloader.Clear() + + // Test getting a protocol config that doesn't exist + var unknownCfg map[string]any + exists := downloader.getProtocolConfig("unknown-protocol", &unknownCfg) + if exists { + t.Errorf("getProtocolConfig() for unknown protocol should return false") + } +} + +func TestTaskFilter_IsEmpty(t *testing.T) { + tests := []struct { + name string + filter *TaskFilter + expected bool + }{ + { + name: "nil IDs, Statuses, NotStatuses", + filter: &TaskFilter{}, + expected: true, + }, + { + name: "empty IDs only", + filter: &TaskFilter{IDs: []string{}}, + expected: true, + }, + { + name: "non-empty IDs", + filter: &TaskFilter{IDs: []string{"id1"}}, + expected: false, + }, + { + name: "non-empty Statuses", + filter: &TaskFilter{Statuses: []base.Status{base.DownloadStatusDone}}, + expected: false, + }, + { + name: "non-empty NotStatuses", + filter: &TaskFilter{NotStatuses: []base.Status{base.DownloadStatusError}}, + expected: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.filter.IsEmpty() + if result != tt.expected { + t.Errorf("TaskFilter.IsEmpty() = %v, want %v", result, tt.expected) + } + }) + } +} diff --git a/pkg/download/extract.go b/pkg/download/extract.go index 63e0746d..8c12c721 100644 --- a/pkg/download/extract.go +++ b/pkg/download/extract.go @@ -3,10 +3,12 @@ package download import ( "context" "io" + "math" "os" "path/filepath" "slices" "strings" + "sync/atomic" "github.com/mholt/archives" ) @@ -35,6 +37,9 @@ var supportedArchiveExtensions = []string{ ".lz", } +// ExtractProgressCallback is called to report extraction progress +type ExtractProgressCallback func(extractedFiles int, totalFiles int, progress int) + // isArchiveFile checks if a file is a supported archive format func isArchiveFile(filename string) bool { lowerName := strings.ToLower(filename) @@ -43,35 +48,35 @@ func isArchiveFile(filename string) bool { }) } -// extractArchive extracts an archive file to a destination directory -func extractArchive(archivePath string, destDir string, password string) error { - // Open the archive file +// archiveInfo holds information about an opened archive +type archiveInfo struct { + file *os.File + stat os.FileInfo + format archives.Format + input io.Reader +} + +// openArchive opens an archive file and identifies its format +func openArchive(archivePath string, password string) (*archiveInfo, error) { file, err := os.Open(archivePath) if err != nil { - return err + return nil, err } - defer file.Close() - // Get file info for format identification stat, err := file.Stat() if err != nil { - return err + file.Close() + return nil, err } - // Identify the archive format format, input, err := archives.Identify(context.Background(), archivePath, file) if err != nil { - return err - } - - // Create destination directory if it doesn't exist - if err := os.MkdirAll(destDir, 0755); err != nil { - return err + file.Close() + return nil, err } // Handle password-protected archives if password != "" { - // Try to set password for formats that support it if rar, ok := format.(archives.Rar); ok { rar.Password = password format = rar @@ -80,17 +85,57 @@ func extractArchive(archivePath string, destDir string, password string) error { sz.Password = password format = sz } - // Note: Zip format in archives doesn't have a Password field - // Password-protected zips are not fully supported + } + + return &archiveInfo{ + file: file, + stat: stat, + format: format, + input: input, + }, nil +} + +// createExtractionHandler creates a handler function for extracting files with progress tracking +func createExtractionHandler(destDir string, totalFiles int, progressCallback ExtractProgressCallback) func(ctx context.Context, fileInfo archives.FileInfo) error { + var extractedFiles atomic.Int32 + return func(ctx context.Context, fileInfo archives.FileInfo) error { + err := extractFile(ctx, fileInfo, destDir) + if err == nil && !fileInfo.IsDir() { + extracted := int(extractedFiles.Add(1)) + if progressCallback != nil && totalFiles > 0 { + progress := int(math.Min(float64((extracted*100)/totalFiles), 100)) + progressCallback(extracted, totalFiles, progress) + } + } + return err + } +} + +// extractArchive extracts an archive file to a destination directory +func extractArchive(archivePath string, destDir string, password string, progressCallback ExtractProgressCallback) error { + // Open the archive file + info, err := openArchive(archivePath, password) + if err != nil { + return err + } + defer info.file.Close() + + // Create destination directory if it doesn't exist + if err := os.MkdirAll(destDir, 0755); err != nil { + return err } // Handle extraction based on format type - switch f := format.(type) { + switch f := info.format.(type) { case archives.Extractor: // For archive formats (zip, rar, 7z, tar, etc.) - return f.Extract(context.Background(), input, func(ctx context.Context, fileInfo archives.FileInfo) error { - return extractFile(ctx, fileInfo, destDir) - }) + // First, count total files for progress tracking + totalFiles, err := countArchiveFiles(archivePath, password) + if err != nil { + // If counting fails, proceed without progress reporting + totalFiles = 0 + } + return f.Extract(context.Background(), info.input, createExtractionHandler(destDir, totalFiles, progressCallback)) case archives.Decompressor: // For single-file compression formats (gz, bz2, xz, etc.) // Decompress to a file without the compression extension @@ -106,7 +151,7 @@ func extractArchive(archivePath string, destDir string, password string) error { } destPath := filepath.Join(destDir, baseName) - reader, err := f.OpenReader(input) + reader, err := f.OpenReader(info.input) if err != nil { return err } @@ -118,24 +163,71 @@ func extractArchive(archivePath string, destDir string, password string) error { } defer destFile.Close() + // Report progress at start and end for decompression + if progressCallback != nil { + progressCallback(0, 1, 0) + } _, err = io.Copy(destFile, reader) + if err == nil && progressCallback != nil { + progressCallback(1, 1, 100) + } return err case archives.Archiver: // This format is an archiver, try to extract using the extractor interface - if ext, ok := format.(archives.Extractor); ok { + if ext, ok := info.format.(archives.Extractor); ok { // Reset file position - if seeker, ok := input.(io.Seeker); ok { + if seeker, ok := info.input.(io.Seeker); ok { seeker.Seek(0, io.SeekStart) } - return ext.Extract(context.Background(), io.NewSectionReader(file, 0, stat.Size()), func(ctx context.Context, fileInfo archives.FileInfo) error { - return extractFile(ctx, fileInfo, destDir) - }) + // Count total files for progress tracking + totalFiles, err := countArchiveFiles(archivePath, password) + if err != nil { + totalFiles = 0 + } + return ext.Extract(context.Background(), io.NewSectionReader(info.file, 0, info.stat.Size()), createExtractionHandler(destDir, totalFiles, progressCallback)) } } return nil } +// createCountingHandler creates a handler function for counting files in an archive +func createCountingHandler(count *int) func(ctx context.Context, fileInfo archives.FileInfo) error { + return func(ctx context.Context, fileInfo archives.FileInfo) error { + if !fileInfo.IsDir() { + *count++ + } + return nil + } +} + +// countArchiveFiles counts the number of files in an archive for progress calculation +func countArchiveFiles(archivePath string, password string) (int, error) { + info, err := openArchive(archivePath, password) + if err != nil { + return 0, err + } + defer info.file.Close() + + count := 0 + switch f := info.format.(type) { + case archives.Extractor: + err = f.Extract(context.Background(), info.input, createCountingHandler(&count)) + case archives.Archiver: + if ext, ok := info.format.(archives.Extractor); ok { + if seeker, ok := info.input.(io.Seeker); ok { + seeker.Seek(0, io.SeekStart) + } + err = ext.Extract(context.Background(), io.NewSectionReader(info.file, 0, info.stat.Size()), createCountingHandler(&count)) + } + case archives.Decompressor: + // Single file compression, count as 1 + return 1, nil + } + + return count, err +} + // extractFile handles extracting a single file from an archive func extractFile(ctx context.Context, fileInfo archives.FileInfo, destDir string) error { // Skip directories, they will be created when extracting files diff --git a/pkg/download/extract_test.go b/pkg/download/extract_test.go index febbd50a..127222c0 100644 --- a/pkg/download/extract_test.go +++ b/pkg/download/extract_test.go @@ -1,7 +1,9 @@ package download import ( + "archive/tar" "archive/zip" + "compress/gzip" "os" "path/filepath" "testing" @@ -70,7 +72,7 @@ func TestExtractArchive_Zip(t *testing.T) { } // Extract the archive - err = extractArchive(zipPath, destDir, "") + err = extractArchive(zipPath, destDir, "", nil) if err != nil { t.Fatalf("extractArchive failed: %v", err) } @@ -114,7 +116,7 @@ func TestExtractArchive_NonArchive(t *testing.T) { destDir := filepath.Join(tempDir, "extracted") // Trying to extract a non-archive should return an error - err = extractArchive(txtPath, destDir, "") + err = extractArchive(txtPath, destDir, "", nil) if err == nil { t.Error("expected error when extracting non-archive file") } @@ -152,3 +154,1167 @@ func createTestZip(path string) error { return w.Close() } + +func TestExtractArchive_Progress(t *testing.T) { + // Create a temporary directory + tempDir, err := os.MkdirTemp("", "extract_progress_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a test zip file with multiple files + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + // Create zip with 4 files + if err := createTestZipWithMultipleFiles(zipPath, 4); err != nil { + t.Fatal(err) + } + + // Track progress callbacks + progressCalls := make([]struct { + extracted int + total int + progress int + }, 0) + + // Extract the archive with progress tracking + err = extractArchive(zipPath, destDir, "", func(extracted int, total int, progress int) { + progressCalls = append(progressCalls, struct { + extracted int + total int + progress int + }{extracted, total, progress}) + }) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify that progress callbacks were made + if len(progressCalls) != 4 { + t.Errorf("expected 4 progress callbacks, got %d", len(progressCalls)) + } + + // Verify the first progress call + if len(progressCalls) > 0 { + first := progressCalls[0] + if first.extracted != 1 || first.total != 4 { + t.Errorf("first progress call: expected extracted=1, total=4, got extracted=%d, total=%d", first.extracted, first.total) + } + } + + // Verify the last progress call + if len(progressCalls) > 0 { + last := progressCalls[len(progressCalls)-1] + if last.extracted != 4 || last.total != 4 || last.progress != 100 { + t.Errorf("last progress call: expected extracted=4, total=4, progress=100, got extracted=%d, total=%d, progress=%d", last.extracted, last.total, last.progress) + } + } +} + +// createTestZipWithMultipleFiles creates a test zip file with the specified number of files +func createTestZipWithMultipleFiles(path string, numFiles int) error { + zipFile, err := os.Create(path) + if err != nil { + return err + } + defer zipFile.Close() + + w := zip.NewWriter(zipFile) + + for i := 0; i < numFiles; i++ { + f, err := w.Create(filepath.Join("dir", "file"+string(rune('A'+i))+".txt")) + if err != nil { + return err + } + _, err = f.Write([]byte("Content of file " + string(rune('A'+i)))) + if err != nil { + return err + } + } + + return w.Close() +} + +func TestOpenArchive_NonExistentFile(t *testing.T) { + _, err := openArchive("/nonexistent/path/file.zip", "") + if err == nil { + t.Error("expected error when opening non-existent file") + } +} + +func TestOpenArchive_InvalidFormat(t *testing.T) { + tempDir, err := os.MkdirTemp("", "open_archive_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a file that's not a valid archive format + // Use a txt extension so it's not detected as an archive + invalidPath := filepath.Join(tempDir, "invalid.txt") + if err := os.WriteFile(invalidPath, []byte("not an archive file"), 0644); err != nil { + t.Fatal(err) + } + + _, err = openArchive(invalidPath, "") + if err == nil { + // archives.Identify may return a format even for non-archive files + // This is expected behavior - it identifies based on content/extension + t.Log("openArchive accepted the file - this is acceptable behavior") + } +} + +func TestOpenArchive_WithPassword(t *testing.T) { + tempDir, err := os.MkdirTemp("", "open_archive_pwd_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a valid zip file to test password parameter handling + zipPath := filepath.Join(tempDir, "test.zip") + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + // Test that password is accepted (even if zip doesn't use it) + info, err := openArchive(zipPath, "testpassword") + if err != nil { + t.Fatalf("openArchive with password failed: %v", err) + } + defer info.file.Close() + + if info.format == nil { + t.Error("expected format to be set") + } +} + +func TestExtractArchive_NonExistentFile(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_nonexistent_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + destDir := filepath.Join(tempDir, "extracted") + err = extractArchive("/nonexistent/file.zip", destDir, "", nil) + if err == nil { + t.Error("expected error when extracting non-existent file") + } +} + +func TestExtractArchive_WithPassword(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_pwd_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a test zip file + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + // Extract with password (zip doesn't require it, but tests the code path) + err = extractArchive(zipPath, destDir, "password123", nil) + if err != nil { + t.Fatalf("extractArchive with password failed: %v", err) + } + + // Verify extraction succeeded + if _, err := os.Stat(filepath.Join(destDir, "test.txt")); os.IsNotExist(err) { + t.Error("expected file not found after extraction") + } +} + +func TestExtractArchive_Gzip(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_gzip_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a gzip compressed file + gzPath := filepath.Join(tempDir, "test.txt.gz") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestGzip(gzPath, "Hello from gzip!"); err != nil { + t.Fatal(err) + } + + // Track progress callback values + var progressCalls []struct { + extracted int + total int + progress int + } + err = extractArchive(gzPath, destDir, "", func(extracted int, total int, progress int) { + progressCalls = append(progressCalls, struct { + extracted int + total int + progress int + }{extracted, total, progress}) + }) + if err != nil { + t.Fatalf("extractArchive failed for gzip: %v", err) + } + + // Verify the decompressed file exists + destPath := filepath.Join(destDir, "test.txt") + if _, err := os.Stat(destPath); os.IsNotExist(err) { + t.Error("expected decompressed file not found") + } + + // Verify content + content, err := os.ReadFile(destPath) + if err != nil { + t.Fatal(err) + } + if string(content) != "Hello from gzip!" { + t.Errorf("unexpected content: %q", string(content)) + } + + // Verify progress callbacks - should have exactly 2 calls for gzip: start (0,1,0) and end (1,1,100) + if len(progressCalls) != 2 { + t.Errorf("expected 2 progress callbacks for gzip, got %d", len(progressCalls)) + } + if len(progressCalls) >= 2 { + // Verify start callback + if progressCalls[0].extracted != 0 || progressCalls[0].total != 1 || progressCalls[0].progress != 0 { + t.Errorf("expected start callback (0,1,0), got (%d,%d,%d)", progressCalls[0].extracted, progressCalls[0].total, progressCalls[0].progress) + } + // Verify end callback + if progressCalls[1].extracted != 1 || progressCalls[1].total != 1 || progressCalls[1].progress != 100 { + t.Errorf("expected end callback (1,1,100), got (%d,%d,%d)", progressCalls[1].extracted, progressCalls[1].total, progressCalls[1].progress) + } + } +} + +func createTestGzip(path string, content string) error { + file, err := os.Create(path) + if err != nil { + return err + } + defer file.Close() + + gz := gzip.NewWriter(file) + _, err = gz.Write([]byte(content)) + if err != nil { + gz.Close() + return err + } + return gz.Close() +} + +func TestCountArchiveFiles(t *testing.T) { + tempDir, err := os.MkdirTemp("", "count_archive_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a test zip with known number of files + zipPath := filepath.Join(tempDir, "test.zip") + if err := createTestZipWithMultipleFiles(zipPath, 5); err != nil { + t.Fatal(err) + } + + count, err := countArchiveFiles(zipPath, "") + if err != nil { + t.Fatalf("countArchiveFiles failed: %v", err) + } + + if count != 5 { + t.Errorf("expected 5 files, got %d", count) + } +} + +func TestCountArchiveFiles_NonExistent(t *testing.T) { + _, err := countArchiveFiles("/nonexistent/file.zip", "") + if err == nil { + t.Error("expected error for non-existent file") + } +} + +func TestCountArchiveFiles_Gzip(t *testing.T) { + tempDir, err := os.MkdirTemp("", "count_gzip_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a gzip file + gzPath := filepath.Join(tempDir, "test.txt.gz") + if err := createTestGzip(gzPath, "test content"); err != nil { + t.Fatal(err) + } + + count, err := countArchiveFiles(gzPath, "") + if err != nil { + t.Fatalf("countArchiveFiles failed: %v", err) + } + + // Gzip is single-file compression, should return 1 + if count != 1 { + t.Errorf("expected 1 file for gzip, got %d", count) + } +} + +func TestExtractArchive_ProgressWithZeroFiles(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_zero_progress_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create an empty zip file + zipPath := filepath.Join(tempDir, "empty.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createEmptyZip(zipPath); err != nil { + t.Fatal(err) + } + + progressCalled := false + err = extractArchive(zipPath, destDir, "", func(extracted int, total int, progress int) { + progressCalled = true + }) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Progress should not be called for empty archive + if progressCalled { + t.Error("progress callback should not be called for empty archive") + } +} + +func createEmptyZip(path string) error { + zipFile, err := os.Create(path) + if err != nil { + return err + } + defer zipFile.Close() + + w := zip.NewWriter(zipFile) + return w.Close() +} + +func TestExtractArchive_WithDirectories(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_dirs_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestZipWithDirectories(zipPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify files were created (directories are created implicitly) + expectedPaths := []string{ + filepath.Join(destDir, "dir1", "file1.txt"), + filepath.Join(destDir, "dir2", "subdir", "file2.txt"), + } + + for _, path := range expectedPaths { + if _, err := os.Stat(path); os.IsNotExist(err) { + t.Errorf("expected path %q not found", path) + } + } +} + +func createTestZipWithDirectories(path string) error { + zipFile, err := os.Create(path) + if err != nil { + return err + } + defer zipFile.Close() + + w := zip.NewWriter(zipFile) + + // Create file in directory (directory will be created automatically) + f, err := w.Create("dir1/file1.txt") + if err != nil { + return err + } + _, err = f.Write([]byte("content1")) + if err != nil { + return err + } + + // Create nested directory structure + f, err = w.Create("dir2/subdir/file2.txt") + if err != nil { + return err + } + _, err = f.Write([]byte("content2")) + if err != nil { + return err + } + + return w.Close() +} + +func TestExtractArchive_NilProgressCallback(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_nil_progress_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestZipWithMultipleFiles(zipPath, 3); err != nil { + t.Fatal(err) + } + + // Should not panic with nil callback + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } +} + +func TestExtractArchive_GzipUppercase(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_gzip_upper_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a gzip compressed file with uppercase extension + gzPath := filepath.Join(tempDir, "test.txt.GZ") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestGzip(gzPath, "Hello from gzip!"); err != nil { + t.Fatal(err) + } + + err = extractArchive(gzPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed for gzip with uppercase: %v", err) + } + + // The base name should have the extension stripped + destPath := filepath.Join(destDir, "test.txt") + if _, err := os.Stat(destPath); os.IsNotExist(err) { + t.Error("expected decompressed file not found") + } +} + +func TestExtractArchive_PathTraversalPrevention(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_traversal_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a zip with a path traversal attempt + zipPath := filepath.Join(tempDir, "malicious.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createMaliciousZip(zipPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify that the file was not created outside destDir + // The malicious path should be sanitized + dangerousPath := filepath.Join(tempDir, "evil.txt") + if _, err := os.Stat(dangerousPath); err == nil { + t.Error("path traversal attack succeeded - file created outside destDir") + } +} + +func createMaliciousZip(path string) error { + zipFile, err := os.Create(path) + if err != nil { + return err + } + defer zipFile.Close() + + w := zip.NewWriter(zipFile) + + // Create a file with path traversal attempt + // Note: Go's zip library may sanitize this, but we test it anyway + f, err := w.Create("../evil.txt") + if err != nil { + return err + } + _, err = f.Write([]byte("malicious content")) + if err != nil { + return err + } + + // Also add a normal file + f, err = w.Create("safe.txt") + if err != nil { + return err + } + _, err = f.Write([]byte("safe content")) + if err != nil { + return err + } + + return w.Close() +} + +func TestIsArchiveFile_AdditionalFormats(t *testing.T) { + // Test additional archive formats + tests := []struct { + filename string + expected bool + }{ + // More compression formats + {"file.tar.lz4", true}, + {"file.tlz4", true}, + {"file.tar.sz", true}, + {"file.tsz", true}, + // Edge cases + {"file.tar.gz.backup", false}, + {".gz", true}, + {"archive.ZIP.bak", false}, + } + + for _, tt := range tests { + t.Run(tt.filename, func(t *testing.T) { + result := isArchiveFile(tt.filename) + if result != tt.expected { + t.Errorf("isArchiveFile(%q) = %v, expected %v", tt.filename, result, tt.expected) + } + }) + } +} + +func TestExtractArchive_DestDirCreation(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_destdir_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + // Use a nested path that doesn't exist + destDir := filepath.Join(tempDir, "level1", "level2", "extracted") + + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify destDir was created + if _, err := os.Stat(destDir); os.IsNotExist(err) { + t.Error("destDir was not created") + } + + // Verify files were extracted + if _, err := os.Stat(filepath.Join(destDir, "test.txt")); os.IsNotExist(err) { + t.Error("file not extracted") + } +} + +func TestExtractArchive_ProgressCallbackValues(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_progress_values_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + // Create zip with 10 files to test progress calculation + if err := createTestZipWithMultipleFiles(zipPath, 10); err != nil { + t.Fatal(err) + } + + var progressValues []int + err = extractArchive(zipPath, destDir, "", func(extracted int, total int, progress int) { + progressValues = append(progressValues, progress) + }) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify progress increases monotonically + for i := 1; i < len(progressValues); i++ { + if progressValues[i] < progressValues[i-1] { + t.Errorf("progress decreased from %d to %d", progressValues[i-1], progressValues[i]) + } + } + + // Verify last progress is 100 + if len(progressValues) > 0 && progressValues[len(progressValues)-1] != 100 { + t.Errorf("final progress should be 100, got %d", progressValues[len(progressValues)-1]) + } +} + +func TestCountArchiveFiles_WithDirectories(t *testing.T) { + tempDir, err := os.MkdirTemp("", "count_dirs_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + if err := createTestZipWithDirectories(zipPath); err != nil { + t.Fatal(err) + } + + count, err := countArchiveFiles(zipPath, "") + if err != nil { + t.Fatalf("countArchiveFiles failed: %v", err) + } + + // Should only count files, not directories + // createTestZipWithDirectories creates 2 files + if count != 2 { + t.Errorf("expected 2 files, got %d", count) + } +} + +func TestOpenArchive_FileStatError(t *testing.T) { + // Test error path when file can't be stat'd + // This is hard to test without mocking, so we just ensure + // the function handles basic error cases + + tempDir, err := os.MkdirTemp("", "open_archive_stat_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a valid zip first + zipPath := filepath.Join(tempDir, "test.zip") + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + // Test normal opening + info, err := openArchive(zipPath, "") + if err != nil { + t.Fatalf("openArchive failed: %v", err) + } + defer info.file.Close() + + if info.stat == nil { + t.Error("stat should not be nil") + } + if info.format == nil { + t.Error("format should not be nil") + } + if info.input == nil { + t.Error("input should not be nil") + } +} + +func TestExtractArchive_FilePermissions(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_perms_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Check that files are readable + content, err := os.ReadFile(filepath.Join(destDir, "test.txt")) + if err != nil { + t.Fatalf("couldn't read extracted file: %v", err) + } + if string(content) != "Hello, World!" { + t.Errorf("unexpected content: %q", string(content)) + } +} + +func TestExtractArchive_TarGz(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_targz_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + tarGzPath := filepath.Join(tempDir, "test.tar.gz") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestTarGz(tarGzPath); err != nil { + t.Fatal(err) + } + + var progressCalls int + err = extractArchive(tarGzPath, destDir, "", func(extracted int, total int, progress int) { + progressCalls++ + }) + if err != nil { + t.Fatalf("extractArchive failed for tar.gz: %v", err) + } + + // Verify the extracted file exists + destPath := filepath.Join(destDir, "test.txt") + content, err := os.ReadFile(destPath) + if err != nil { + t.Fatalf("couldn't read extracted file: %v", err) + } + if string(content) != "Hello from tar.gz!" { + t.Errorf("unexpected content: %q", string(content)) + } + + // Verify nested file exists + nestedPath := filepath.Join(destDir, "subdir", "nested.txt") + content, err = os.ReadFile(nestedPath) + if err != nil { + t.Fatalf("couldn't read nested file: %v", err) + } + if string(content) != "Nested content" { + t.Errorf("unexpected nested content: %q", string(content)) + } +} + +func createTestTarGz(path string) error { + file, err := os.Create(path) + if err != nil { + return err + } + defer file.Close() + + gzWriter := gzip.NewWriter(file) + defer gzWriter.Close() + + tarWriter := tar.NewWriter(gzWriter) + defer tarWriter.Close() + + // Add a file + content := []byte("Hello from tar.gz!") + header := &tar.Header{ + Name: "test.txt", + Mode: 0644, + Size: int64(len(content)), + } + if err := tarWriter.WriteHeader(header); err != nil { + return err + } + if _, err := tarWriter.Write(content); err != nil { + return err + } + + // Add a nested file + nestedContent := []byte("Nested content") + nestedHeader := &tar.Header{ + Name: "subdir/nested.txt", + Mode: 0644, + Size: int64(len(nestedContent)), + } + if err := tarWriter.WriteHeader(nestedHeader); err != nil { + return err + } + if _, err := tarWriter.Write(nestedContent); err != nil { + return err + } + + return nil +} + +func TestCountArchiveFiles_TarGz(t *testing.T) { + tempDir, err := os.MkdirTemp("", "count_targz_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + tarGzPath := filepath.Join(tempDir, "test.tar.gz") + if err := createTestTarGz(tarGzPath); err != nil { + t.Fatal(err) + } + + count, err := countArchiveFiles(tarGzPath, "") + if err != nil { + t.Fatalf("countArchiveFiles failed: %v", err) + } + + // Should have 2 files + if count != 2 { + t.Errorf("expected 2 files, got %d", count) + } +} + +func TestExtractArchive_LargeFileCount(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_large_count_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + // Create zip with many files to test progress capping at 100 + numFiles := 100 + if err := createTestZipWithMultipleFiles(zipPath, numFiles); err != nil { + t.Fatal(err) + } + + var maxProgress int + err = extractArchive(zipPath, destDir, "", func(extracted int, total int, progress int) { + if progress > maxProgress { + maxProgress = progress + } + // Progress should never exceed 100 + if progress > 100 { + t.Errorf("progress exceeded 100: %d", progress) + } + }) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Max progress should be 100 + if maxProgress != 100 { + t.Errorf("expected max progress 100, got %d", maxProgress) + } +} + +func TestExtractArchive_GzipNoExtension(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_gzip_noext_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + // Create a gzip with just .gz (no original extension) + gzPath := filepath.Join(tempDir, "compressed.gz") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestGzip(gzPath, "Compressed content"); err != nil { + t.Fatal(err) + } + + err = extractArchive(gzPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Should create file named "compressed" (without .gz) + destPath := filepath.Join(destDir, "compressed") + if _, err := os.Stat(destPath); os.IsNotExist(err) { + t.Error("expected decompressed file not found") + } +} + +func TestExtractArchive_ReadOnlyDestDir(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_readonly_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "readonly") + + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + // Create a read-only directory + if err := os.MkdirAll(destDir, 0555); err != nil { + t.Fatal(err) + } + // Make it writable for cleanup + defer os.Chmod(destDir, 0755) + + // Extraction should fail due to read-only destination + err = extractArchive(zipPath, destDir, "", nil) + if err == nil { + t.Error("expected error when extracting to read-only directory") + } +} + +func TestSupportedArchiveExtensions(t *testing.T) { + // Test that all listed extensions are recognized + for _, ext := range supportedArchiveExtensions { + filename := "test" + ext + if !isArchiveFile(filename) { + t.Errorf("extension %q should be recognized as archive", ext) + } + } +} + +func TestExtractArchive_Tar(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_tar_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + tarPath := filepath.Join(tempDir, "test.tar") + destDir := filepath.Join(tempDir, "extracted") + + if err := createTestTar(tarPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(tarPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed for tar: %v", err) + } + + // Verify files were extracted + destPath := filepath.Join(destDir, "test.txt") + if _, err := os.Stat(destPath); os.IsNotExist(err) { + t.Error("expected file not found") + } +} + +func createTestTar(path string) error { + file, err := os.Create(path) + if err != nil { + return err + } + defer file.Close() + + tarWriter := tar.NewWriter(file) + defer tarWriter.Close() + + content := []byte("Hello from tar!") + header := &tar.Header{ + Name: "test.txt", + Mode: 0644, + Size: int64(len(content)), + } + if err := tarWriter.WriteHeader(header); err != nil { + return err + } + if _, err := tarWriter.Write(content); err != nil { + return err + } + + return nil +} + +func TestCountArchiveFiles_Tar(t *testing.T) { + tempDir, err := os.MkdirTemp("", "count_tar_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + tarPath := filepath.Join(tempDir, "test.tar") + if err := createTestTar(tarPath); err != nil { + t.Fatal(err) + } + + count, err := countArchiveFiles(tarPath, "") + if err != nil { + t.Fatalf("countArchiveFiles failed: %v", err) + } + + if count != 1 { + t.Errorf("expected 1 file, got %d", count) + } +} + +func TestOpenArchive_ValidArchive(t *testing.T) { + tempDir, err := os.MkdirTemp("", "open_valid_archive_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + info, err := openArchive(zipPath, "") + if err != nil { + t.Fatalf("openArchive failed: %v", err) + } + defer info.file.Close() + + // Verify all fields are set + if info.file == nil { + t.Error("file should not be nil") + } + if info.stat == nil { + t.Error("stat should not be nil") + } + if info.format == nil { + t.Error("format should not be nil") + } + if info.input == nil { + t.Error("input should not be nil") + } + if info.stat.Size() == 0 { + t.Error("file size should be > 0") + } +} + +func TestExtractArchive_NestedDirectoryStructure(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_nested_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "nested.zip") + destDir := filepath.Join(tempDir, "extracted") + + if err := createDeeplyNestedZip(zipPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify deeply nested file + deepPath := filepath.Join(destDir, "a", "b", "c", "d", "deep.txt") + if _, err := os.Stat(deepPath); os.IsNotExist(err) { + t.Error("deeply nested file not found") + } +} + +func createDeeplyNestedZip(path string) error { + zipFile, err := os.Create(path) + if err != nil { + return err + } + defer zipFile.Close() + + w := zip.NewWriter(zipFile) + + f, err := w.Create("a/b/c/d/deep.txt") + if err != nil { + return err + } + _, err = f.Write([]byte("Deep content")) + if err != nil { + return err + } + + return w.Close() +} + +func TestExtractArchive_EmptyFileName(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_empty_name_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + // Create a normal zip - the archive library handles empty names gracefully + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + err = extractArchive(zipPath, destDir, "", nil) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } +} + +func TestExtractArchive_ProgressTracking(t *testing.T) { + tempDir, err := os.MkdirTemp("", "extract_progress_track_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + destDir := filepath.Join(tempDir, "extracted") + + numFiles := 5 + if err := createTestZipWithMultipleFiles(zipPath, numFiles); err != nil { + t.Fatal(err) + } + + var extractedValues []int + var totalValues []int + + err = extractArchive(zipPath, destDir, "", func(extracted int, total int, progress int) { + extractedValues = append(extractedValues, extracted) + totalValues = append(totalValues, total) + }) + if err != nil { + t.Fatalf("extractArchive failed: %v", err) + } + + // Verify total is always the same + for _, total := range totalValues { + if total != numFiles { + t.Errorf("total should be %d, got %d", numFiles, total) + } + } + + // Verify extracted increases sequentially + for i, extracted := range extractedValues { + if extracted != i+1 { + t.Errorf("extracted should be %d, got %d", i+1, extracted) + } + } +} + +func TestArchiveInfo_Fields(t *testing.T) { + tempDir, err := os.MkdirTemp("", "archive_info_test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tempDir) + + zipPath := filepath.Join(tempDir, "test.zip") + if err := createTestZip(zipPath); err != nil { + t.Fatal(err) + } + + info, err := openArchive(zipPath, "") + if err != nil { + t.Fatalf("openArchive failed: %v", err) + } + defer info.file.Close() + + // Verify file name + if info.file.Name() != zipPath { + t.Errorf("expected file name %q, got %q", zipPath, info.file.Name()) + } + + // Verify stat mode + if info.stat.Mode().IsDir() { + t.Error("expected file, not directory") + } +} diff --git a/ui/flutter/lib/api/model/task.dart b/ui/flutter/lib/api/model/task.dart index 53acf9e6..2fe9161f 100644 --- a/ui/flutter/lib/api/model/task.dart +++ b/ui/flutter/lib/api/model/task.dart @@ -8,6 +8,18 @@ enum Status { ready, running, pause, wait, error, done } enum Protocol { http, bt } +// ExtractStatus enum matching Go backend +enum ExtractStatus { + @JsonValue('') + none, + @JsonValue('extracting') + extracting, + @JsonValue('done') + done, + @JsonValue('error') + error +} + @JsonSerializable(explicitToJson: true) class Task { String id; @@ -43,6 +55,8 @@ class Progress { int downloaded; int uploadSpeed; int uploaded; + ExtractStatus extractStatus; + int extractProgress; Progress({ required this.used, @@ -50,6 +64,8 @@ class Progress { required this.downloaded, required this.uploadSpeed, required this.uploaded, + this.extractStatus = ExtractStatus.none, + this.extractProgress = 0, }); factory Progress.fromJson(Map json) => diff --git a/ui/flutter/lib/api/model/task.g.dart b/ui/flutter/lib/api/model/task.g.dart index 125edefb..434c43b5 100644 --- a/ui/flutter/lib/api/model/task.g.dart +++ b/ui/flutter/lib/api/model/task.g.dart @@ -53,12 +53,23 @@ const _$ProtocolEnumMap = { Protocol.bt: 'bt', }; +const _$ExtractStatusEnumMap = { + ExtractStatus.none: '', + ExtractStatus.extracting: 'extracting', + ExtractStatus.done: 'done', + ExtractStatus.error: 'error', +}; + Progress _$ProgressFromJson(Map json) => Progress( used: (json['used'] as num).toInt(), speed: (json['speed'] as num).toInt(), downloaded: (json['downloaded'] as num).toInt(), uploadSpeed: (json['uploadSpeed'] as num).toInt(), uploaded: (json['uploaded'] as num).toInt(), + extractStatus: $enumDecodeNullable( + _$ExtractStatusEnumMap, json['extractStatus']) ?? + ExtractStatus.none, + extractProgress: (json['extractProgress'] as num?)?.toInt() ?? 0, ); Map _$ProgressToJson(Progress instance) => { @@ -67,4 +78,6 @@ Map _$ProgressToJson(Progress instance) => { 'downloaded': instance.downloaded, 'uploadSpeed': instance.uploadSpeed, 'uploaded': instance.uploaded, + 'extractStatus': _$ExtractStatusEnumMap[instance.extractStatus]!, + 'extractProgress': instance.extractProgress, }; diff --git a/ui/flutter/lib/app/views/buid_task_list_view.dart b/ui/flutter/lib/app/views/buid_task_list_view.dart index fbdac8e8..239801eb 100644 --- a/ui/flutter/lib/app/views/buid_task_list_view.dart +++ b/ui/flutter/lib/app/views/buid_task_list_view.dart @@ -187,6 +187,19 @@ class BuildTaskListView extends GetView { return totalSize <= 0 ? 0 : task.progress.downloaded / totalSize; } + String getExtractionStatusText() { + switch (task.progress.extractStatus) { + case ExtractStatus.extracting: + return '${'extracting'.tr} ${task.progress.extractProgress}%'; + case ExtractStatus.done: + return 'extractDone'.tr; + case ExtractStatus.error: + return 'extractError'.tr; + default: + return ''; + } + } + String getProgressText() { if (isDone()) { return Util.fmtByte(task.meta.res!.size); @@ -317,6 +330,56 @@ class BuildTaskListView extends GetView { : LinearProgressIndicator( value: getProgress(), ), + // Extraction status row + if (task.progress.extractStatus != ExtractStatus.none) + Builder(builder: (context) { + final isExtracting = + task.progress.extractStatus == ExtractStatus.extracting; + final isExtractDone = + task.progress.extractStatus == ExtractStatus.done; + final statusColor = isExtracting + ? Get.theme.colorScheme.primary + : (isExtractDone ? Colors.green : Colors.red); + return Column( + children: [ + Row( + children: [ + Expanded( + child: Row( + children: [ + Icon( + isExtracting + ? Icons.unarchive + : (isExtractDone + ? Icons.check_circle + : Icons.error), + size: 16, + color: statusColor, + ), + const SizedBox(width: 4), + Text( + getExtractionStatusText(), + style: Get.textTheme.bodySmall?.copyWith( + color: statusColor, + ), + ), + ], + ).padding(left: 18), + ), + ], + ).padding(top: 4, bottom: isExtracting ? 0 : 8), + // Extraction progress bar + if (isExtracting) + LinearProgressIndicator( + value: task.progress.extractProgress / 100.0, + backgroundColor: + Get.theme.colorScheme.surfaceContainerHighest, + valueColor: AlwaysStoppedAnimation( + Get.theme.colorScheme.secondary), + ), + ], + ); + }), ], ), )).padding(horizontal: 14, top: 8), diff --git a/ui/flutter/lib/i18n/langs/de_de.dart b/ui/flutter/lib/i18n/langs/de_de.dart index faefae50..3b2ed6bd 100644 --- a/ui/flutter/lib/i18n/langs/de_de.dart +++ b/ui/flutter/lib/i18n/langs/de_de.dart @@ -121,6 +121,9 @@ const deDE = { 'archivePassword': 'Archiv-Passwort', 'archivePasswordHint': 'Leer lassen, wenn nicht passwortgeschützt', 'deleteAfterExtract': 'Archiv nach Entpacken löschen', + 'extracting': 'Wird entpackt', + 'extractDone': 'Entpacken abgeschlossen', + 'extractError': 'Entpacken fehlgeschlagen', 'name': 'Name', 'size': 'Größe', 'unknown': 'Unbekannt', diff --git a/ui/flutter/lib/i18n/langs/en_us.dart b/ui/flutter/lib/i18n/langs/en_us.dart index b179ec88..8cd21cd8 100644 --- a/ui/flutter/lib/i18n/langs/en_us.dart +++ b/ui/flutter/lib/i18n/langs/en_us.dart @@ -129,6 +129,9 @@ const enUS = { 'archivePassword': 'Archive Password', 'archivePasswordHint': 'Leave empty if not password protected', 'deleteAfterExtract': 'Delete Archive After Extraction', + 'extracting': 'Extracting', + 'extractDone': 'Extraction completed', + 'extractError': 'Extraction failed', 'name': 'Name', 'size': 'Size', 'unknown': 'Unknown', diff --git a/ui/flutter/lib/i18n/langs/es_es.dart b/ui/flutter/lib/i18n/langs/es_es.dart index 83179a3c..0b974f08 100644 --- a/ui/flutter/lib/i18n/langs/es_es.dart +++ b/ui/flutter/lib/i18n/langs/es_es.dart @@ -113,6 +113,9 @@ const esES = { 'archivePassword': 'Contraseña del archivo', 'archivePasswordHint': 'Dejar vacío si no tiene contraseña', 'deleteAfterExtract': 'Eliminar archivo después de extraer', + 'extracting': 'Extrayendo', + 'extractDone': 'Extracción completada', + 'extractError': 'Error en la extracción', 'insertPlaceholder': 'Insertar marcador de posición', 'placeholderYear': 'Año actual', 'placeholderMonth': 'Mes actual (01-12)', diff --git a/ui/flutter/lib/i18n/langs/fa_ir.dart b/ui/flutter/lib/i18n/langs/fa_ir.dart index 58192aac..b06c0984 100644 --- a/ui/flutter/lib/i18n/langs/fa_ir.dart +++ b/ui/flutter/lib/i18n/langs/fa_ir.dart @@ -68,6 +68,9 @@ const faIR = { 'archivePassword': 'رمز عبور بایگانی', 'archivePasswordHint': 'اگر رمز ندارد خالی بگذارید', 'deleteAfterExtract': 'حذف آرشیو پس از استخراج', + 'extracting': 'در حال استخراج', + 'extractDone': 'استخراج کامل شد', + 'extractError': 'استخراج ناموفق بود', 'insertPlaceholder': 'درج نگهدارنده', 'placeholderYear': 'سال جاری', 'placeholderMonth': 'ماه جاری (01-12)', diff --git a/ui/flutter/lib/i18n/langs/fr_fr.dart b/ui/flutter/lib/i18n/langs/fr_fr.dart index 68a3400f..77da3e63 100644 --- a/ui/flutter/lib/i18n/langs/fr_fr.dart +++ b/ui/flutter/lib/i18n/langs/fr_fr.dart @@ -105,6 +105,9 @@ const frFR = { 'archivePassword': 'Mot de passe de l\'archive', 'archivePasswordHint': 'Laisser vide si non protégé par mot de passe', 'deleteAfterExtract': "Supprimer l'archive après extraction", + 'extracting': 'Extraction en cours', + 'extractDone': 'Extraction terminée', + 'extractError': 'Échec de l\'extraction', 'insertPlaceholder': 'Insérer un espace réservé', 'placeholderYear': 'Année en cours', 'placeholderMonth': 'Mois en cours (01-12)', diff --git a/ui/flutter/lib/i18n/langs/hu_hu.dart b/ui/flutter/lib/i18n/langs/hu_hu.dart index 04310a26..e91c5cd8 100644 --- a/ui/flutter/lib/i18n/langs/hu_hu.dart +++ b/ui/flutter/lib/i18n/langs/hu_hu.dart @@ -121,6 +121,9 @@ const huHU = { 'archivePassword': 'Archívum jelszó', 'archivePasswordHint': 'Hagyja üresen, ha nincs jelszóval védve', 'deleteAfterExtract': 'Archívum törlése kicsomagolás után', + 'extracting': 'Kicsomagolás', + 'extractDone': 'Kicsomagolás befejezve', + 'extractError': 'Kicsomagolás sikertelen', 'name': 'Név', 'size': 'Méret', 'unknown': 'Ismeretlen', diff --git a/ui/flutter/lib/i18n/langs/id_id.dart b/ui/flutter/lib/i18n/langs/id_id.dart index 25c0e6ac..093517b2 100644 --- a/ui/flutter/lib/i18n/langs/id_id.dart +++ b/ui/flutter/lib/i18n/langs/id_id.dart @@ -115,6 +115,9 @@ const idID = { 'archivePassword': 'Kata Sandi Arsip', 'archivePasswordHint': 'Kosongkan jika tidak dilindungi kata sandi', 'deleteAfterExtract': 'Hapus arsip setelah ekstraksi', + 'extracting': 'Mengekstrak', + 'extractDone': 'Ekstraksi selesai', + 'extractError': 'Ekstraksi gagal', 'insertPlaceholder': 'Sisipkan placeholder', 'placeholderYear': 'Tahun saat ini', 'placeholderMonth': 'Bulan saat ini (01-12)', diff --git a/ui/flutter/lib/i18n/langs/it_it.dart b/ui/flutter/lib/i18n/langs/it_it.dart index b960b3b5..16e53cc4 100644 --- a/ui/flutter/lib/i18n/langs/it_it.dart +++ b/ui/flutter/lib/i18n/langs/it_it.dart @@ -103,6 +103,9 @@ const itIT = { 'archivePassword': 'Password archivio', 'archivePasswordHint': 'Lasciare vuoto se non protetto da password', 'deleteAfterExtract': "Elimina l'archivio dopo l'estrazione", + 'extracting': 'Estrazione in corso', + 'extractDone': 'Estrazione completata', + 'extractError': 'Estrazione fallita', 'insertPlaceholder': 'Inserisci segnaposto', 'placeholderYear': 'Anno corrente', 'placeholderMonth': 'Mese corrente (01-12)', diff --git a/ui/flutter/lib/i18n/langs/ja_jp.dart b/ui/flutter/lib/i18n/langs/ja_jp.dart index 0b3f7d23..18e88f48 100644 --- a/ui/flutter/lib/i18n/langs/ja_jp.dart +++ b/ui/flutter/lib/i18n/langs/ja_jp.dart @@ -69,6 +69,9 @@ const jaJP = { 'archivePassword': 'アーカイブパスワード', 'archivePasswordHint': 'パスワードなしの場合は空のままにしてください', 'deleteAfterExtract': '展開後にアーカイブを削除', + 'extracting': '展開中', + 'extractDone': '展開完了', + 'extractError': '展開失敗', 'insertPlaceholder': 'プレースホルダーを挿入', 'placeholderYear': '現在の年', 'placeholderMonth': '現在の月 (01-12)', diff --git a/ui/flutter/lib/i18n/langs/pl_pl.dart b/ui/flutter/lib/i18n/langs/pl_pl.dart index 9ae4dcef..113414b8 100644 --- a/ui/flutter/lib/i18n/langs/pl_pl.dart +++ b/ui/flutter/lib/i18n/langs/pl_pl.dart @@ -101,6 +101,9 @@ const plPL = { 'archivePassword': 'Hasło archiwum', 'archivePasswordHint': 'Pozostaw puste, jeśli nie ma hasła', 'deleteAfterExtract': 'Usuń archiwum po rozpakowaniu', + 'extracting': 'Rozpakowywanie', + 'extractDone': 'Rozpakowywanie zakończone', + 'extractError': 'Rozpakowywanie nie powiodło się', 'insertPlaceholder': 'Wstaw placeholder', 'placeholderYear': 'Bieżący rok', 'placeholderMonth': 'Bieżący miesiąc (01-12)', diff --git a/ui/flutter/lib/i18n/langs/pt_br.dart b/ui/flutter/lib/i18n/langs/pt_br.dart index 11c3d1cf..f9960d83 100644 --- a/ui/flutter/lib/i18n/langs/pt_br.dart +++ b/ui/flutter/lib/i18n/langs/pt_br.dart @@ -118,6 +118,9 @@ const ptBR = { 'archivePassword': 'Senha do arquivo', 'archivePasswordHint': 'Deixar vazio se não estiver protegido por senha', 'deleteAfterExtract': 'Excluir arquivo após extração', + 'extracting': 'Extraindo', + 'extractDone': 'Extração concluída', + 'extractError': 'Falha na extração', 'name': 'Nome', 'size': 'Tamanho', 'unknown': 'Desconhecido', diff --git a/ui/flutter/lib/i18n/langs/ru_ru.dart b/ui/flutter/lib/i18n/langs/ru_ru.dart index f37bdaab..4260eb16 100644 --- a/ui/flutter/lib/i18n/langs/ru_ru.dart +++ b/ui/flutter/lib/i18n/langs/ru_ru.dart @@ -118,6 +118,9 @@ const ruRU = { 'archivePassword': 'Пароль архива', 'archivePasswordHint': 'Оставить пустым, если архив не защищён паролем', 'deleteAfterExtract': 'Удалить архив после распаковки', + 'extracting': 'Распаковка', + 'extractDone': 'Распаковка завершена', + 'extractError': 'Ошибка распаковки', 'name': 'Название', 'size': 'Размер', 'unknown': 'Неизвестно', diff --git a/ui/flutter/lib/i18n/langs/ta_ta.dart b/ui/flutter/lib/i18n/langs/ta_ta.dart index bb9c6cb6..8dc4607c 100644 --- a/ui/flutter/lib/i18n/langs/ta_ta.dart +++ b/ui/flutter/lib/i18n/langs/ta_ta.dart @@ -103,6 +103,9 @@ const taTA = { 'archivePassword': 'காப்பக கடவுச்சொல்', 'archivePasswordHint': 'கடவுச்சொல் இல்லையென்றால் காலியாக விடவும்', 'deleteAfterExtract': 'பிரித்தெடுத்த பிறகு காப்பகத்தை நீக்கு', + 'extracting': 'பிரித்தெடுக்கிறது', + 'extractDone': 'பிரித்தெடுத்தல் முடிந்தது', + 'extractError': 'பிரித்தெடுத்தல் தோல்வியடைந்தது', 'insertPlaceholder': 'இடங்காட்டி செருக', 'placeholderYear': 'தற்போதைய ஆண்டு', 'placeholderMonth': 'தற்போதைய மாதம் (01-12)', diff --git a/ui/flutter/lib/i18n/langs/tr_tr.dart b/ui/flutter/lib/i18n/langs/tr_tr.dart index c11f60dc..78534d76 100644 --- a/ui/flutter/lib/i18n/langs/tr_tr.dart +++ b/ui/flutter/lib/i18n/langs/tr_tr.dart @@ -119,6 +119,9 @@ const trTR = { 'archivePassword': 'Arşiv şifresi', 'archivePasswordHint': 'Şifre yoksa boş bırakın', 'deleteAfterExtract': 'Çıkarmadan sonra arşivi sil', + 'extracting': 'Çıkarılıyor', + 'extractDone': 'Çıkarma tamamlandı', + 'extractError': 'Çıkarma başarısız', 'name': 'Ad', 'size': 'Boyut', 'unknown': 'Bilinmeyen', diff --git a/ui/flutter/lib/i18n/langs/uk_ua.dart b/ui/flutter/lib/i18n/langs/uk_ua.dart index 3024847b..d18d7c41 100644 --- a/ui/flutter/lib/i18n/langs/uk_ua.dart +++ b/ui/flutter/lib/i18n/langs/uk_ua.dart @@ -118,6 +118,9 @@ const ukUA = { 'archivePassword': 'Пароль архіву', 'archivePasswordHint': 'Залишити порожнім, якщо архів не захищений паролем', 'deleteAfterExtract': 'Видалити архів після розпакування', + 'extracting': 'Розпакування', + 'extractDone': 'Розпакування завершено', + 'extractError': 'Помилка розпакування', 'name': 'Назва', 'size': 'Розмір', 'unknown': 'Невідомо', diff --git a/ui/flutter/lib/i18n/langs/vi_vn.dart b/ui/flutter/lib/i18n/langs/vi_vn.dart index 5bfc2277..6dd0bc3a 100644 --- a/ui/flutter/lib/i18n/langs/vi_vn.dart +++ b/ui/flutter/lib/i18n/langs/vi_vn.dart @@ -96,6 +96,9 @@ const viVN = { 'archivePassword': 'Mật khẩu tập tin nén', 'archivePasswordHint': 'Để trống nếu không có mật khẩu', 'deleteAfterExtract': 'Xóa tập tin nén sau khi giải nén', + 'extracting': 'Đang giải nén', + 'extractDone': 'Giải nén hoàn tất', + 'extractError': 'Giải nén thất bại', 'insertPlaceholder': 'Chèn placeholder', 'placeholderYear': 'Năm hiện tại', 'placeholderMonth': 'Tháng hiện tại (01-12)', diff --git a/ui/flutter/lib/i18n/langs/zh_cn.dart b/ui/flutter/lib/i18n/langs/zh_cn.dart index eec6c812..ee08e6f3 100644 --- a/ui/flutter/lib/i18n/langs/zh_cn.dart +++ b/ui/flutter/lib/i18n/langs/zh_cn.dart @@ -127,6 +127,9 @@ const zhCN = { 'archivePassword': '压缩包密码', 'archivePasswordHint': '如无密码请留空', 'deleteAfterExtract': '解压后删除压缩包', + 'extracting': '正在解压', + 'extractDone': '解压完成', + 'extractError': '解压失败', 'name': '名称', 'size': '大小', 'unknown': '未知', diff --git a/ui/flutter/lib/i18n/langs/zh_tw.dart b/ui/flutter/lib/i18n/langs/zh_tw.dart index 77a40230..f24614b5 100644 --- a/ui/flutter/lib/i18n/langs/zh_tw.dart +++ b/ui/flutter/lib/i18n/langs/zh_tw.dart @@ -115,6 +115,9 @@ const zhTW = { 'archivePassword': '壓縮包密碼', 'archivePasswordHint': '如無密碼請留空', 'deleteAfterExtract': '解壓後刪除壓縮檔', + 'extracting': '正在解壓', + 'extractDone': '解壓完成', + 'extractError': '解壓失敗', 'name': '名稱', 'size': '大小', 'unknown': '未知',