gopeed/pkg/download/extension_test.go

package download

import (
	"crypto/md5"
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/GopeedLab/gopeed/internal/logger"
	"github.com/GopeedLab/gopeed/pkg/base"
	gojaerror "github.com/GopeedLab/gopeed/pkg/download/engine/inject/error"
	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
	"github.com/dop251/goja"
)

func TestDownloader_InstallExtensionByFolder(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/basic", false); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("resolve error")
		}
	})
}

func TestDownloader_InstallExtensionByFolderDevMode(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/basic", true); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("resolve error")
		}
	})
}

func TestDownloader_Extension_GBlobBlob(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/blob",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if rr.ID != "" {
			t.Fatalf("expected empty resolve id for extension resource, got %q", rr.ID)
		}

		doneCh := make(chan error, 1)
		downloader.Listener(func(event *Event) {
			if event.Key == EventKeyDone || event.Key == EventKeyError {
				doneCh <- event.Err
			}
		})

		dir := t.TempDir()
		if _, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		}); err != nil {
			t.Fatal(err)
		}

		select {
		case err := <-doneCh:
			if err != nil {
				t.Fatal(err)
			}
		case <-time.After(5 * time.Second):
			t.Fatal("timeout waiting for gblob blob download")
		}

		data, err := os.ReadFile(filepath.Join(dir, "hello.txt"))
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != "hello world" {
			t.Fatalf("unexpected blob download content: %q", string(data))
		}

		waitForDirEmpty(t, filepath.Join(downloader.cfg.StorageDir, "gblob"), 5*time.Second)
	})
}

func TestDownloader_Extension_GBlobReadableStream(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/stream",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if rr.ID != "" {
			t.Fatalf("expected empty resolve id for extension resource, got %q", rr.ID)
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}
		waitForTaskTerminal(t, downloader, id, 5*time.Second)

		data, err := os.ReadFile(filepath.Join(dir, "stream.txt"))
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != "line 1\nline 2\n" {
			t.Fatalf("unexpected stream download content: %q", string(data))
		}
	})
}

func TestDownloader_Extension_GBlobReadableStreamUnknownSize(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/stream-unknown",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if rr.ID != "" {
			t.Fatalf("expected empty resolve id for extension resource, got %q", rr.ID)
		}
		if got := rr.Res.Files[0].Size; got != 0 {
			t.Fatalf("expected unknown size in resolve result, got %d", got)
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		time.Sleep(60 * time.Millisecond)
		task := downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found")
		}
		if task.Status == base.DownloadStatusDone {
			t.Fatal("task finished before writer.close()")
		}
		waitForTaskTerminal(t, downloader, id, 5*time.Second)

		data, err := os.ReadFile(filepath.Join(dir, "stream-unknown.txt"))
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != "line 1\nline 2\n" {
			t.Fatalf("unexpected unknown-size stream content: %q", string(data))
		}

		task = downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found after completion")
		}
		if got := task.Meta.Res.Size; got != int64(len(data)) {
			t.Fatalf("unexpected final task size: got %d want %d", got, len(data))
		}
	})
}

func TestDownloader_Extension_GBlobSourceSizePropagatesToCreatedTask(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/stream",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 1 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}

		file := rr.Res.Files[0]

		dir := t.TempDir()
		id, err := downloader.CreateDirect(file.Req, &base.Options{
			Path: dir,
			Name: file.Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		task := downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found")
		}
		if task.Meta == nil || task.Meta.Res == nil {
			t.Fatal("task meta resource not seeded")
		}
		if got := task.Meta.Res.Size; got != file.Size {
			t.Fatalf("unexpected task size: got %d want %d", got, file.Size)
		}
		if len(task.Meta.Res.Files) != 1 || task.Meta.Res.Files[0].Size != file.Size {
			t.Fatalf("unexpected task file metadata: %#v", task.Meta.Res.Files)
		}

		waitForTaskTerminal(t, downloader, id, 5*time.Second)
	})
}

func TestDownloader_Extension_GBlobReadableStreamRangeResume(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/stream-range",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 1 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}
		if !rr.Res.Range {
			t.Fatal("expected resumable gblob resource")
		}

		file := rr.Res.Files[0]

		dir := t.TempDir()
		id, err := downloader.CreateDirect(file.Req, &base.Options{
			Path: dir,
			Name: file.Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		waitForTaskStatus(t, downloader, id, base.DownloadStatusError, 5*time.Second)

		filePath := filepath.Join(dir, file.Name)
		waitForFileSizeAtLeast(t, filePath, int64(len("line 1\n")), 2*time.Second)
		info, err := os.Stat(filePath)
		if err != nil {
			t.Fatal(err)
		}
		if info.Size() >= file.Size {
			t.Fatalf("expected partial file before resume, got %d want <%d", info.Size(), file.Size)
		}

		task := downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found after first error")
		}
		if task.Meta == nil || task.Meta.Res == nil || !task.Meta.Res.Range {
			t.Fatal("expected resumable task metadata after first error")
		}

		if err := downloader.Continue(&TaskFilter{IDs: []string{id}}); err != nil {
			t.Fatal(err)
		}
		waitForTaskStatus(t, downloader, id, base.DownloadStatusDone, 5*time.Second)

		data, err := os.ReadFile(filePath)
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != "line 1\nline 2\nline 3\n" {
			t.Fatalf("unexpected resumed content: %q", string(data))
		}
	})
}

func TestDownloader_Extension_GBlobHTTPStreamProxy(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		payload := strings.Repeat("gopeed-stream-", 32*1024)
		expectedMD5 := calcExtensionTestMD5(strings.NewReader(payload))
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.Header().Set("Content-Type", "application/octet-stream")
			w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
			flusher, _ := w.(http.Flusher)
			chunkSize := 8192
			for start := 0; start < len(payload); start += chunkSize {
				end := start + chunkSize
				if end > len(payload) {
					end = len(payload)
				}
				if _, err := io.WriteString(w, payload[start:end]); err != nil {
					return
				}
				if flusher != nil {
					flusher.Flush()
				}
				time.Sleep(2 * time.Millisecond)
			}
		}))
		defer server.Close()

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/http-stream?target=" + server.URL + "&name=proxy.bin",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if rr.ID != "" {
			t.Fatalf("expected empty resolve id for extension resource, got %q", rr.ID)
		}
		if len(rr.Res.Files) != 1 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}

		doneCh := make(chan error, 1)
		downloader.Listener(func(event *Event) {
			if event.Key == EventKeyDone || event.Key == EventKeyError {
				doneCh <- event.Err
			}
		})

		dir := t.TempDir()
		if _, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		}); err != nil {
			t.Fatal(err)
		}

		select {
		case err := <-doneCh:
			if err != nil {
				t.Fatal(err)
			}
		case <-time.After(10 * time.Second):
			t.Fatal("timeout waiting for gblob http stream proxy download")
		}

		file, err := os.Open(filepath.Join(dir, "proxy.bin"))
		if err != nil {
			t.Fatal(err)
		}
		defer file.Close()
		if got := calcExtensionTestMD5(file); got != expectedMD5 {
			t.Fatalf("unexpected proxied download md5: got %s want %s", got, expectedMD5)
		}
	})
}

