test: add comprehensive test suite (98 tests)

- test_pool.py: EntropyPool unit tests
- test_tap.py: EntropyTap with distribution checks
- test_harvesters.py: all harvester implementations
- test_integration.py: public API and end-to-end tests

Author: medeirosdev

tests/__init__.py

@@ -0,0 +1 @@
+# TrueEntropy Tests

tests/conftest.py

@@ -0,0 +1,34 @@
+# =============================================================================
+# TrueEntropy - Test Configuration
+# =============================================================================
+
+"""Pytest configuration and fixtures for TrueEntropy tests."""
+
+import pytest
+
+from trueentropy.pool import EntropyPool
+from trueentropy.tap import EntropyTap
+
+
+@pytest.fixture
+def pool() -> EntropyPool:
+    """Create a fresh EntropyPool for testing."""
+    return EntropyPool()
+
+
+@pytest.fixture
+def seeded_pool() -> EntropyPool:
+    """Create an EntropyPool with fixed seed for deterministic tests."""
+    return EntropyPool(seed=b"test_seed_for_deterministic_tests")
+
+
+@pytest.fixture
+def tap(pool: EntropyPool) -> EntropyTap:
+    """Create an EntropyTap with a fresh pool."""
+    return EntropyTap(pool)
+
+
+@pytest.fixture
+def seeded_tap(seeded_pool: EntropyPool) -> EntropyTap:
+    """Create an EntropyTap with seeded pool for deterministic tests."""
+    return EntropyTap(seeded_pool)

tests/test_harvesters.py

