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

internal/crypto/crypto_test.go

@@ -0,0 +1,190 @@
+//go:build linux || freebsd
+// +build linux freebsd
+
+package crypto
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestNewChecksumVerifier(t *testing.T) {
+	tests := []struct {
+		hashType ChecksumType
+		valid    bool
+	}{
+		{SHA256, true},
+		{SHA512, true},
+		{BLAKE2b, true},
+		{SHA3_256, true},
+		{SHA3_512, true},
+		{MD5, false}, // MD5 is deprecated
+		{"invalid", false},
+	}
+
+	for _, test := range tests {
+		_, err := NewChecksumVerifier(test.hashType, "abc123")
+		if test.valid && err != nil {
+			t.Errorf("NewChecksumVerifier(%s) failed: %v", test.hashType, err)
+		}
+		if !test.valid && err == nil {
+			t.Errorf("NewChecksumVerifier(%s) should have failed", test.hashType)
+		}
+	}
+}
+
+func TestChecksumVerifier(t *testing.T) {
+	// Test SHA-256
+	verifier, err := NewChecksumVerifier(SHA256, "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae")
+	if err != nil {
+		t.Fatalf("Failed to create verifier: %v", err)
+	}
+
+	// Test with string "foo"
+	actual, err := verifier.VerifyReader(strings.NewReader("foo"))
+	if err != nil {
+		t.Fatalf("VerifyReader failed: %v", err)
+	}
+	if actual != "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae" {
+		t.Errorf("Unexpected hash: %s", actual)
+	}
+}
+
+func TestComputeFileChecksum(t *testing.T) {
+	// Create a temp file for testing
+	tmpFile := t.TempDir() + "/test.txt"
+	writeTestFile(tmpFile, "test content")
+
+	hash, err := ComputeFileChecksum(tmpFile, SHA256)
+	if err != nil {
+		t.Fatalf("ComputeFileChecksum failed: %v", err)
+	}
+	if hash == "" {
+		t.Error("Expected non-empty hash")
+	}
+
+	// Verify it's a valid hex string
+	if len(hash) != 64 {
+		t.Errorf("Expected SHA-256 hash length 64, got %d", len(hash))
+	}
+}
+
+func TestComputeFileChecksumTypes(t *testing.T) {
+	tmpFile := t.TempDir() + "/test.txt"
+	writeTestFile(tmpFile, "test")
+
+	tests := []struct {
+		hashType ChecksumType
+		length   int
+	}{
+		{SHA256, 64},
+		{SHA512, 128},
+		{BLAKE2b, 64},
+		{SHA3_256, 64},
+		{SHA3_512, 128},
+	}
+
+	for _, test := range tests {
+		hash, err := ComputeFileChecksum(tmpFile, test.hashType)
+		if err != nil {
+			t.Errorf("ComputeFileChecksum(%s) failed: %v", test.hashType, err)
+			continue
+		}
+		if len(hash) != test.length {
+			t.Errorf("Expected %s hash length %d, got %d", test.hashType, test.length, len(hash))
+		}
+	}
+}
+
+func TestChecksumVerifierType(t *testing.T) {
+	verifier, _ := NewChecksumVerifier(SHA256, "abc")
+	if verifier.Type() != SHA256 {
+		t.Errorf("Expected type SHA256, got %s", verifier.Type())
+	}
+}
+
+func TestChecksumVerifierExpected(t *testing.T) {
+	expected := "abc123def456"
+	verifier, _ := NewChecksumVerifier(SHA256, expected)
+	if verifier.Expected() != expected {
+		t.Errorf("Expected %s, got %s", expected, verifier.Expected())
+	}
+}
+
+func TestChecksumVerifierHasher(t *testing.T) {
+	verifier, _ := NewChecksumVerifier(SHA256, "abc")
+	hasher := verifier.Hasher()
+	if hasher == nil {
+		t.Error("Expected non-nil hasher")
+	}
+}
+
+func writeTestFile(path, content string) {
+	f, _ := os.Create(path)
+	f.WriteString(content)
+	f.Close()
+}
+
+func TestVerifyFileSuccess(t *testing.T) {
+	path := "/tmp/goget_test_verify_ok.tmp"
+	writeTestFile(path, "test data for verification")
+	defer os.Remove(path)
+
+	hash, err := ComputeFileChecksum(path, SHA256)
+	if err != nil {
+		t.Fatalf("ComputeFileChecksum failed: %v", err)
+	}
+
+	verifier, err := NewChecksumVerifier(SHA256, hash)
+	if err != nil {
+		t.Fatalf("NewChecksumVerifier failed: %v", err)
+	}
+
+	match, actual, err := verifier.VerifyFile(path)
+	if err != nil {
+		t.Fatalf("VerifyFile failed: %v", err)
+	}
+	if !match {
+		t.Errorf("unexpected mismatch: expected %s, got %s", hash, actual)
+	}
+}
+
+func TestVerifyFileMismatch(t *testing.T) {
+	path := "/tmp/goget_test_verify_bad.tmp"
+	writeTestFile(path, "correct data")
+	defer os.Remove(path)
+
+	verifier, err := NewChecksumVerifier(SHA256, strings.Repeat("0", 64))
+	if err != nil {
+		t.Fatalf("NewChecksumVerifier failed: %v", err)
+	}
+
+	match, _, err := verifier.VerifyFile(path)
+	if err != nil {
+		t.Fatalf("VerifyFile failed: %v", err)
+	}
+	if match {
+		t.Error("expected checksum mismatch for wrong hash")
+	}
+}
+
+func TestVerifyFileNonexistent(t *testing.T) {
+	verifier, _ := NewChecksumVerifier(SHA256, strings.Repeat("a", 64))
+	_, _, err := verifier.VerifyFile("/nonexistent/path")
+	if err == nil {
+		t.Error("expected error for nonexistent file")
+	}
+}
+
+func TestAllSupportedChecksumTypes(t *testing.T) {
+	types := []ChecksumType{SHA256, SHA512, BLAKE2b, SHA3_256, SHA3_512}
+	for _, ct := range types {
+		t.Run(string(ct), func(t *testing.T) {
+			_, err := NewChecksumVerifier(ct, strings.Repeat("a", 128))
+			if err != nil {
+				t.Errorf("NewChecksumVerifier(%s) failed: %v", ct, err)
+			}
+		})
+	}
+}