func TestDownloader_Extension_GBlobHTTPStreamProxyReportsDownloadedBeforeCompletion(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		downloader.cfg.RefreshInterval = 50

		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		payload := strings.Repeat("gopeed-progress-", 64*1024)
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Method == http.MethodHead {
				w.Header().Set("Connection", "close")
				w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
				return
			}

			w.Header().Set("Connection", "close")
			w.Header().Set("Content-Type", "application/octet-stream")
			w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
			flusher, _ := w.(http.Flusher)
			chunkSize := 4096
			for start := 0; start < len(payload); start += chunkSize {
				end := start + chunkSize
				if end > len(payload) {
					end = len(payload)
				}
				if _, err := io.WriteString(w, payload[start:end]); err != nil {
					return
				}
				if flusher != nil {
					flusher.Flush()
				}
				time.Sleep(30 * time.Millisecond)
			}
		}))
		defer server.Close()

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/http-stream?target=" + server.URL + "&name=progress.bin",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 1 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		waitForTaskStatus(t, downloader, id, base.DownloadStatusRunning, 2*time.Second)

		deadline := time.Now().Add(2 * time.Second)
		var observed int64
		for time.Now().Before(deadline) {
			task := downloader.GetTask(id)
			if task == nil {
				t.Fatal("task not found")
			}
			observed = task.Progress.Downloaded
			if observed > 0 {
				if task.Status == base.DownloadStatusDone {
					t.Fatal("expected slow proxy task to still be running when intermediate downloaded bytes become visible")
				}
				break
			}
			time.Sleep(20 * time.Millisecond)
		}
		if observed <= 0 {
			_ = downloader.Delete(&TaskFilter{IDs: []string{id}}, true)
			t.Fatalf("expected downloaded bytes > 0 before completion, got %d", observed)
		}

		waitForTaskTerminal(t, downloader, id, 10*time.Second)
	})
}

func TestDownloader_Extension_GBlobHTTPBlobReportsDownloadedBeforeCompletion(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		downloader.cfg.RefreshInterval = 50

		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		payload := strings.Repeat("gopeed-blob-progress-", 64*1024)
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Method == http.MethodHead {
				w.Header().Set("Connection", "close")
				w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
				return
			}

			w.Header().Set("Connection", "close")
			w.Header().Set("Content-Type", "application/octet-stream")
			w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
			flusher, _ := w.(http.Flusher)
			chunkSize := 4096
			for start := 0; start < len(payload); start += chunkSize {
				end := start + chunkSize
				if end > len(payload) {
					end = len(payload)
				}
				if _, err := io.WriteString(w, payload[start:end]); err != nil {
					return
				}
				if flusher != nil {
					flusher.Flush()
				}
				time.Sleep(30 * time.Millisecond)
			}
		}))
		defer server.Close()

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/http-blob?target=" + server.URL + "&name=progress-blob.bin",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 1 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		waitForTaskStatus(t, downloader, id, base.DownloadStatusRunning, 2*time.Second)

		deadline := time.Now().Add(2 * time.Second)
		var observed int64
		for time.Now().Before(deadline) {
			task := downloader.GetTask(id)
			if task == nil {
				t.Fatal("task not found")
			}
			observed = task.Progress.Downloaded
			if observed > 0 {
				if task.Status == base.DownloadStatusDone {
					t.Fatal("expected slow blob task to still be running when intermediate downloaded bytes become visible")
				}
				break
			}
			time.Sleep(20 * time.Millisecond)
		}
		if observed <= 0 {
			_ = downloader.Delete(&TaskFilter{IDs: []string{id}}, true)
			t.Fatalf("expected downloaded bytes > 0 before completion, got %d", observed)
		}

		waitForTaskTerminal(t, downloader, id, 10*time.Second)
	})
}

func TestDownloader_Extension_GBlobHTTPStreamPairReportsDownloadedConcurrently(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		downloader.cfg.RefreshInterval = 50

		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		payload := strings.Repeat("gopeed-pair-progress-", 64*1024)
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Method == http.MethodHead {
				w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
				return
			}

			w.Header().Set("Content-Type", "application/octet-stream")
			w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
			flusher, _ := w.(http.Flusher)
			chunkSize := 4096
			for start := 0; start < len(payload); start += chunkSize {
				end := start + chunkSize
				if end > len(payload) {
					end = len(payload)
				}
				if _, err := io.WriteString(w, payload[start:end]); err != nil {
					return
				}
				if flusher != nil {
					flusher.Flush()
				}
				time.Sleep(25 * time.Millisecond)
			}
		}))
		defer server.Close()

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/http-stream?pair=1&target=" + url.QueryEscape(server.URL),
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 2 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}

		dir := t.TempDir()
		var ids []string
		for _, file := range rr.Res.Files {
			id, err := downloader.CreateDirect(file.Req, &base.Options{
				Path: dir,
				Name: file.Name,
			})
			if err != nil {
				t.Fatal(err)
			}
			ids = append(ids, id)
		}

		for _, id := range ids {
			waitForTaskStatus(t, downloader, id, base.DownloadStatusRunning, 2*time.Second)
		}

		deadline := time.Now().Add(5 * time.Second)
		for time.Now().Before(deadline) {
			task1 := downloader.GetTask(ids[0])
			task2 := downloader.GetTask(ids[1])
			if task1 == nil || task2 == nil {
				t.Fatal("pair task not found")
			}
			if task1.Status == base.DownloadStatusDone && task2.Progress.Downloaded == 0 {
				t.Fatalf("second task never reported downloaded bytes before first completed: task1=%d task2=%d", task1.Progress.Downloaded, task2.Progress.Downloaded)
			}
			if task2.Status == base.DownloadStatusDone && task1.Progress.Downloaded == 0 {
				t.Fatalf("first task never reported downloaded bytes before second completed: task1=%d task2=%d", task1.Progress.Downloaded, task2.Progress.Downloaded)
			}
			if task1.Progress.Downloaded > 0 && task2.Progress.Downloaded > 0 {
				waitForTaskStatus(t, downloader, ids[0], base.DownloadStatusDone, 10*time.Second)
				waitForTaskStatus(t, downloader, ids[1], base.DownloadStatusDone, 10*time.Second)
				return
			}
			time.Sleep(20 * time.Millisecond)
		}

		task1 := downloader.GetTask(ids[0])
		task2 := downloader.GetTask(ids[1])
		t.Fatalf("expected both tasks to report downloaded bytes before completion, got task1=%d task2=%d status1=%s status2=%s", task1.Progress.Downloaded, task2.Progress.Downloaded, task1.Status, task2.Status)
	})
}

