216 lines
6.6 KiB
Python
216 lines
6.6 KiB
Python
"""
|
|
Unit tests for SHA256 hash calculation and deduplication logic.
|
|
|
|
Tests cover:
|
|
- Hash computation produces consistent results
|
|
- Hash is always 64 character lowercase hexadecimal
|
|
- Different content produces different hashes
|
|
- Binary content handling
|
|
- Large file handling (streaming)
|
|
"""
|
|
|
|
import pytest
|
|
import hashlib
|
|
import io
|
|
from tests.conftest import (
|
|
create_test_file,
|
|
compute_sha256,
|
|
TEST_CONTENT_HELLO,
|
|
TEST_HASH_HELLO,
|
|
TEST_CONTENT_BINARY,
|
|
TEST_HASH_BINARY,
|
|
)
|
|
|
|
|
|
class TestHashComputation:
|
|
"""Unit tests for hash calculation functionality."""
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_consistent_results(self):
|
|
"""Test SHA256 hash produces consistent results for identical content."""
|
|
content = b"test content for hashing"
|
|
|
|
# Compute hash multiple times
|
|
hash1 = compute_sha256(content)
|
|
hash2 = compute_sha256(content)
|
|
hash3 = compute_sha256(content)
|
|
|
|
assert hash1 == hash2 == hash3
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_different_content_different_hash(self):
|
|
"""Test SHA256 produces different hashes for different content."""
|
|
content1 = b"content version 1"
|
|
content2 = b"content version 2"
|
|
|
|
hash1 = compute_sha256(content1)
|
|
hash2 = compute_sha256(content2)
|
|
|
|
assert hash1 != hash2
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_format_64_char_hex(self):
|
|
"""Test SHA256 hash is always 64 character lowercase hexadecimal."""
|
|
test_cases = [
|
|
b"", # Empty
|
|
b"a", # Single char
|
|
b"Hello, World!", # Normal string
|
|
bytes(range(256)), # All byte values
|
|
b"x" * 10000, # Larger content
|
|
]
|
|
|
|
for content in test_cases:
|
|
hash_value = compute_sha256(content)
|
|
|
|
# Check length
|
|
assert len(hash_value) == 64, (
|
|
f"Hash length should be 64, got {len(hash_value)}"
|
|
)
|
|
|
|
# Check lowercase
|
|
assert hash_value == hash_value.lower(), "Hash should be lowercase"
|
|
|
|
# Check hexadecimal
|
|
assert all(c in "0123456789abcdef" for c in hash_value), (
|
|
"Hash should be hex"
|
|
)
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_known_value(self):
|
|
"""Test SHA256 produces expected hash for known input."""
|
|
assert compute_sha256(TEST_CONTENT_HELLO) == TEST_HASH_HELLO
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_binary_content(self):
|
|
"""Test SHA256 handles binary content correctly."""
|
|
assert compute_sha256(TEST_CONTENT_BINARY) == TEST_HASH_BINARY
|
|
|
|
# Test with null bytes
|
|
content_with_nulls = b"\x00\x00test\x00\x00"
|
|
hash_value = compute_sha256(content_with_nulls)
|
|
assert len(hash_value) == 64
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_streaming_computation(self):
|
|
"""Test SHA256 can be computed in chunks (streaming)."""
|
|
# Large content
|
|
chunk_size = 8192
|
|
total_size = chunk_size * 10 # 80KB
|
|
content = b"x" * total_size
|
|
|
|
# Direct computation
|
|
direct_hash = compute_sha256(content)
|
|
|
|
# Streaming computation
|
|
hasher = hashlib.sha256()
|
|
for i in range(0, total_size, chunk_size):
|
|
hasher.update(content[i : i + chunk_size])
|
|
streaming_hash = hasher.hexdigest()
|
|
|
|
assert direct_hash == streaming_hash
|
|
|
|
@pytest.mark.unit
|
|
def test_sha256_order_matters(self):
|
|
"""Test that content order affects hash (not just content set)."""
|
|
content1 = b"AB"
|
|
content2 = b"BA"
|
|
|
|
assert compute_sha256(content1) != compute_sha256(content2)
|
|
|
|
|
|
class TestStorageHashComputation:
|
|
"""Tests for hash computation in the storage layer."""
|
|
|
|
@pytest.mark.unit
|
|
def test_storage_computes_sha256(self, mock_storage):
|
|
"""Test storage layer correctly computes SHA256 hash."""
|
|
content = TEST_CONTENT_HELLO
|
|
file_obj = io.BytesIO(content)
|
|
|
|
result = mock_storage._store_simple(file_obj)
|
|
|
|
assert result.sha256 == TEST_HASH_HELLO
|
|
|
|
@pytest.mark.unit
|
|
def test_storage_computes_md5(self, mock_storage):
|
|
"""Test storage layer also computes MD5 hash."""
|
|
content = TEST_CONTENT_HELLO
|
|
file_obj = io.BytesIO(content)
|
|
|
|
result = mock_storage._store_simple(file_obj)
|
|
|
|
expected_md5 = hashlib.md5(content).hexdigest()
|
|
assert result.md5 == expected_md5
|
|
|
|
@pytest.mark.unit
|
|
def test_storage_computes_sha1(self, mock_storage):
|
|
"""Test storage layer also computes SHA1 hash."""
|
|
content = TEST_CONTENT_HELLO
|
|
file_obj = io.BytesIO(content)
|
|
|
|
result = mock_storage._store_simple(file_obj)
|
|
|
|
expected_sha1 = hashlib.sha1(content).hexdigest()
|
|
assert result.sha1 == expected_sha1
|
|
|
|
@pytest.mark.unit
|
|
def test_storage_returns_correct_size(self, mock_storage):
|
|
"""Test storage layer returns correct file size."""
|
|
content = b"test content with known size"
|
|
file_obj = io.BytesIO(content)
|
|
|
|
result = mock_storage._store_simple(file_obj)
|
|
|
|
assert result.size == len(content)
|
|
|
|
@pytest.mark.unit
|
|
def test_storage_generates_correct_s3_key(self, mock_storage):
|
|
"""Test storage layer generates correct S3 key pattern."""
|
|
content = TEST_CONTENT_HELLO
|
|
file_obj = io.BytesIO(content)
|
|
|
|
result = mock_storage._store_simple(file_obj)
|
|
|
|
# Key should be: fruits/{hash[:2]}/{hash[2:4]}/{hash}
|
|
expected_key = (
|
|
f"fruits/{TEST_HASH_HELLO[:2]}/{TEST_HASH_HELLO[2:4]}/{TEST_HASH_HELLO}"
|
|
)
|
|
assert result.s3_key == expected_key
|
|
|
|
|
|
class TestHashEdgeCases:
|
|
"""Edge case tests for hash computation."""
|
|
|
|
@pytest.mark.unit
|
|
def test_hash_empty_content_rejected(self, mock_storage):
|
|
"""Test that empty content is rejected."""
|
|
from app.storage import HashComputationError
|
|
|
|
file_obj = io.BytesIO(b"")
|
|
|
|
with pytest.raises(HashComputationError):
|
|
mock_storage._store_simple(file_obj)
|
|
|
|
@pytest.mark.unit
|
|
def test_hash_large_file_streaming(self, mock_storage):
|
|
"""Test hash computation for large files uses streaming."""
|
|
# Create a 10MB file
|
|
size = 10 * 1024 * 1024
|
|
content = b"x" * size
|
|
file_obj = io.BytesIO(content)
|
|
|
|
result = mock_storage._store_simple(file_obj)
|
|
|
|
expected_hash = compute_sha256(content)
|
|
assert result.sha256 == expected_hash
|
|
|
|
@pytest.mark.unit
|
|
def test_hash_special_bytes(self):
|
|
"""Test hash handles all byte values correctly."""
|
|
# All possible byte values
|
|
content = bytes(range(256))
|
|
hash_value = compute_sha256(content)
|
|
|
|
assert len(hash_value) == 64
|
|
assert hash_value == TEST_HASH_BINARY
|