goget/internal/crypto/crypto_test.go

//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)
			}
		})
	}
}