func TestDownloader_Extension_GBlobHTTPStreamDeleteWhileDownloading(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		downloader.cfg.RefreshInterval = 50

		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		payload := strings.Repeat("gopeed-delete-", 64*1024)
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Method == http.MethodHead {
				w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
				return
			}

			w.Header().Set("Content-Type", "application/octet-stream")
			w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
			flusher, _ := w.(http.Flusher)
			chunkSize := 4096
			for start := 0; start < len(payload); start += chunkSize {
				end := start + chunkSize
				if end > len(payload) {
					end = len(payload)
				}
				if _, err := io.WriteString(w, payload[start:end]); err != nil {
					return
				}
				if flusher != nil {
					flusher.Flush()
				}
				time.Sleep(20 * time.Millisecond)
			}
		}))
		server.Config.SetKeepAlivesEnabled(false)
		defer server.Close()
		defer server.CloseClientConnections()

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/http-stream?target=" + server.URL + "&name=delete.bin",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 1 {
			t.Fatalf("unexpected resolved file count: %d", len(rr.Res.Files))
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		waitForTaskStatus(t, downloader, id, base.DownloadStatusRunning, 2*time.Second)

		filePath := filepath.Join(dir, rr.Res.Files[0].Name)
		waitForFileSizeAtLeast(t, filePath, 4096, 2*time.Second)

		if err := downloader.Delete(&TaskFilter{IDs: []string{id}}, false); err != nil {
			t.Fatal(err)
		}

		deadline := time.Now().Add(2 * time.Second)
		for time.Now().Before(deadline) {
			if downloader.GetTask(id) == nil {
				waitForDirEmpty(t, filepath.Join(downloader.cfg.StorageDir, "gblob"), 5*time.Second)
				return
			}
			time.Sleep(20 * time.Millisecond)
		}
		t.Fatalf("timeout waiting for task %s to be deleted", id)
	})
}

func TestDownloader_Extension_GBlobHTTPStreamRangePauseAndContinue(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		payload := strings.Repeat("gopeed-range-stream-", 16*1024)
		expectedMD5 := calcExtensionTestMD5(strings.NewReader(payload))
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Method == http.MethodHead {
				w.Header().Set("Accept-Ranges", "bytes")
				w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
				return
			}

			data := []byte(payload)
			start := 0
			status := http.StatusOK
			rangeHeader := r.Header.Get("Range")
			if strings.HasPrefix(rangeHeader, "bytes=") {
				startValue := strings.TrimSuffix(strings.TrimPrefix(rangeHeader, "bytes="), "-")
				parsed, err := strconv.Atoi(startValue)
				if err != nil {
					http.Error(w, err.Error(), http.StatusBadRequest)
					return
				}
				start = parsed
				if start > len(data) {
					w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
					return
				}
				status = http.StatusPartialContent
				w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, len(data)-1, len(data)))
			}

			w.Header().Set("Accept-Ranges", "bytes")
			w.Header().Set("Content-Type", "application/octet-stream")
			w.Header().Set("Content-Length", strconv.Itoa(len(data)-start))
			w.WriteHeader(status)

			flusher, _ := w.(http.Flusher)
			chunkSize := 4096
			for offset := start; offset < len(data); offset += chunkSize {
				end := offset + chunkSize
				if end > len(data) {
					end = len(data)
				}
				if _, err := w.Write(data[offset:end]); err != nil {
					return
				}
				if flusher != nil {
					flusher.Flush()
				}
				time.Sleep(5 * time.Millisecond)
			}
		}))
		defer server.Close()

		rr, err := downloader.Resolve(&base.Request{
			URL: fmt.Sprintf(
				"https://example.com/http-stream-range?target=%s&name=proxy-range.bin&size=%d",
				url.QueryEscape(server.URL),
				len(payload),
			),
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) != 1 || !rr.Res.Range {
			t.Fatalf("unexpected resumable resolve result: %#v", rr.Res)
		}

		file := rr.Res.Files[0]

		dir := t.TempDir()
		id, err := downloader.CreateDirect(file.Req, &base.Options{
			Path: dir,
			Name: file.Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		filePath := filepath.Join(dir, file.Name)
		waitForFileSizeAtLeast(t, filePath, 4096, 5*time.Second)
		if err := downloader.Pause(&TaskFilter{IDs: []string{id}}); err != nil {
			t.Fatal(err)
		}
		waitForTaskStatus(t, downloader, id, base.DownloadStatusPause, 2*time.Second)

		stat, err := os.Stat(filePath)
		if err != nil {
			t.Fatal(err)
		}
		pausedSize := stat.Size()

		time.Sleep(250 * time.Millisecond)

		stat, err = os.Stat(filePath)
		if err != nil {
			t.Fatal(err)
		}
		if stat.Size() != pausedSize {
			t.Fatalf("expected paused file size to remain %d, got %d", pausedSize, stat.Size())
		}

		if err := downloader.Continue(&TaskFilter{IDs: []string{id}}); err != nil {
			t.Fatal(err)
		}
		waitForTaskStatus(t, downloader, id, base.DownloadStatusDone, 10*time.Second)

		output, err := os.Open(filePath)
		if err != nil {
			t.Fatal(err)
		}
		defer output.Close()
		if got := calcExtensionTestMD5(output); got != expectedMD5 {
			t.Fatalf("unexpected resumed range download md5: got %s want %s", got, expectedMD5)
		}
	})
}

