robotframework-mock 0.8.0__tar.gz → 0.9.0__tar.gz

{robotframework_mock-0.8.0/src/robotframework_mock.egg-info → robotframework_mock-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.8.0
+Version: 0.9.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -62,6 +62,7 @@ pip install -r requirements-dev.txt
 - Support for keywords with custom names via @keyword decorator
 - Verify keyword calls and call counts
 - Inspect and verify the arguments a mocked keyword was called with
+- Inspect the order in which mocked keywords were called
 - Measure resource-file keyword coverage with configurable thresholds
 - Simple API with three main keywords
 
@@ -434,6 +435,32 @@ Return how many times a mocked keyword was called.
 ${count}=    MockDB.Get Keyword Call Count    execute_sql
 ```
 
+### Get Keyword Call Order
+
+Return the mocked keywords in the order they were called, as a list of names.
+
+Covers keywords mocked through the same library instance. This is what
+establishes ordering *between* different mocks — an individual mock's call
+history cannot show how it interleaved with its siblings.
+
+A keyword called more than once appears once per call. Keywords that were mocked
+but never called do not appear, and calls made on a keyword's return value are
+not included.
+
+**Example:**
+```robot
+MockRes.Mock Keyword    Init Client    return_value=alias
+MockRes.Mock Keyword    Run Query      return_value=${rows}
+
+Fetch Data
+
+${order}=    MockRes.Get Keyword Call Order
+Should Be Equal    ${order}    ${{ ['Init Client', 'Run Query'] }}
+```
+
+Use this instead of wiring a `side_effect` that appends to a list, which is the
+only way to observe ordering otherwise.
+
 ## How It Works
 
 ### MockLibrary

{robotframework_mock-0.8.0 → robotframework_mock-0.9.0}/README.md

@@ -38,6 +38,7 @@ pip install -r requirements-dev.txt
 - Support for keywords with custom names via @keyword decorator
 - Verify keyword calls and call counts
 - Inspect and verify the arguments a mocked keyword was called with
+- Inspect the order in which mocked keywords were called
 - Measure resource-file keyword coverage with configurable thresholds
 - Simple API with three main keywords
 
@@ -410,6 +411,32 @@ Return how many times a mocked keyword was called.
 ${count}=    MockDB.Get Keyword Call Count    execute_sql
 ```
 
+### Get Keyword Call Order
+
+Return the mocked keywords in the order they were called, as a list of names.
+
+Covers keywords mocked through the same library instance. This is what
+establishes ordering *between* different mocks — an individual mock's call
+history cannot show how it interleaved with its siblings.
+
+A keyword called more than once appears once per call. Keywords that were mocked
+but never called do not appear, and calls made on a keyword's return value are
+not included.
+
+**Example:**
+```robot
+MockRes.Mock Keyword    Init Client    return_value=alias
+MockRes.Mock Keyword    Run Query      return_value=${rows}
+
+Fetch Data
+
+${order}=    MockRes.Get Keyword Call Order
+Should Be Equal    ${order}    ${{ ['Init Client', 'Run Query'] }}
+```
+
+Use this instead of wiring a `side_effect` that appends to a list, which is the
+only way to observe ordering otherwise.
+
 ## How It Works
 
 ### MockLibrary

{robotframework_mock-0.8.0 → robotframework_mock-0.9.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = robotframework-mock
-version = 0.8.0
+version = 0.9.0
 author = Lajos Olah
 author_email = lajos.olah.jr@gmail.com
 description = A Robot Framework library for mocking keywords in unit tests

{robotframework_mock-0.8.0 → robotframework_mock-0.9.0}/src/MockLibrary/__init__.py

@@ -160,6 +160,7 @@ class MockLibrary(CallInspectionMixin):
         # Create Mock object with specified behavior
         mock = Mock(return_value=return_value, side_effect=side_effect)
         self._mocks[method_name] = mock
+        self._track_call_order(keyword_name, mock)
 
         # Replace the method on the class or instance
         try:
@@ -194,6 +195,7 @@ class MockLibrary(CallInspectionMixin):
 
         # Clear all tracking dictionaries
         self._mocks.clear()
+        self._reset_call_order()
         self._original_methods.clear()
 
     @keyword

{robotframework_mock-0.8.0 → robotframework_mock-0.9.0}/src/MockResource/__init__.py

@@ -231,6 +231,7 @@ class MockResource(CallInspectionMixin):
             keyword_runner.keyword.teardown = None
         mock = Mock(return_value=return_value, side_effect=side_effect)
         self._mocks[normalize_keyword_name(keyword_name)] = mock
+        self._track_call_order(keyword_name, mock)
         # Tell MockCoverage this keyword's body no longer runs, so it is not
         # credited with coverage it did not earn.
         register_mocked_keyword(resource_file, keyword_name)
@@ -247,6 +248,7 @@ class MockResource(CallInspectionMixin):
             | MockRes.Reset Mocks |
         """
         self._mocks.clear()
+        self._reset_call_order()
         for keyword_name, source in self._mocked_sources.items():
             unregister_mocked_keyword(source, keyword_name)
         for keyword_name, items in self._original_items.items():

{robotframework_mock-0.8.0 → robotframework_mock-0.9.0}/src/_mock_core/__init__.py

@@ -10,7 +10,7 @@ apart.
 # pylint: disable=invalid-name
 import os
 from typing import Any, Dict, List
-from unittest.mock import call
+from unittest.mock import call, Mock
 
 from robot.api.deco import keyword
 from robot.utils import normalize
@@ -87,10 +87,37 @@ class CallInspectionMixin:
     - ``self._mocks``: mapping of mock key -> :class:`unittest.mock.Mock`
     - ``self._mock_key(keyword_name)``: the ``self._mocks`` key for a keyword
       name, in case the library does not key by the name as written
+    - ``self._call_manager`` / ``self._display_names``: created on first use by
+      :meth:`_track_call_order`, which the host calls for each new mock
     """
 
     _mocks: Dict[str, Any]
 
+    def _track_call_order(self, keyword_name: str, mock) -> None:
+        """Attach a mock so its calls are ordered against its siblings.
+
+        ``unittest.mock`` records calls to attached children on the parent in
+        invocation order, which is the only way to establish the relative order
+        of calls to *different* mocks - each mock's own ``call_args_list`` knows
+        nothing about the others.
+
+        Args:
+            keyword_name: Keyword name as written when mocking.
+            mock: The mock backing that keyword.
+        """
+        if not hasattr(self, '_call_manager'):
+            self._call_manager = Mock()
+            self._display_names = {}
+        key = normalize_keyword_name(keyword_name)
+        self._display_names[key] = keyword_name
+        self._call_manager.attach_mock(mock, key)
+
+    def _reset_call_order(self) -> None:
+        """Forget the recorded call order, called when mocks are reset."""
+        if hasattr(self, '_call_manager'):
+            del self._call_manager
+            del self._display_names
+
     def _mock_key(self, keyword_name: str) -> str:
         """Return the ``self._mocks`` key for *keyword_name*.
 
@@ -144,6 +171,40 @@ class CallInspectionMixin:
             )
         return calls[index]
 
+    @keyword
+    def get_keyword_call_order(self) -> List[str]:
+        """Return the mocked keywords in the order they were called.
+
+        Covers keywords mocked through *this* library instance, which is what
+        establishes ordering between different mocks - an individual mock's
+        call history cannot show how it interleaved with its siblings.
+
+        A keyword called more than once appears once per call. Keywords mocked
+        but never called do not appear at all.
+
+        Returns:
+            Keyword names, as written when mocking, in invocation order.
+
+        Example:
+            | MockRes.Mock Keyword | Init Client | return_value=alias |
+            | MockRes.Mock Keyword | Run Query | return_value=${rows} |
+            | Fetch Data |
+            | ${order}= | MockRes.Get Keyword Call Order |
+            | Should Be Equal | ${order} | ${{ ['Init Client', 'Run Query'] }} |
+        """
+        if not hasattr(self, '_call_manager'):
+            return []
+        order = []
+        for recorded in self._call_manager.mock_calls:
+            name = recorded[0]
+            # Skip nested calls such as "run_query().json()", which belong to
+            # the returned object rather than to a mocked keyword.
+            if not name or '.' in name:
+                continue
+            if name in self._display_names:
+                order.append(self._display_names[name])
+        return order
+
     @keyword
     def get_keyword_call_count(self, keyword_name: str) -> int:
         """Return how many times a mocked keyword was called.

{robotframework_mock-0.8.0 → robotframework_mock-0.9.0/src/robotframework_mock.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.8.0
+Version: 0.9.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -62,6 +62,7 @@ pip install -r requirements-dev.txt
 - Support for keywords with custom names via @keyword decorator
 - Verify keyword calls and call counts
 - Inspect and verify the arguments a mocked keyword was called with
+- Inspect the order in which mocked keywords were called
 - Measure resource-file keyword coverage with configurable thresholds
 - Simple API with three main keywords
 
@@ -434,6 +435,32 @@ Return how many times a mocked keyword was called.
 ${count}=    MockDB.Get Keyword Call Count    execute_sql
 ```
 
+### Get Keyword Call Order
+
+Return the mocked keywords in the order they were called, as a list of names.
+
+Covers keywords mocked through the same library instance. This is what
+establishes ordering *between* different mocks — an individual mock's call
+history cannot show how it interleaved with its siblings.
+
+A keyword called more than once appears once per call. Keywords that were mocked
+but never called do not appear, and calls made on a keyword's return value are
+not included.
+
+**Example:**
+```robot
+MockRes.Mock Keyword    Init Client    return_value=alias
+MockRes.Mock Keyword    Run Query      return_value=${rows}
+
+Fetch Data
+
+${order}=    MockRes.Get Keyword Call Order
+Should Be Equal    ${order}    ${{ ['Init Client', 'Run Query'] }}
+```
+
+Use this instead of wiring a `side_effect` that appends to a list, which is the
+only way to observe ordering otherwise.
+
 ## How It Works
 
 ### MockLibrary