VectorArray Integration Tests

Author: sankalps0549

pytest.ini

@@ -3,3 +3,5 @@ markers =
     unit: Unit tests that run quickly and test small pieces of functionality
     integration: Integration tests that check multiple components together
     core: Core functionality tests
+    synergy: Tests the Synergy class
+    vector_array: Tests the VectorArray class

src/moldflow/vector_array.py

@@ -28,19 +28,19 @@ def __init__(self, _vector_array):
 
     def clear(self) -> None:
         """
-        Clear the vector array.
+        Resets a vector array - the size of the array is 0 subsequent to this call.
         """
         process_log(__name__, LogMessage.FUNCTION_CALL, locals(), name="clear")
         self.vector_array.Clear()
 
-    def add_xyz(self, x: float, y: float, z: float) -> None:
+    def add_xyz(self, x: float | int, y: float | int, z: float | int) -> None:
         """
-        Add a vector to the array with x, y, z values.
+        Adds a vector (x, y, z) to the end of the array.
 
         Args:
-            x (float): The x value.
-            y (float): The y value.
-            z (float): The z value.
+            x [float | int]: The x component.
+            y [float | int]: The y component.
+            z [float | int]: The z component.
         """
         process_log(__name__, LogMessage.FUNCTION_CALL, locals(), name="add_xyz")
         check_type(x, (float, int))
@@ -51,23 +51,23 @@ def add_xyz(self, x: float, y: float, z: float) -> None:
     @property
     def size(self) -> int:
         """
-        Get the size of the vector array.
+        Returns the number of vectors in the array. [read-only]
 
         Returns:
-            int: The size of the vector array.
+            The size of the vector array.
         """
         process_log(__name__, LogMessage.PROPERTY_GET, locals(), name="size")
         return self.vector_array.Size
 
     def x(self, index: int) -> float:
         """
-        Get the x value of the vector at the index.
+        Get the x component of the vector at the index.
 
         Args:
-            index (int): The index of the vector.
+            index [int]: index between 0 and vector_array.size-1 (inclusive)
 
         Returns:
-            float: The x value of the vector.
+            The x component of the vector at offset index.
         """
         process_log(__name__, LogMessage.PROPERTY_PARAM_GET, locals(), name="x", value=index)
         check_type(index, int)
@@ -76,13 +76,13 @@ def x(self, index: int) -> float:
 
     def y(self, index: int) -> float:
         """
-        Get the y value of the vector at the index.
+        Get the y component of the vector at the index.
 
         Args:
-            index (int): The index of the vector.
+            index [int]: index between 0 and vector_array.size-1 (inclusive)
 
         Returns:
-            float: The y value of the vector.
+            The y component of the vector at offset index.
         """
         process_log(__name__, LogMessage.PROPERTY_PARAM_GET, locals(), name="y", value=index)
         check_type(index, int)
@@ -91,13 +91,13 @@ def y(self, index: int) -> float:
 
     def z(self, index: int) -> float:
         """
-        Get the z value of the vector at the index.
+        Get the z component of the vector at the index.
 
         Args:
-            index (int): The index of the vector.
+            index [int]: index between 0 and vector_array.size-1 (inclusive)
 
         Returns:
-            float: The z value of the vector.
+            The z component of the vector at offset index.
         """
         process_log(__name__, LogMessage.PROPERTY_PARAM_GET, locals(), name="z", value=index)
         check_type(index, int)

tests/api/integration_tests/conftest.py

@@ -0,0 +1,16 @@
+"""
+Configuration and constants for integration tests.
+"""
+
+import pytest
+from moldflow import Synergy
+
+
+@pytest.fixture(scope="class")
+def synergy():
+    """
+    Fixture to create a real Synergy instance for integration testing.
+    """
+    synergy_instance = Synergy()
+    yield synergy_instance
+    synergy_instance.quit(False)

tests/api/integration_tests/test_integration_vector_array.py