func TestDownloader_Extension_GBlobResumeAfterRestartViaOnError(t *testing.T) {
	storageDir := t.TempDir()
	downloadDir := t.TempDir()

	payload := strings.Repeat("gopeed-restart-range-", 16*1024)
	expectedMD5 := calcExtensionTestMD5(strings.NewReader(payload))
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !strings.Contains(r.URL.Path, "/restart-range") {
			http.NotFound(w, r)
			return
		}

		if r.Method == http.MethodHead {
			w.Header().Set("Accept-Ranges", "bytes")
			w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
			return
		}

		data := []byte(payload)
		start := 0
		status := http.StatusOK
		rangeHeader := r.Header.Get("Range")
		if strings.HasPrefix(rangeHeader, "bytes=") {
			startValue := strings.TrimSuffix(strings.TrimPrefix(rangeHeader, "bytes="), "-")
			parsed, err := strconv.Atoi(startValue)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
			start = parsed
			if start > len(data) {
				w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
				return
			}
			status = http.StatusPartialContent
			w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, len(data)-1, len(data)))
		}

		w.Header().Set("Accept-Ranges", "bytes")
		w.Header().Set("Content-Type", "application/octet-stream")
		w.Header().Set("Content-Length", strconv.Itoa(len(data)-start))
		w.WriteHeader(status)

		flusher, _ := w.(http.Flusher)
		chunkSize := 4096
		for offset := start; offset < len(data); offset += chunkSize {
			end := offset + chunkSize
			if end > len(data) {
				end = len(data)
			}
			if _, err := w.Write(data[offset:end]); err != nil {
				return
			}
			if flusher != nil {
				flusher.Flush()
			}
			time.Sleep(20 * time.Millisecond)
		}
	}))
	defer server.Close()

	newDownloader := func() *Downloader {
		downloader := NewDownloader(&DownloaderConfig{
			Storage:    NewBoltStorage(storageDir),
			StorageDir: storageDir,
			DownloaderStoreConfig: &base.DownloaderStoreConfig{
				DownloadDir: downloadDir,
			},
		})
		downloader.cfg.RefreshInterval = 50
		if err := downloader.Setup(); err != nil {
			t.Fatal(err)
		}
		return downloader
	}

	downloader := newDownloader()
	if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob_restart", false); err != nil {
		t.Fatal(err)
	}

	rr, err := downloader.Resolve(&base.Request{
		URL: server.URL + "/restart-range",
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if len(rr.Res.Files) != 1 || !rr.Res.Range {
		t.Fatalf("unexpected resolve result: %#v", rr.Res)
	}

	file := rr.Res.Files[0]
	id, err := downloader.CreateDirect(file.Req, &base.Options{
		Path: downloadDir,
		Name: file.Name,
	})
	if err != nil {
		t.Fatal(err)
	}

	waitForTaskStatus(t, downloader, id, base.DownloadStatusRunning, 2*time.Second)

	deadline := time.Now().Add(2 * time.Second)
	var partialSize int64
	for time.Now().Before(deadline) {
		task := downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found")
		}
		partialSize = task.Progress.Downloaded
		if partialSize > 0 && partialSize < int64(len(payload)) {
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	if partialSize <= 0 || partialSize >= int64(len(payload)) {
		t.Fatalf("expected partial downloaded bytes before restart, got %d", partialSize)
	}

	if err := downloader.Close(); err != nil {
		t.Fatal(err)
	}

	downloader = newDownloader()
	defer func() {
		_ = downloader.Clear()
		os.RemoveAll(storageDir)
		os.RemoveAll(downloadDir)
	}()
	if len(downloader.GetExtensions()) == 0 {
		t.Fatal("expected restored downloader to load extensions")
	}

	task := downloader.GetTask(id)
	if task == nil {
		t.Fatal("restored task not found")
	}
	if task.Status != base.DownloadStatusError {
		t.Fatalf("expected restored gblob task to become error, got %s", task.Status)
	}
	if task.Protocol != "gblob" {
		t.Fatalf("expected restored task protocol gblob, got %s", task.Protocol)
	}
	if task.Meta == nil || task.Meta.Req == nil {
		t.Fatal("restored task request missing")
	}
	if task.Meta.Req.RawURL == "" {
		t.Fatal("restored task raw url missing")
	}
	if task.Meta.Req.Labels == nil || task.Meta.Req.Labels["mode"] != "restart" {
		t.Fatalf("unexpected restored task labels: %#v", task.Meta.Req.Labels)
	}
	oldURL := task.Meta.Req.URL

	if err := downloader.Continue(&TaskFilter{IDs: []string{id}}); err != nil {
		t.Fatal(err)
	}

	deadline = time.Now().Add(2 * time.Second)
	for time.Now().Before(deadline) {
		task = downloader.GetTask(id)
		if task == nil {
			t.Fatal("restored task not found after continue")
		}
		if task.Meta != nil && task.Meta.Req != nil && task.Meta.Req.Labels["started"] != "" {
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	if task == nil || task.Meta == nil || task.Meta.Req == nil || task.Meta.Req.Labels["started"] == "" {
		t.Fatalf("expected onError recovery to run, labels=%#v old=%q current=%q", task.Meta.Req.Labels, oldURL, task.Meta.Req.URL)
	}
	if task.Meta.Req.Labels["rebuilt"] != "true" {
		t.Fatalf("expected onError recovery to rebuild gblob URL, labels=%#v old=%q current=%q rebuildError=%q", task.Meta.Req.Labels, oldURL, task.Meta.Req.URL, task.Meta.Req.Labels["rebuildError"])
	}
	if task.Meta.Req.URL == oldURL {
		t.Fatalf("expected onError recovery to rebuild gblob URL, old=%q current=%q labels=%#v", oldURL, task.Meta.Req.URL, task.Meta.Req.Labels)
	}

	waitForTaskStatus(t, downloader, id, base.DownloadStatusDone, 10*time.Second)

	outputFile, err := os.Open(filepath.Join(downloadDir, file.Name))
	if err != nil {
		t.Fatal(err)
	}
	defer outputFile.Close()
	if got := calcExtensionTestMD5(outputFile); got != expectedMD5 {
		t.Fatalf("unexpected resumed download md5: got %s want %s", got, expectedMD5)
	}
}

func TestDownloader_Extension_GBlobReadableStreamPauseAndContinue(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/stream-unknown",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		filePath := filepath.Join(dir, "stream-unknown.txt")
		waitForFileSizeAtLeast(t, filePath, int64(len("line 1\n")), 2*time.Second)

		if err := downloader.Pause(&TaskFilter{IDs: []string{id}}); err != nil {
			t.Fatal(err)
		}

		task := downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found after pause")
		}
		if task.Status != base.DownloadStatusPause {
			t.Fatalf("expected paused task, got %s", task.Status)
		}

		stat, err := os.Stat(filePath)
		if err != nil {
			t.Fatal(err)
		}
		pausedSize := stat.Size()

		time.Sleep(250 * time.Millisecond)

		stat, err = os.Stat(filePath)
		if err != nil {
			t.Fatal(err)
		}
		if stat.Size() != pausedSize {
			t.Fatalf("expected paused file size to remain %d, got %d", pausedSize, stat.Size())
		}

		if err := downloader.Continue(&TaskFilter{IDs: []string{id}}); err != nil {
			t.Fatal(err)
		}
		waitForTaskTerminal(t, downloader, id, 5*time.Second)

		data, err := os.ReadFile(filePath)
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != "line 1\nline 2\n" {
			t.Fatalf("unexpected pause/continue stream content: %q", string(data))
		}
	})
}

func TestDownloader_Extension_GBlobRecoverOnError(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/gblob_recover", false); err != nil {
			t.Fatal(err)
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://example.com/recover",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}

		dir := t.TempDir()
		id, err := downloader.CreateDirect(rr.Res.Files[0].Req, &base.Options{
			Path: dir,
			Name: rr.Res.Files[0].Name,
		})
		if err != nil {
			t.Fatal(err)
		}

		filePath := filepath.Join(dir, "recover.txt")
		deadline := time.Now().Add(5 * time.Second)
		for time.Now().Before(deadline) {
			task := downloader.GetTask(id)
			if task != nil && task.Status == base.DownloadStatusDone {
				break
			}
			time.Sleep(20 * time.Millisecond)
		}

		task := downloader.GetTask(id)
		if task == nil {
			t.Fatal("task not found after recovery")
		}
		if task.Status != base.DownloadStatusDone {
			var fileSize int64 = -1
			if info, statErr := os.Stat(filePath); statErr == nil {
				fileSize = info.Size()
			}
			t.Fatalf(
				"timeout waiting for recovered gblob download: status=%s downloaded=%d url=%q rawUrl=%q labels=%#v fileSize=%d",
				task.Status,
				task.Progress.Downloaded,
				task.Meta.Req.URL,
				task.Meta.Req.RawURL,
				task.Meta.Req.Labels,
				fileSize,
			)
		}

		data, err := os.ReadFile(filePath)
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != "recovered\n" {
			t.Fatalf("unexpected recovered file content: %q", string(data))
		}

		if task.Status != base.DownloadStatusDone {
			t.Fatalf("expected recovered task done, got %s", task.Status)
		}
		if task.Meta.Req.RawURL != "https://example.com/recover" {
			t.Fatalf("unexpected raw url: %q", task.Meta.Req.RawURL)
		}
	})
}