@@ -0,0 +1,281 @@
+# =============================================================================
+# TrueEntropy - Harvesters Tests
+# =============================================================================
+#
+# Unit tests for all harvester classes.
+# Tests cover:
+# - Timing harvester
+# - Network harvester
+# - System harvester
+# - External harvester
+# - Base harvester interface
+#
+# =============================================================================
+
+"""Tests for the entropy harvesters."""
+
+import pytest
+
+from trueentropy.harvesters.base import BaseHarvester, HarvestResult
+from trueentropy.harvesters.timing import TimingHarvester
+from trueentropy.harvesters.network import NetworkHarvester
+from trueentropy.harvesters.system import SystemHarvester
+from trueentropy.harvesters.external import ExternalHarvester
+
+
+class TestHarvestResult:
+    """Test HarvestResult dataclass."""
+    
+    def test_success_result(self) -> None:
+        """Test creating a successful result."""
+        result = HarvestResult(
+            data=b"test_data",
+            entropy_bits=16,
+            source="test",
+            success=True
+        )
+        
+        assert result.data == b"test_data"
+        assert result.entropy_bits == 16
+        assert result.source == "test"
+        assert result.success is True
+        assert result.error is None
+    
+    def test_failure_result(self) -> None:
+        """Test creating a failed result."""
+        result = HarvestResult(
+            data=b"",
+            entropy_bits=0,
+            source="test",
+            success=False,
+            error="Something went wrong"
+        )
+        
+        assert result.data == b""
+        assert result.entropy_bits == 0
+        assert result.success is False
+        assert result.error == "Something went wrong"
+
+
+class TestTimingHarvester:
+    """Test TimingHarvester."""
+    
+    def test_name(self) -> None:
+        """Harvester should have correct name."""
+        harvester = TimingHarvester()
+        assert harvester.name == "timing"
+    
+    def test_collect_returns_result(self) -> None:
+        """collect() should return HarvestResult."""
+        harvester = TimingHarvester()
+        result = harvester.collect()
+        
+        assert isinstance(result, HarvestResult)
+    
+    def test_collect_succeeds(self) -> None:
+        """collect() should succeed (timing is always available)."""
+        harvester = TimingHarvester()
+        result = harvester.collect()
+        
+        assert result.success is True
+        assert result.data != b""
+        assert result.entropy_bits > 0
+    
+    def test_collect_returns_bytes(self) -> None:
+        """collect() should return bytes data."""
+        harvester = TimingHarvester()
+        result = harvester.collect()
+        
+        assert isinstance(result.data, bytes)
+        assert len(result.data) > 0
+    
+    def test_num_samples_configuration(self) -> None:
+        """Harvester should respect num_samples config."""
+        harvester = TimingHarvester(num_samples=32)
+        assert harvester.num_samples == 32
+        
+        result = harvester.collect()
+        # 32 samples * 8 bytes per sample
+        assert len(result.data) == 32 * 8
+    
+    def test_different_collections_different_data(self) -> None:
+        """Successive collections should return different data."""
+        harvester = TimingHarvester()
+        
+        results = [harvester.collect().data for _ in range(10)]
+        
+        # All should be unique
+        assert len(set(results)) == 10
+    
+    def test_safe_collect(self) -> None:
+        """safe_collect() should never raise."""
+        harvester = TimingHarvester()
+        
+        # Should not raise
+        result = harvester.safe_collect()
+        
+        assert isinstance(result, HarvestResult)
+
+
+class TestSystemHarvester:
+    """Test SystemHarvester."""
+    
+    def test_name(self) -> None:
+        """Harvester should have correct name."""
+        harvester = SystemHarvester()
+        assert harvester.name == "system"
+    
+    def test_collect_returns_result(self) -> None:
+        """collect() should return HarvestResult."""
+        harvester = SystemHarvester()
+        result = harvester.collect()
+        
+        assert isinstance(result, HarvestResult)
+    
+    def test_collect_returns_data(self) -> None:
+        """collect() should return non-empty data."""
+        harvester = SystemHarvester()
+        result = harvester.collect()
+        
+        # Should succeed if psutil is available
+        if result.success:
+            assert result.data != b""
+            assert result.entropy_bits > 0
+    
+    def test_list_available_metrics(self) -> None:
+        """list_available_metrics() should return list."""
+        harvester = SystemHarvester()
+        metrics = harvester.list_available_metrics()
+        
+        assert isinstance(metrics, list)
+        # At minimum, timestamp should be available
+        assert "timestamp_ns" in metrics
+
+
+class TestNetworkHarvester:
+    """Test NetworkHarvester."""
+    
+    def test_name(self) -> None:
+        """Harvester should have correct name."""
+        harvester = NetworkHarvester()
+        assert harvester.name == "network"
+    
+    def test_default_targets(self) -> None:
+        """Harvester should have default targets."""
+        harvester = NetworkHarvester()
+        
+        assert len(harvester.targets) > 0
+        assert all(t.startswith("http") for t in harvester.targets)
+    
+    def test_custom_targets(self) -> None:
+        """Harvester should accept custom targets."""
+        targets = ["https://example.com", "https://test.com"]
+        harvester = NetworkHarvester(targets=targets)
+        
+        assert harvester.targets == targets
+    
+    def test_timeout_configuration(self) -> None:
+        """Harvester should respect timeout config."""
+        harvester = NetworkHarvester(timeout=1.0)
+        assert harvester.timeout == 1.0
+    
+    def test_collect_returns_result(self) -> None:
+        """collect() should return HarvestResult."""
+        harvester = NetworkHarvester()
+        result = harvester.collect()
+        
+        assert isinstance(result, HarvestResult)
+    
+    # Note: We don't test actual network calls here to avoid
+    # network-dependent test failures. Integration tests would
+    # cover that.
+
+
+class TestExternalHarvester:
+    """Test ExternalHarvester."""
+    
+    def test_name(self) -> None:
+        """Harvester should have correct name."""
+        harvester = ExternalHarvester()
+        assert harvester.name == "external"
+    
+    def test_enable_flags(self) -> None:
+        """Harvester should respect enable flags."""
+        harvester = ExternalHarvester(
+            enable_earthquake=False,
+            enable_crypto=True
+        )
+        
+        assert harvester.enable_earthquake is False
+        assert harvester.enable_crypto is True
+    
+    def test_timeout_configuration(self) -> None:
+        """Harvester should respect timeout config."""
+        harvester = ExternalHarvester(timeout=3.0)
+        assert harvester.timeout == 3.0
+    
+    def test_collect_returns_result(self) -> None:
+        """collect() should return HarvestResult."""
+        harvester = ExternalHarvester()
+        result = harvester.collect()
+        
+        assert isinstance(result, HarvestResult)
+    
+    # Note: We don't test actual API calls here to avoid
+    # network-dependent test failures and rate limiting.
+
+
+class TestBaseHarvesterInterface:
+    """Test that harvesters implement the interface correctly."""
+    
+    def test_all_harvesters_have_name(self) -> None:
+        """All harvesters should implement name property."""
+        harvesters = [
+            TimingHarvester(),
+            SystemHarvester(),
+            NetworkHarvester(),
+            ExternalHarvester(),
+        ]
+        
+        for h in harvesters:
+            assert isinstance(h.name, str)
+            assert len(h.name) > 0
+    
+    def test_all_harvesters_have_collect(self) -> None:
+        """All harvesters should implement collect method."""
+        harvesters = [
+            TimingHarvester(),
+            SystemHarvester(),
+            NetworkHarvester(),
+            ExternalHarvester(),
+        ]
+        
+        for h in harvesters:
+            result = h.collect()
+            assert isinstance(result, HarvestResult)
+    
+    def test_all_harvesters_have_safe_collect(self) -> None:
+        """All harvesters should have safe_collect from base class."""
+        harvesters = [
+            TimingHarvester(),
+            SystemHarvester(),
+            NetworkHarvester(),
+            ExternalHarvester(),
+        ]
+        
+        for h in harvesters:
+            result = h.safe_collect()
+            assert isinstance(result, HarvestResult)
+    
+    def test_repr(self) -> None:
+        """All harvesters should have useful repr."""
+        harvesters = [
+            TimingHarvester(),
+            SystemHarvester(),
+            NetworkHarvester(),
+            ExternalHarvester(),
+        ]
+        
+        for h in harvesters:
+            repr_str = repr(h)
+            assert h.name in repr_str