chore: refactor ffi tests

This simplifies/reorganises tests to make them more logically organised,
and more intentful (even if not as exhaustive).

Signed-off-by: JP-Ellis <[email protected]>

Author: JP-Ellis

pact-python-ffi/tests/test_init.py

@@ -84,136 +84,178 @@ class TestInteractionIteration:
     Test interaction iteration functionality.
     """
 
-    def test_pact_interaction(self) -> None:
-        """Test PactInteraction class."""
+    @pytest.fixture
+    def pact(self) -> pact_ffi.PactHandle:
+        """Create a V4 pact for testing."""
         pact = pact_ffi.new_pact("consumer", "provider")
         pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
+        return pact
 
-        # Create HTTP interaction
-        pact_ffi.new_sync_message_interaction(pact, "test")
+    def test_interaction_iterator_repr(self, pact: pact_ffi.PactHandle) -> None:
+        iterator = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        assert str(iterator) == "PactInteractionIterator"
+        assert repr(iterator).startswith("PactInteractionIterator(")
 
-        # Get interactions via iterator
-        sync_http_iter = pact_ffi.pact_handle_get_sync_http_iter(pact)
-        list(sync_http_iter)
-        # Test string representation works on iterator
-        assert "PactSyncHttpIterator" in str(sync_http_iter) or str(sync_http_iter)
+    def test_http_iterator_repr(self, pact: pact_ffi.PactHandle) -> None:
+        iterator = pact_ffi.pact_handle_get_sync_http_iter(pact)
+        assert str(iterator) == "PactSyncHttpIterator"
+        assert repr(iterator).startswith("PactSyncHttpIterator(")
 
-    def test_pact_message_iterator(self) -> None:
-        """Test PactMessageIterator class."""
-        pact = pact_ffi.new_pact("consumer", "provider")
-        pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
+    def test_async_message_iterator_repr(self, pact: pact_ffi.PactHandle) -> None:
+        iterator = pact_ffi.pact_handle_get_async_message_iter(pact)
+        assert str(iterator) == "PactAsyncMessageIterator"
+        assert repr(iterator).startswith("PactAsyncMessageIterator(")
 
-        # Create message interaction
-        pact_ffi.new_message_interaction(pact, "test message")
+    def test_sync_message_iterator_repr(self, pact: pact_ffi.PactHandle) -> None:
+        iterator = pact_ffi.pact_handle_get_sync_message_iter(pact)
+        assert str(iterator) == "PactSyncMessageIterator"
+        assert repr(iterator).startswith("PactSyncMessageIterator(")
 
-        # Get message iterator
-        iterator = pact_ffi.pact_handle_get_message_iter(pact)
+    def test_empty_iterators(self, pact: pact_ffi.PactHandle) -> None:
+        inter_iter = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        assert sum(1 for _ in inter_iter) == 0
 
-        # Test string representation
-        assert "PactMessageIterator" in str(iterator)
-        assert "PactMessageIterator" in repr(iterator)
+        http_iterator = pact_ffi.pact_handle_get_sync_http_iter(pact)
+        assert sum(1 for _ in http_iterator) == 0
 
-        # Iterate and count messages
-        message_count = sum(1 for _ in iterator)
+        async_iterator = pact_ffi.pact_handle_get_async_message_iter(pact)
+        assert sum(1 for _ in async_iterator) == 0
 
-        # Should have the message
-        assert message_count >= 1
+        sync_iterator = pact_ffi.pact_handle_get_sync_message_iter(pact)
+        assert sum(1 for _ in sync_iterator) == 0
 
-    def test_pact_interaction_owned(self) -> None:
-        """Test PactInteraction with owned parameter."""
-        pact = pact_ffi.new_pact("consumer", "provider")
-        pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
-        pact_ffi.new_sync_message_interaction(pact, "test")
+    def test_iterators(self, pact: pact_ffi.PactHandle) -> None:
+        pact_ffi.new_interaction(pact, "http")
+        pact_ffi.new_message_interaction(pact, "async")
+        pact_ffi.new_sync_message_interaction(pact, "sync")
 
-        # Get an interaction through the iterator
-        sync_iter = pact_ffi.pact_handle_get_sync_message_iter(pact)
-        for interaction in sync_iter:
-            # Interaction should be owned by the iterator
-            # Test destructor doesn't crash
-            del interaction
-            break
-
-    def test_pact_message_iterator_empty(self) -> None:
-        """Test PactMessageIterator with no messages."""
-        pact = pact_ffi.new_pact("consumer", "provider")
-        pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
+        # Test each iterator type
+        interaction_iter = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        assert sum(1 for _ in interaction_iter) == 3
+        assert sum(1 for _ in interaction_iter) == 0  # exhausted
 
-        iterator = pact_ffi.pact_handle_get_message_iter(pact)
+        http_iter = pact_ffi.pact_handle_get_sync_http_iter(pact)
+        assert sum(1 for _ in http_iter) == 1
+        assert sum(1 for _ in http_iter) == 0  # exhausted
 
-        # Should iterate zero times
-        message_count = sum(1 for _ in iterator)
-        assert message_count == 0
+        async_iter = pact_ffi.pact_handle_get_async_message_iter(pact)
+        assert sum(1 for _ in async_iter) == 1
+        assert sum(1 for _ in async_iter) == 0  # exhausted
 
-    def test_pact_interaction_iterator_next(self) -> None:
-        """Test iterator next functions."""
-        pact = pact_ffi.new_pact("consumer", "provider")
-        pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
+        sync_iter = pact_ffi.pact_handle_get_sync_message_iter(pact)
+        assert sum(1 for _ in sync_iter) == 1
+        assert sum(1 for _ in sync_iter) == 0  # exhausted
 
-        # Create multiple interactions
+    def test_iterator_types(self, pact: pact_ffi.PactHandle) -> None:
         pact_ffi.new_interaction(pact, "http")
         pact_ffi.new_message_interaction(pact, "async")
         pact_ffi.new_sync_message_interaction(pact, "sync")
 
-        # Test each iterator type
+        interaction_iter = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        assert all(
+            isinstance(interaction, pact_ffi.PactInteraction)
+            for interaction in interaction_iter
+        )
+
         http_iter = pact_ffi.pact_handle_get_sync_http_iter(pact)
-        http_count = sum(1 for _ in http_iter)
-        assert http_count == 1
+        assert all(
+            isinstance(interaction, pact_ffi.SynchronousHttp)
+            for interaction in http_iter
+        )
 
         async_iter = pact_ffi.pact_handle_get_async_message_iter(pact)
-        async_count = sum(1 for _ in async_iter)
-        assert async_count == 1
+        assert all(
+            isinstance(interaction, pact_ffi.AsynchronousMessage)
+            for interaction in async_iter
+        )
 
         sync_iter = pact_ffi.pact_handle_get_sync_message_iter(pact)
-        sync_count = sum(1 for _ in sync_iter)
-        assert sync_count == 1
+        assert all(
+            isinstance(interaction, pact_ffi.SynchronousMessage)
+            for interaction in sync_iter
+        )
 
-    def test_pact_message_iterator_repr(self) -> None:
-        """Test PactMessageIterator __repr__ method."""
+
+class TestPactModelHandle:
+    """
+    Test basic Pact model pointer handling.
+    """
+
+    @pytest.fixture
+    def pact(self) -> pact_ffi.PactHandle:
+        """Create a V4 pact for testing."""
         pact = pact_ffi.new_pact("consumer", "provider")
         pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
+        return pact
 
-        iterator = pact_ffi.pact_handle_get_message_iter(pact)
-        repr_str = repr(iterator)
+    def test_pact_handle_repr(self, pact: pact_ffi.PactHandle) -> None:
+        assert str(pact).startswith("PactHandle(")
+        assert repr(pact).startswith("PactHandle(")
 
-        assert "PactMessageIterator" in repr_str
-        assert "0x" in repr_str or ">" in repr_str
+    def test_pact_repr(self, pact: pact_ffi.PactHandle) -> None:
+        pact_model = pact_ffi.pact_handle_to_pointer(pact)
 
-    def test_pact_interaction_str_repr(self) -> None:
-        """Test PactInteraction __str__ and __repr__ methods."""
-        pact = pact_ffi.new_pact("consumer", "provider")
-        pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
-        pact_ffi.new_sync_message_interaction(pact, "test")
+        assert isinstance(pact_model, pact_ffi.Pact)
+        assert str(pact_model) == "Pact"
+        assert repr(pact_model).startswith("Pact(")
 
-        # Get an interaction from iterator
-        sync_iter = pact_ffi.pact_handle_get_sync_message_iter(pact)
-        for interaction in sync_iter:
-            str_result = str(interaction)
-            repr_result = repr(interaction)
 
-            assert "SynchronousMessage" in str_result
-            assert "SynchronousMessage" in repr_result
-            break
+class TestPactInteractionCasting:
+    """
+    Test casting interactions to specific subtypes via iterators.
+    """
 
-    def test_multiple_iterator_types_simultaneously(self) -> None:
-        """Test using multiple iterator types at the same time."""
+    @pytest.fixture
+    def pact(self) -> pact_ffi.PactHandle:
+        """Create a V4 pact for testing."""
         pact = pact_ffi.new_pact("consumer", "provider")
         pact_ffi.with_specification(pact, pact_ffi.PactSpecification.V4)
+        return pact
 
-        # Create one of each type
+    def test_synchronous_http_casting(self, pact: pact_ffi.PactHandle) -> None:
+        """Test SynchronousHttp interaction casting and representation."""
         pact_ffi.new_interaction(pact, "http")
+
+        # Test HTTP iterator yields SynchronousHttp
+        interaction_iter = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        interaction = next(interaction_iter)
+        assert isinstance(interaction, pact_ffi.PactInteraction)
+        http = interaction.as_synchronous_http()
+        assert isinstance(http, pact_ffi.SynchronousHttp)
+
+        with pytest.raises(TypeError):
+            interaction.as_asynchronous_message()
+        with pytest.raises(TypeError):
+            interaction.as_synchronous_message()
+
+    def test_asynchronous_message_casting(self, pact: pact_ffi.PactHandle) -> None:
+        """Test AsynchronousMessage interaction casting and representation."""
         pact_ffi.new_message_interaction(pact, "async")
-        pact_ffi.new_sync_message_interaction(pact, "sync")
 
-        # Create all three iterators
-        http_iter = pact_ffi.pact_handle_get_sync_http_iter(pact)
-        async_iter = pact_ffi.pact_handle_get_async_message_iter(pact)
-        sync_iter = pact_ffi.pact_handle_get_sync_message_iter(pact)
+        # Test async message iterator yields AsynchronousMessage
+        interaction_iter = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        interaction = next(interaction_iter)
+        assert isinstance(interaction, pact_ffi.PactInteraction)
+        async_msg = interaction.as_asynchronous_message()
+        assert isinstance(async_msg, pact_ffi.AsynchronousMessage)
 
-        # Iterate through all of them
-        http_list = list(http_iter)
-        async_list = list(async_iter)
-        sync_list = list(sync_iter)
+        with pytest.raises(TypeError):
+            interaction.as_synchronous_http()
+        with pytest.raises(TypeError):
+            interaction.as_synchronous_message()
+
+    def test_synchronous_message_casting(self, pact: pact_ffi.PactHandle) -> None:
+        """Test SynchronousMessage interaction casting and representation."""
+        pact_ffi.new_sync_message_interaction(pact, "sync")
 
-        assert len(http_list) == 1
-        assert len(async_list) == 1
-        assert len(sync_list) == 1
+        # Test sync message iterator yields SynchronousMessage
+        interaction_iter = pact_ffi.pact_model_interaction_iterator(pact.pointer())
+        interaction = next(interaction_iter)
+        assert isinstance(interaction, pact_ffi.PactInteraction)
+        sync_msg = interaction.as_synchronous_message()
+        assert isinstance(sync_msg, pact_ffi.SynchronousMessage)
+
+        with pytest.raises(TypeError):
+            interaction.as_synchronous_http()
+        with pytest.raises(TypeError):
+            interaction.as_asynchronous_message()