func TestDownloader_InstallExtensionByGit(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByGit("https://github.com/GopeedLab/gopeed-extension-samples#github-release-sample"); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/GopeedLab/gopeed/releases",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("resolve error")
		}
	})
}

func TestDownloader_InstallExtensionByGitSimple(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByGit("github.com/GopeedLab/gopeed-extension-samples#github-release-sample"); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/GopeedLab/gopeed/releases",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("resolve error")
		}
	})
}

func TestDownloader_InstallExtensionByGitFull(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByGit("https://github.com/GopeedLab/gopeed-extension-samples.git#github-release-sample"); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/GopeedLab/gopeed/releases",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("resolve error")
		}
	})
}

func TestDownloader_UpgradeExtension(t *testing.T) {
	getSetting := func(settings []*Setting, name string) *Setting {
		for _, setting := range settings {
			if setting.Name == name {
				return setting
			}
		}
		return nil
	}

	setupDownloader(func(downloader *Downloader) {
		installedExt, err := downloader.InstallExtensionByFolder("./testdata/extensions/update", false)
		if err != nil {
			t.Fatal(err)
		}
		extensions := downloader.GetExtensions()
		if len(extensions) == 0 {
			t.Fatal("extension not installed")
		}
		oldVersion := installedExt.Version
		// fetch new version from git
		newVersion, err := downloader.UpgradeCheckExtension(installedExt.Identity)
		if err != nil {
			t.Fatal(err)
		}
		if newVersion == "" {
			t.Fatal("new version not found")
		}
		// update extension
		if err = downloader.UpgradeExtension(installedExt.Identity); err != nil {
			t.Fatal(err)
		}
		upgradeExt := downloader.getExtension(installedExt.Identity)
		if upgradeExt.Version == oldVersion {
			t.Fatal("extension update fail")
		}

		// check setting update
		s1 := getSetting(upgradeExt.Settings, "s1")
		if s1.Title == "S1 old" {
			t.Fatal("setting update fail")
		}
		// check setting type update
		s2 := getSetting(upgradeExt.Settings, "s2")
		if s2.Type == "number" {
			t.Fatal("setting type update fail")
		}
		// check setting remove
		d1 := getSetting(upgradeExt.Settings, "d1")
		if d1 != nil {
			t.Fatal("setting remove fail")
		}
		// check setting add
		s3 := getSetting(upgradeExt.Settings, "s3")
		if s3 == nil {
			t.Fatal("setting add fail")
		}

		rr, err := downloader.Resolve(&base.Request{
			URL: "https://test.com",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if rr.Res.Name != "test" {
			t.Fatal("script update fail")
		}
	})
}

func TestDownloader_Extension_OnStart(t *testing.T) {
	downloadAndCheck := func(req *base.Request) {
		setupDownloader(func(downloader *Downloader) {
			if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/on_start", false); err != nil {
				t.Fatal(err)
			}
			errCh := make(chan error, 1)
			downloader.Listener(func(event *Event) {
				if event.Key == EventKeyFinally {
					errCh <- event.Err
				}
			})
			id, err := downloader.CreateDirect(req, nil)
			if err != nil {
				t.Fatal(err)
			}
			select {
			case err = <-errCh:
				break
			case <-time.After(time.Second * 30): // Increased timeout for real network requests
				err = errors.New("timeout")
			}
			if err != nil {
				panic("extension on start download error: " + err.Error())
			}
			task := downloader.GetTask(id)
			if task.Meta.Req.URL != "https://github.com" {
				t.Fatalf("except url: https://github.com, actual: %s", task.Meta.Req.URL)
			}
			if task.Meta.Req.Labels["modified"] != "true" {
				t.Fatalf("except label: modified=true, actual: %s", task.Meta.Req.Labels["modified"])
			}
		})
	}

	// url match
	downloadAndCheck(&base.Request{
		URL: "https://github.com/gopeed/test/404",
	})

	// label match
	downloadAndCheck(&base.Request{
		URL: "https://test.com",
		Labels: map[string]string{
			"test": "true",
		},
	})
}

func TestDownloader_Extension_OnError(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/on_error", false); err != nil {
			t.Fatal(err)
		}
		errCh := make(chan error, 1)
		downloader.Listener(func(event *Event) {
			if event.Key == EventKeyFinally {
				errCh <- event.Err
			}
		})
		id, err := downloader.CreateDirect(&base.Request{
			URL: "https://github.com/gopeed/test/404",
			Labels: map[string]string{
				"test": "true",
			},
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		select {
		case err = <-errCh:
			break
		case <-time.After(time.Second * 30): // Increased timeout for real network requests
			err = errors.New("timeout")
		}

		if err != nil {
			panic("extension on error download error: " + err.Error())
		}
		// extension on error modify url and continue download
		task := downloader.GetTask(id)
		if task.Status != base.DownloadStatusDone {
			t.Fatalf("except status is done, actual: %s", task.Status)
		}
	})
}

