feat: initial goget release — modern IPv6-first download utility

2026-06-26 21:21:58 +02:00
commit 53db81e1f7
147 changed files with 45931 additions and 0 deletions
@@ -0,0 +1,338 @@
+//go:build linux || freebsd
+// +build linux freebsd
+
+package config
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"codeberg.org/petrbalvin/interpres"
+)
+
+func TestDefaultConfig(t *testing.T) {
+	cfg := DefaultConfig()
+
+	if cfg.Timeout != 30*time.Minute {
+		t.Errorf("Expected default timeout 30m, got %v", cfg.Timeout)
+	}
+	if cfg.Parallel != 0 {
+		t.Errorf("Expected default parallel 0, got %d", cfg.Parallel)
+	}
+	if cfg.Verbose != true {
+		t.Errorf("Expected default verbose true, got %v", cfg.Verbose)
+	}
+	if cfg.AutoDecompress != true {
+		t.Errorf("Expected default auto decompress true, got %v", cfg.AutoDecompress)
+	}
+	if cfg.ChecksumAlgo != "sha256" {
+		t.Errorf("Expected default checksum algo sha256, got %s", cfg.ChecksumAlgo)
+	}
+}
+
+func TestConfigMerge(t *testing.T) {
+	cfg := DefaultConfig()
+
+	cfg.Merge(&CLIFlags{
+		Timeout:         1 * time.Hour,
+		Parallel:        4,
+		Verbose:         true,
+		Debug:           false,
+		MaxSpeed:        1024 * 1024,
+		Proxy:           "http://proxy",
+		NoIPv4:          false,
+		NoDecompress:    false,
+		Username:        "user",
+		Password:        "pass",
+		CookieJar:       "",
+		Recursive:       false,
+		MaxDepth:        0,
+		FollowExternal:  false,
+		ExcludePatterns: nil,
+		Extract:         false,
+		ExtractDir:      "",
+		StripComponents: 0,
+	})
+
+	if cfg.Timeout != 1*time.Hour {
+		t.Errorf("Expected timeout 1h, got %v", cfg.Timeout)
+	}
+	if cfg.Parallel != 4 {
+		t.Errorf("Expected parallel 4, got %d", cfg.Parallel)
+	}
+	if cfg.Proxy != "http://proxy" {
+		t.Errorf("Expected proxy http://proxy, got %s", cfg.Proxy)
+	}
+	if cfg.Auth.Username != "user" {
+		t.Errorf("Expected username user, got %s", cfg.Auth.Username)
+	}
+}
+
+func TestGetEffectiveTimeout(t *testing.T) {
+	cfg := DefaultConfig()
+
+	// User override
+	timeout := cfg.GetEffectiveTimeout(1000000, 1*time.Hour)
+	if timeout != 1*time.Hour {
+		t.Errorf("Expected 1h with user override, got %v", timeout)
+	}
+
+	// Auto calculation for known size
+	timeout = cfg.GetEffectiveTimeout(100*1024*1024, 0)
+	if timeout < 30*time.Second {
+		t.Errorf("Expected at least 30s for auto timeout, got %v", timeout)
+	}
+
+	// Unknown size
+	timeout = cfg.GetEffectiveTimeout(-1, 0)
+	if timeout != 30*time.Minute {
+		t.Errorf("Expected 30m for unknown size, got %v", timeout)
+	}
+}
+
+func TestGetParallelConnections(t *testing.T) {
+	cfg := DefaultConfig()
+
+	// Explicit parallel
+	cfg.Parallel = 8
+	if cfg.GetParallelConnections(1000) != 8 {
+		t.Errorf("Expected 8 explicit connections, got %d", cfg.GetParallelConnections(1000))
+	}
+
+	// Auto for large file
+	cfg.Parallel = 0
+	if cfg.GetParallelConnections(200*1024*1024) != 4 {
+		t.Errorf("Expected 4 auto connections for large file, got %d", cfg.GetParallelConnections(200*1024*1024))
+	}
+
+	// Auto for small file
+	if cfg.GetParallelConnections(1024) != 1 {
+		t.Errorf("Expected 1 connection for small file, got %d", cfg.GetParallelConnections(1024))
+	}
+}
+
+func TestShouldUseColors(t *testing.T) {
+	cfg := DefaultConfig()
+
+	// Always
+	cfg.Color = "always"
+	if !cfg.ShouldUseColors() {
+		t.Error("Expected colors with always setting")
+	}
+
+	// Never
+	cfg.Color = "never"
+	if cfg.ShouldUseColors() {
+		t.Error("Expected no colors with never setting")
+	}
+
+	// Auto (default)
+	cfg.Color = "auto"
+	// Can't test environment in unit tests, but verify it doesn't panic
+	_ = cfg.ShouldUseColors()
+}
+
+func TestIsExcluded(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.Recursive.ExcludePatterns = []string{"example.com", "test.org"}
+
+	if !cfg.IsExcluded("https://example.com/file.zip") {
+		t.Error("Expected example.com to be excluded")
+	}
+	if !cfg.IsExcluded("https://test.org/file.zip") {
+		t.Error("Expected test.org to be excluded")
+	}
+	if cfg.IsExcluded("https://other.com/file.zip") {
+		t.Error("Expected other.com to not be excluded")
+	}
+}
+
+func TestGetRecursiveDelay(t *testing.T) {
+	cfg := DefaultConfig()
+
+	delay := cfg.GetRecursiveDelay()
+	if delay != 100*time.Millisecond {
+		t.Errorf("Expected default delay 100ms, got %v", delay)
+	}
+
+	cfg.Recursive.Delay = "500ms"
+	delay = cfg.GetRecursiveDelay()
+	if delay != 500*time.Millisecond {
+		t.Errorf("Expected delay 500ms, got %v", delay)
+	}
+
+	// Invalid delay should fall back to default
+	cfg.Recursive.Delay = "invalid"
+	delay = cfg.GetRecursiveDelay()
+	if delay != 100*time.Millisecond {
+		t.Errorf("Expected default delay for invalid value, got %v", delay)
+	}
+}
+
+func TestGetExtractOutputDir(t *testing.T) {
+	cfg := DefaultConfig()
+
+	// Empty config should return default
+	dir := cfg.GetExtractOutputDir("/default")
+	if dir != "/default" {
+		t.Errorf("Expected /default, got %s", dir)
+	}
+
+	// Config with output dir
+	cfg.Extract.OutputDir = "/custom"
+	dir = cfg.GetExtractOutputDir("/default")
+	if dir != "/custom" {
+		t.Errorf("Expected /custom, got %s", dir)
+	}
+}
+
+func TestParseSpeed(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int64
+	}{
+		{"", 0},
+		{"0", 0},
+		{"100", 100},
+		{"100B/s", 100},
+		{"1KB/s", 1000},
+		{"1MB/s", 1000000},
+		{"1GB/s", 1000000000},
+		{"10MB/s", 10000000},
+		{"100 KB/s", 100000},
+	}
+
+	for _, test := range tests {
+		result := ParseSpeed(test.input)
+		if result != test.expected {
+			t.Errorf("ParseSpeed(%s) = %d, expected %d", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestExpandTilde(t *testing.T) {
+	// Test with tilde
+	path := expandTilde("~/test/file.txt")
+	if path == "~/test/file.txt" {
+		t.Error("Expected tilde to be expanded")
+	}
+
+	// Test without tilde
+	path = expandTilde("/absolute/path/file.txt")
+	if path != "/absolute/path/file.txt" {
+		t.Errorf("Expected unchanged path, got %s", path)
+	}
+}
+
+func TestConfigSave(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.Verbose = true
+	cfg.Parallel = 4
+
+	// Save should not fail (may create directories)
+	err := cfg.Save()
+	// We can't test the actual file creation in unit tests without a temp dir
+	// but we verify the method doesn't panic
+	_ = err
+}
+
+func TestLoadNonExistentConfig(t *testing.T) {
+	cfg, err := Load("/nonexistent/path/config.toml")
+	if err != nil {
+		t.Fatalf("Expected no error for non-existent config, got %v", err)
+	}
+	if cfg == nil {
+		t.Fatal("Expected default config for non-existent file")
+	}
+}
+
+func TestMarshalUnmarshalTOML(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.Parallel = 4
+	cfg.Verbose = true
+	cfg.Timeout = 5 * time.Minute
+	cfg.Auth.Username = "testuser"
+	cfg.Auth.AuthType = "basic"
+	cfg.Recursive.Enabled = true
+	cfg.Recursive.MaxDepth = 5
+	cfg.DNSServers = []string{"1.1.1.1", "8.8.8.8"}
+
+	data, err := interpres.Marshal(*cfg)
+	if err != nil {
+		t.Fatalf("interpres.Marshal failed: %v", err)
+	}
+
+	tomlStr := string(data)
+	// Verify key elements are present
+	if !strings.Contains(tomlStr, "parallel = 4") {
+		t.Errorf("expected 'parallel = 4' in TOML output, got:\n%s", tomlStr)
+	}
+	if !strings.Contains(tomlStr, "verbose = true") {
+		t.Errorf("expected 'verbose = true' in TOML output, got:\n%s", tomlStr)
+	}
+	if !strings.Contains(tomlStr, "[auth]") {
+		t.Errorf("expected '[auth]' section in TOML output, got:\n%s", tomlStr)
+	}
+	if !strings.Contains(tomlStr, "username = \"testuser\"") {
+		t.Errorf("expected 'username = \"testuser\"' in TOML output, got:\n%s", tomlStr)
+	}
+	if !strings.Contains(tomlStr, "[recursive]") {
+		t.Errorf("expected '[recursive]' section in TOML output, got:\n%s", tomlStr)
+	}
+	if !strings.Contains(tomlStr, "dns_servers = [") {
+		t.Errorf("expected 'dns_servers' array in TOML output, got:\n%s", tomlStr)
+	}
+
+	// Roundtrip: unmarshal back and verify
+	var cfg2 Config
+	if err := interpres.Unmarshal(data, &cfg2); err != nil {
+		t.Fatalf("interpres.Unmarshal failed: %v", err)
+	}
+
+	if cfg2.Parallel != 4 {
+		t.Errorf("roundtrip: expected Parallel 4, got %d", cfg2.Parallel)
+	}
+	if cfg2.Verbose != true {
+		t.Errorf("roundtrip: expected Verbose true, got %v", cfg2.Verbose)
+	}
+	if cfg2.Auth.Username != "testuser" {
+		t.Errorf("roundtrip: expected Auth.Username testuser, got %s", cfg2.Auth.Username)
+	}
+	if cfg2.Recursive.MaxDepth != 5 {
+		t.Errorf("roundtrip: expected Recursive.MaxDepth 5, got %d", cfg2.Recursive.MaxDepth)
+	}
+	if len(cfg2.DNSServers) != 2 || cfg2.DNSServers[0] != "1.1.1.1" {
+		t.Errorf("roundtrip: expected DNSServers [1.1.1.1, 8.8.8.8], got %v", cfg2.DNSServers)
+	}
+}
+
+func TestMarshalTOMLDefaultConfig(t *testing.T) {
+	cfg := DefaultConfig()
+	data, err := interpres.Marshal(*cfg)
+	if err != nil {
+		t.Fatalf("interpres.Marshal with default config failed: %v", err)
+	}
+	if len(data) == 0 {
+		t.Error("expected non-empty TOML output for default config")
+	}
+
+	// Verify it can be parsed back
+	var cfg2 Config
+	if err := interpres.Unmarshal(data, &cfg2); err != nil {
+		t.Fatalf("interpres.Unmarshal of default output failed: %v", err)
+	}
+	if cfg2.OutputDir != "." {
+		t.Errorf("expected OutputDir '.', got %s", cfg2.OutputDir)
+	}
+	if cfg2.ChecksumAlgo != "sha256" {
+		t.Errorf("expected ChecksumAlgo sha256, got %s", cfg2.ChecksumAlgo)
+	}
+}
+
+func TestConfigPath(t *testing.T) {
+	cfg := DefaultConfig()
+	path := cfg.Path()
+	// Path should be empty when loaded with DefaultConfig
+	_ = path
+}