@@ -0,0 +1,207 @@
+"""
+Integration tests for VectorArray Wrapper Class of moldflow-api module.
+
+These tests focus on testing the actual functionality and behavior
+of the VectorArray class with real Moldflow Synergy COM objects.
+"""
+
+import pytest
+from moldflow import VectorArray, Synergy
+
+
+@pytest.mark.integration
+@pytest.mark.vector_array
+class TestIntegrationVectorArray:
+    """
+    Integration test suite for the VectorArray class.
+    """
+
+    @pytest.fixture
+    def vector_array(self, synergy: Synergy):
+        """
+        Fixture to create a real VectorArray instance for integration testing.
+        """
+        return synergy.create_vector_array()
+
+    def _check_vector_array_size(self, vector_array: VectorArray, expected_size: int):
+        """
+        Verify the size of the vector array.
+        """
+        assert vector_array.size == expected_size
+
+    def _check_vector_at_index(
+        self, vector_array: VectorArray, index: int, expected_value: list[int | float]
+    ):
+        """
+        Verify the values of a vector at a specific index in the array.
+        """
+        assert vector_array.x(index) == expected_value[0]
+        assert vector_array.y(index) == expected_value[1]
+        assert vector_array.z(index) == expected_value[2]
+
+    @pytest.mark.synergy
+    def test_create_vector_array(self, synergy: Synergy):
+        """
+        Test that VectorArray can be created from Synergy instance.
+        """
+        vector_array = synergy.create_vector_array()
+        self._check_vector_array_size(vector_array, 0)
+
+    def test_add_xyz_single_vector(self, vector_array: VectorArray):
+        """
+        Test adding a single vector to the array using add_xyz.
+        """
+        self._check_vector_array_size(vector_array, 0)
+
+        vector_array.add_xyz(1.0, 2.0, 3.0)
+        self._check_vector_array_size(vector_array, 1)
+        self._check_vector_at_index(vector_array, 0, [1.0, 2.0, 3.0])
+
+    @pytest.mark.parametrize(
+        "vectors",
+        [
+            [(1, 2.2, 3.3), (4.4, 5.5, 6.6)],
+            [(0, 0.0, 0.0), (-1.0, -2, -3.0), (10.5, 20.5, 30)],
+            [(-5.5, 10.0, 15.5)],
+        ],
+    )
+    def test_add_xyz_multiple_vectors(
+        self, vector_array: VectorArray, vectors: list[tuple[float | int, float | int, float | int]]
+    ):
+        """
+        Test adding multiple vectors to the array.
+        """
+        self._check_vector_array_size(vector_array, 0)
+
+        for i, (x, y, z) in enumerate(vectors):
+            vector_array.add_xyz(x, y, z)
+            self._check_vector_array_size(vector_array, i + 1)
+            self._check_vector_at_index(vector_array, i, [x, y, z])
+
+        self._check_vector_array_size(vector_array, len(vectors))
+        for i, (x, y, z) in enumerate(vectors):
+            self._check_vector_at_index(vector_array, i, [x, y, z])
+
+    def test_clear_empty_array(self, vector_array: VectorArray):
+        """
+        Test clearing an empty vector array.
+        """
+        # Initially empty
+        self._check_vector_array_size(vector_array, 0)
+
+        # Clear empty array
+        vector_array.clear()
+        self._check_vector_array_size(vector_array, 0)
+
+    def test_clear_populated_array(self, vector_array: VectorArray):
+        """
+        Test clearing a populated vector array.
+        """
+        # Add some vectors
+        test_vectors = [(1.1, 2.2, 3.3), (4.4, 5.5, 6.6), (7.7, 8.8, 9.9)]
+        for x, y, z in test_vectors:
+            vector_array.add_xyz(x, y, z)
+
+        self._check_vector_array_size(vector_array, len(test_vectors))
+
+        # Clear the array
+        vector_array.clear()
+        self._check_vector_array_size(vector_array, 0)
+
+    def test_vector_array_indexing(self, vector_array: VectorArray):
+        """
+        Test accessing vectors by index in the array.
+        """
+        test_vectors = [(10.1, 20.2, 30.3), (-5.5, 15.5, 25.5), (0.0, 100.0, 200.0)]
+
+        # Add test vectors
+        for x, y, z in test_vectors:
+            vector_array.add_xyz(x, y, z)
+
+        # Test accessing each vector by index
+        for i, (expected_x, expected_y, expected_z) in enumerate(test_vectors):
+            self._check_vector_at_index(vector_array, i, [expected_x, expected_y, expected_z])
+
+    @pytest.mark.parametrize(
+        "initial_vectors, additional_vectors, final_vectors",
+        [([(1.1, 2.2, 3.3), (4.4, 5.5, 6.6)], [(7.7, 8.8, 9.9)], [(10.1, 11.2, 12.3)])],
+    )
+    def test_vector_array_state_persistence(
+        self,
+        vector_array: VectorArray,
+        initial_vectors: list[tuple[float, float, float]],
+        additional_vectors: list[tuple[float, float, float]],
+        final_vectors: list[tuple[float, float, float]],
+    ):
+        """
+        Test that VectorArray maintains state correctly across multiple operations.
+        """
+        # Add initial vectors
+        for x, y, z in initial_vectors:
+            vector_array.add_xyz(x, y, z)
+
+        # Verify initial state
+        self._check_vector_array_size(vector_array, len(initial_vectors))
+        for i, (x, y, z) in enumerate(initial_vectors):
+            self._check_vector_at_index(vector_array, i, [x, y, z])
+
+        # Add additional vectors
+        for x, y, z in additional_vectors:
+            vector_array.add_xyz(x, y, z)
+
+        # Verify all vectors are still correct
+        all_vectors = initial_vectors + additional_vectors
+        self._check_vector_array_size(vector_array, len(all_vectors))
+        for i, (x, y, z) in enumerate(all_vectors):
+            self._check_vector_at_index(vector_array, i, [x, y, z])
+
+        # Clear and verify
+        vector_array.clear()
+        self._check_vector_array_size(vector_array, 0)
+
+        # Add final vectors after clear
+        for x, y, z in final_vectors:
+            vector_array.add_xyz(x, y, z)
+
+        self._check_vector_array_size(vector_array, len(final_vectors))
+        for i, (x, y, z) in enumerate(final_vectors):
+            self._check_vector_at_index(vector_array, i, [x, y, z])
+
+    @pytest.mark.parametrize("size", [1, 5, 10])
+    def test_vector_array_size_property(self, vector_array: VectorArray, size: int):
+        """
+        Test that the size property correctly reflects the number of vectors.
+        """
+        self._check_vector_array_size(vector_array, 0)
+
+        for i in range(size):
+            vector_array.add_xyz(float(i * 1.1), float(i * 2.2), float(i * 3.3))
+            self._check_vector_array_size(vector_array, i + 1)
+
+        self._check_vector_array_size(vector_array, size)
+
+    def test_reference_behavior(self, vector_array: VectorArray):
+        """
+        Test reference behavior of VectorArray.
+        """
+        vector_array.add_xyz(1.0, 2.0, 3.0)
+        vector_array_copy = vector_array
+        self._check_vector_array_size(vector_array_copy, 1)
+        self._check_vector_at_index(vector_array_copy, 0, [1.0, 2.0, 3.0])
+
+        vector_array_copy.add_xyz(4.0, 5.0, 6.0)
+        self._check_vector_array_size(vector_array_copy, 2)
+        self._check_vector_at_index(vector_array_copy, 0, [1.0, 2.0, 3.0])
+        self._check_vector_at_index(vector_array_copy, 1, [4.0, 5.0, 6.0])
+        self._check_vector_at_index(vector_array, 1, [4.0, 5.0, 6.0])
+
+        vector_array_copy2 = VectorArray(vector_array.vector_array)
+        self._check_vector_array_size(vector_array_copy2, 2)
+        self._check_vector_at_index(vector_array_copy2, 0, [1.0, 2.0, 3.0])
+        self._check_vector_at_index(vector_array_copy2, 1, [4.0, 5.0, 6.0])
+
+        vector_array_copy2.add_xyz(7.0, 8.0, 9.0)
+        self._check_vector_array_size(vector_array_copy2, 3)
+        self._check_vector_at_index(vector_array_copy2, 0, [1.0, 2.0, 3.0])
+        self._check_vector_at_index(vector_array_copy2, 1, [4.0, 5.0, 6.0])
+        self._check_vector_at_index(vector_array_copy2, 2, [7.0, 8.0, 9.0])

tests/api/unit_tests/test_unit_vector_array.py

@@ -10,6 +10,7 @@
 
 
 @pytest.mark.unit
+@pytest.mark.vector_array
 class TestUnitVectorArray:
     """
     Test suite for the VectorArray class.