func TestDownloader_Extension_OnDone(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/on_done", false); err != nil {
			t.Fatal(err)
		}
		errCh := make(chan error, 1)
		downloader.Listener(func(event *Event) {
			if event.Key == EventKeyFinally {
				errCh <- event.Err
			}
		})
		id, err := downloader.CreateDirect(&base.Request{
			URL: "https://github.com",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		select {
		case err = <-errCh:
			break
		case <-time.After(time.Second * 30): // Increased timeout for real network requests
			err = errors.New("timeout")
		}
		// wait for script execution
		time.Sleep(time.Millisecond * 3000)

		if err != nil {
			panic("extension on done download error: " + err.Error())
		}
		// extension on error modify url and continue download
		task := downloader.GetTask(id)
		if task.Meta.Req.Labels["modified"] != "true" {
			t.Fatalf("except label: modified=true, actual: %s", task.Meta.Req.Labels["modified"])
		}
		if task.Status != base.DownloadStatusDone {
			t.Fatalf("except status is done, actual: %s", task.Status)
		}
	})
}

func TestDownloader_Extension_Errors(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/script_error", false); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 2 {
			t.Fatal("script error catch failed")
		}
	})

	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/function_error", false); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 2 {
			t.Fatal("function error catch failed")
		}
	})

	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/message_error", false); err != nil {
			t.Fatal(err)
		}
		_, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err == nil {
			t.Fatalf("except error, but got nil")
		}
		me, ok := err.(*gojaerror.MessageError)
		if !ok {
			t.Fatalf("except MessageError type, but got %s", err)
		}
		want := "test"
		if me.Error() != want {
			t.Fatalf("except MessageError message %s, but got %s", want, me.Message)
		}
	})
}

func TestDownloader_Extension_Settings(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/settings_empty", false); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("settings parse error")
		}
	})

	setupDownloader(func(downloader *Downloader) {
		installedExt, err := downloader.InstallExtensionByFolder("./testdata/extensions/settings_all", false)
		if err != nil {
			t.Fatal(err)
		}
		downloader.UpdateExtensionSettings(installedExt.Identity, map[string]any{
			"stringValued":  "valued",
			"numberValued":  1.1,
			"booleanValued": true,
		})
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("settings parse error")
		}
	})
}

func TestDownloader_ExtensionStorage(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		if _, err := downloader.InstallExtensionByFolder("./testdata/extensions/storage", false); err != nil {
			t.Fatal(err)
		}
		rr, err := downloader.Resolve(&base.Request{
			URL: "https://github.com/test",
		}, nil)
		if err != nil {
			t.Fatal(err)
		}
		if len(rr.Res.Files) == 1 {
			t.Fatal("resolve error")
		}
	})
}

func TestDownloader_SwitchExtension(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		installedExt, err := downloader.InstallExtensionByFolder("./testdata/extensions/basic", false)
		if err != nil {
			t.Fatal(err)
		}
		if installedExt.Disabled == true {
			t.Fatal("extension disabled")
		}
		if err = downloader.SwitchExtension(installedExt.Identity, false); err != nil {
			t.Fatal(err)
		}
		if installedExt.Disabled == false {
			t.Fatal("extension enabled")
		}
	})
}

func TestDownloader_DeleteExtension(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		installedExt, err := downloader.InstallExtensionByFolder("./testdata/extensions/settings_all", false)
		if err != nil {
			t.Fatal(err)
		}
		extensions := downloader.GetExtensions()
		if err := downloader.DeleteExtension(installedExt.Identity); err != nil {
			t.Fatal(err)
		}
		extensions = downloader.GetExtensions()
		if len(extensions) != 0 {
			t.Fatal("extension delete fail")
		}
	})
}

func TestDownloader_Extension_Logger(t *testing.T) {
	logger := logger.NewLogger(false, "")
	il := newInstanceLogger(&Extension{
		Name: "test",
	}, logger)
	il.Debug(goja.NaN(), goja.Undefined())
	il.Info(goja.NaN(), goja.Undefined())
	il.Warn(goja.NaN(), goja.Undefined())
	il.Error(goja.NaN(), goja.Undefined())
}

func TestDownloader_ExtensionRuntimeWebViewInjected(t *testing.T) {
	downloader, cleanup, err := newTestExtensionEngineDownloader()
	if err != nil {
		t.Fatal(err)
	}
	defer cleanup()

	runtime, err := newTestExtensionEngine(t, downloader)
	if err != nil {
		t.Fatal(err)
	}
	defer runtime.Close()

	value, err := runtime.Eval(`({
		hasRuntime: !!gopeed.runtime,
		hasWebView: !!(gopeed.runtime && gopeed.runtime.webview),
		hasOpen: typeof gopeed.runtime.webview.open,
		hasWebViewIsAvailable: typeof gopeed.runtime.webview.isAvailable,
		webViewAvailable: gopeed.runtime.webview.isAvailable()
	})`)
	if err != nil {
		t.Fatal(err)
	}

	result, ok := value.(map[string]any)
	if !ok {
		t.Fatalf("unexpected eval result type: %T", value)
	}
	if result["hasRuntime"] != true {
		t.Fatalf("expected runtime injection, got %#v", result)
	}
	if result["hasWebView"] != true {
		t.Fatalf("expected webview injection, got %#v", result)
	}
	if result["hasOpen"] != "function" || result["hasWebViewIsAvailable"] != "function" {
		t.Fatalf("expected webview api functions, got %#v", result)
	}
	if result["webViewAvailable"] != false {
		t.Fatalf("expected unavailable webview runtime by default, got %#v", result["webViewAvailable"])
	}
}

func TestDownloader_ExtensionRuntimeWebViewAvailabilityFromProvider(t *testing.T) {
	downloader := NewDownloader(&DownloaderConfig{
		Storage: NewMemStorage(),
		WebViewProvider: fakeExtensionWebViewProvider{
			available: true,
			opener:    &fakeRuntimeWebViewOpener{},
		},
	})
	if err := downloader.Setup(); err != nil {
		t.Fatal(err)
	}
	defer downloader.Clear()

	runtime, err := newTestExtensionEngine(t, downloader)
	if err != nil {
		t.Fatal(err)
	}
	defer runtime.Close()

	value, err := runtime.Eval(`gopeed.runtime.webview.isAvailable()`)
	if err != nil {
		t.Fatal(err)
	}
	if value != true {
		t.Fatalf("expected available webview runtime, got %#v", value)
	}
}

func TestDownloader_ExtensionRuntimeWebViewPageMethodsInjected(t *testing.T) {
	downloader := NewDownloader(&DownloaderConfig{
		Storage: NewMemStorage(),
		WebViewProvider: fakeExtensionWebViewProvider{
			available: true,
			opener:    &fakeRuntimeWebViewOpener{},
		},
	})
	if err := downloader.Setup(); err != nil {
		t.Fatal(err)
	}
	defer downloader.Clear()

	runtime, err := newTestExtensionEngine(t, downloader)
	if err != nil {
		t.Fatal(err)
	}
	defer runtime.Close()

	value, err := runtime.Eval(`(async () => {
		const page = await gopeed.runtime.webview.open();
		return {
			hasFocus: typeof page.focus,
			hasClick: typeof page.click,
			hasType: typeof page.type,
			hasWaitForSelector: typeof page.waitForSelector,
			hasWaitForFunction: typeof page.waitForFunction,
			hasWaitForLoad: typeof page.waitForLoad,
		};
	})()`)
	if err != nil {
		t.Fatal(err)
	}

	result, ok := value.(map[string]any)
	if !ok {
		t.Fatalf("unexpected page methods result type: %T", value)
	}
	for _, key := range []string{
		"hasFocus",
		"hasClick",
		"hasType",
		"hasWaitForSelector",
		"hasWaitForFunction",
	} {
		if result[key] != "function" {
			t.Fatalf("expected %s to be a function, got %#v", key, result[key])
		}
	}
	if result["hasWaitForLoad"] != "undefined" {
		t.Fatalf("expected hasWaitForLoad to be undefined, got %#v", result["hasWaitForLoad"])
	}
}

func TestDownloader_ExtensionRuntimeWebViewExecuteAnonymousFunction(t *testing.T) {
	opener := &capturingRuntimeWebViewOpener{
		page: &capturingRuntimeWebViewPage{
			executeValue: map[string]any{
				"title":      "Hello",
				"url":        "https://example.com",
				"userAgent":  "UA",
				"readyState": "complete",
			},
		},
	}
	downloader := NewDownloader(&DownloaderConfig{
		Storage: NewMemStorage(),
		WebViewProvider: fakeExtensionWebViewProvider{
			available: true,
			opener:    opener,
		},
	})
	if err := downloader.Setup(); err != nil {
		t.Fatal(err)
	}
	defer downloader.Clear()

	runtime, err := newTestExtensionEngine(t, downloader)
	if err != nil {
		t.Fatal(err)
	}
	defer runtime.Close()

	value, err := runtime.Eval(`(async () => {
		const page = await gopeed.runtime.webview.open();
		return await page.execute(() => ({
			title: document.title || "",
			url: String(location.href || ""),
			userAgent: navigator.userAgent,
			readyState: document.readyState,
		}));
	})()`)
	if err != nil {
		t.Fatal(err)
	}
	result, ok := value.(map[string]any)
	if !ok {
		t.Fatalf("unexpected execute result type: %T", value)
	}
	if result["title"] != "Hello" || result["readyState"] != "complete" {
		t.Fatalf("unexpected execute result: %#v", result)
	}
	expected := `(() => ({
			title: document.title || "",
			url: String(location.href || ""),
			userAgent: navigator.userAgent,
			readyState: document.readyState,
		}))`
	if opener.page.lastExecuteSource != expected {
		t.Fatalf("unexpected execute source: %q", opener.page.lastExecuteSource)
	}
}

func TestDownloader_TriggerOnResolve_DetachedAsyncWorkDoesNotBlock(t *testing.T) {
	setupDownloader(func(downloader *Downloader) {
		extDir := t.TempDir()
		manifest := `{
  "name": "detached-async-resolve",
  "author": "gopeed",
  "title": "Detached Async Resolve",
  "version": "0.0.1",
  "scripts": [
    {
      "event": "onResolve",
      "match": {
        "urls": ["*://example.com/*"]
      },
      "entry": "index.js"
    }
  ]
}`
		script := `gopeed.events.onResolve(async (ctx) => {
  (async () => {
    await new Promise((resolve) => setTimeout(resolve, 500));
    globalThis.__detachedDone = true;
  })();
  ctx.res = {
    name: 'done',
    files: [
      {
        name: 'out.txt',
        req: {
          url: 'https://example.com/file.txt'
        }
      }
    ]
  };
});`
		if err := os.WriteFile(filepath.Join(extDir, "manifest.json"), []byte(manifest), 0644); err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(filepath.Join(extDir, "index.js"), []byte(script), 0644); err != nil {
			t.Fatal(err)
		}
		if _, err := downloader.InstallExtensionByFolder(extDir, false); err != nil {
			t.Fatal(err)
		}

		type result struct {
			res *base.Resource
			err error
		}
		done := make(chan result, 1)
		startedAt := time.Now()
		go func() {
			res, err := downloader.triggerOnResolve(&base.Request{URL: "https://example.com/test"})
			done <- result{res: res, err: err}
		}()

		select {
		case out := <-done:
			if out.err != nil {
				t.Fatal(out.err)
			}
			if time.Since(startedAt) > 200*time.Millisecond {
				t.Fatalf("triggerOnResolve blocked for %s", time.Since(startedAt))
			}
			if out.res == nil || len(out.res.Files) != 1 {
				t.Fatalf("unexpected resource: %#v", out.res)
			}
		case <-time.After(1 * time.Second):
			t.Fatal("timeout waiting for triggerOnResolve")
		}
	})
}

type fakeExtensionWebViewProvider struct {
	available bool
	opener    enginewebview.Opener
}

func (p fakeExtensionWebViewProvider) IsAvailable() bool {
	return p.available
}

func (p fakeExtensionWebViewProvider) Open(opts enginewebview.OpenOptions) (enginewebview.Page, error) {
	if p.opener == nil {
		return nil, nil
	}
	return p.opener.Open(opts)
}

type fakeRuntimeWebViewOpener struct{}

func (fakeRuntimeWebViewOpener) Open(enginewebview.OpenOptions) (enginewebview.Page, error) {
	return fakeRuntimeWebViewPage{}, nil
}

type fakeRuntimeWebViewPage struct{}

func (fakeRuntimeWebViewPage) AddInitScript(string) error {
	return nil
}

func (fakeRuntimeWebViewPage) Goto(string, enginewebview.GotoOptions) error {
	return nil
}

func (fakeRuntimeWebViewPage) Execute(string, ...any) (any, error) {
	return nil, nil
}

func (fakeRuntimeWebViewPage) GetCookies() ([]enginewebview.Cookie, error) {
	return nil, nil
}

func (fakeRuntimeWebViewPage) SetCookie(enginewebview.Cookie) error {
	return nil
}

func (fakeRuntimeWebViewPage) DeleteCookie(enginewebview.Cookie) error {
	return nil
}

func (fakeRuntimeWebViewPage) ClearCookies() error {
	return nil
}

func (fakeRuntimeWebViewPage) Close() error {
	return nil
}

type capturingRuntimeWebViewOpener struct {
	page *capturingRuntimeWebViewPage
}

func (o *capturingRuntimeWebViewOpener) Open(enginewebview.OpenOptions) (enginewebview.Page, error) {
	return o.page, nil
}

type capturingRuntimeWebViewPage struct {
	lastExecuteSource string
	lastExecuteArgs   []any
	executeValue      any
}

func (p *capturingRuntimeWebViewPage) AddInitScript(string) error {
	return nil
}

func (p *capturingRuntimeWebViewPage) Goto(string, enginewebview.GotoOptions) error {
	return nil
}

func (p *capturingRuntimeWebViewPage) Execute(expression string, args ...any) (any, error) {
	p.lastExecuteSource = expression
	p.lastExecuteArgs = args
	return p.executeValue, nil
}

func (p *capturingRuntimeWebViewPage) GetCookies() ([]enginewebview.Cookie, error) {
	return nil, nil
}

func (p *capturingRuntimeWebViewPage) SetCookie(enginewebview.Cookie) error {
	return nil
}

func (p *capturingRuntimeWebViewPage) DeleteCookie(enginewebview.Cookie) error {
	return nil
}

func (p *capturingRuntimeWebViewPage) ClearCookies() error {
	return nil
}

func (p *capturingRuntimeWebViewPage) Close() error {
	return nil
}

func setupDownloader(fn func(downloader *Downloader)) {
	storageDir, err := os.MkdirTemp("", "gopeed-test-storage-")
	if err != nil {
		panic(err)
	}
	downloadDir, err := os.MkdirTemp("", "gopeed-test-download-")
	if err != nil {
		_ = os.RemoveAll(storageDir)
		panic(err)
	}
	downloader := NewDownloader(&DownloaderConfig{
		StorageDir: storageDir,
	})
	if err := downloader.Setup(); err != nil {
		_ = os.RemoveAll(storageDir)
		_ = os.RemoveAll(downloadDir)
		panic(err)
	}
	cfg, err := downloader.GetConfig()
	if err != nil {
		_ = os.RemoveAll(storageDir)
		_ = os.RemoveAll(downloadDir)
		panic(err)
	}
	cfg.DownloadDir = downloadDir
	if err := downloader.PutConfig(cfg); err != nil {
		_ = os.RemoveAll(storageDir)
		_ = os.RemoveAll(downloadDir)
		panic(err)
	}
	defer func() {
		downloader.Clear()
		os.RemoveAll(downloader.cfg.StorageDir)
		os.RemoveAll(downloadDir)
	}()
	fn(downloader)
}

func newTestExtensionEngineDownloader() (*Downloader, func(), error) {
	downloader := NewDownloader(&DownloaderConfig{
		Storage: NewMemStorage(),
	})
	if err := downloader.Setup(); err != nil {
		return nil, nil, err
	}
	cleanup := func() {
		_ = downloader.Clear()
	}
	return downloader, cleanup, nil
}

func newTestExtensionEngine(t *testing.T, downloader *Downloader) (*ExtensionEngine, error) {
	t.Helper()
	return downloader.NewExtensionEngine(&Extension{
		Name:    "test-runtime",
		Author:  "gopeed",
		Title:   "Gopeed Test Script Runtime",
		Version: "0.0.0",
		DevMode: true,
	}, map[string]any{})
}

func waitForFileSizeAtLeast(t *testing.T, path string, size int64, timeout time.Duration) {
	t.Helper()
	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		info, err := os.Stat(path)
		if err == nil && info.Size() >= size {
			return
		}
		time.Sleep(10 * time.Millisecond)
	}
	t.Fatalf("timeout waiting for file %s size >= %d", path, size)
}

func waitForTaskTerminal(t *testing.T, downloader *Downloader, id string, timeout time.Duration) {
	t.Helper()
	doneCh := make(chan error, 1)
	downloader.Listener(func(event *Event) {
		if event.Task == nil || event.Task.ID != id {
			return
		}
		if event.Key == EventKeyDone || event.Key == EventKeyError {
			select {
			case doneCh <- event.Err:
			default:
			}
		}
	})

	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		task := downloader.GetTask(id)
		if task != nil {
			switch task.Status {
			case base.DownloadStatusDone:
				return
			case base.DownloadStatusError:
				select {
				case err := <-doneCh:
					if err == nil {
						t.Fatalf("task %s ended with error status", id)
					}
					t.Fatal(err)
				default:
					t.Fatalf("task %s ended with error status", id)
				}
			}
		}
		select {
		case err := <-doneCh:
			if err != nil {
				t.Fatal(err)
			}
			return
		case <-time.After(10 * time.Millisecond):
		}
	}

	select {
	case err := <-doneCh:
		if err != nil {
			t.Fatal(err)
		}
	case <-time.After(timeout):
		task := downloader.GetTask(id)
		if task == nil {
			t.Fatalf("timeout waiting for task %s: task not found", id)
		}
		t.Fatalf("timeout waiting for task %s: status=%s downloaded=%d total=%d", id, task.Status, task.Progress.Downloaded, task.Meta.Res.Size)
	}
}

func waitForTaskStatus(t *testing.T, downloader *Downloader, id string, status base.Status, timeout time.Duration) {
	t.Helper()
	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		task := downloader.GetTask(id)
		if task != nil && task.Status == status {
			return
		}
		time.Sleep(10 * time.Millisecond)
	}
	task := downloader.GetTask(id)
	if task == nil {
		t.Fatalf("timeout waiting for task %s status %s: task not found", id, status)
	}
	t.Fatalf("timeout waiting for task %s status %s: got %s", id, status, task.Status)
}

func waitForDirEmpty(t *testing.T, path string, timeout time.Duration) {
	t.Helper()
	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		entries, err := os.ReadDir(path)
		if err == nil && len(entries) == 0 {
			return
		}
		if errors.Is(err, os.ErrNotExist) {
			return
		}
		time.Sleep(10 * time.Millisecond)
	}
	entries, err := os.ReadDir(path)
	if err != nil && errors.Is(err, os.ErrNotExist) {
		return
	}
	t.Fatalf("timeout waiting for directory %s to become empty, entries=%d err=%v", path, len(entries), err)
}

func calcExtensionTestMD5(reader io.Reader) string {
	hash := md5.New()
	if _, err := io.Copy(hash, reader); err != nil {
		return ""
	}
	return hex.EncodeToString(hash.Sum(nil))
}