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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.7.0
+Version: 0.8.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -444,9 +444,39 @@ MockLibrary dynamically replaces keyword implementations:
 3. Stores original methods before mocking
 4. Replaces methods with mock implementations using Python's unittest.mock.Mock
 5. Returns mocked values or executes side effects
-6. Tracks call counts for verification
+6. Tracks call counts and call arguments for verification
 7. Raises AttributeError if attempting to mock a non-existent keyword
 
+#### Mocks are installed on the library class
+
+Step 4 replaces the method on the target library's **class**, not on the
+instance. Two consequences are worth knowing, because neither is reported as an
+error:
+
+**A mock stays active until `Reset Mocks`, across tests and suites.** The mock
+is not scoped to the test that created it. A test that mocks a keyword and
+leaves without resetting hands the mock to everything that follows. Reset in a
+teardown rather than at the end of a test body, so the mock is also removed when
+the test fails midway.
+
+**Two `MockLibrary` instances wrapping the same library share one mock.** Last
+registration wins, and resetting *either* instance restores the real method:
+
+```robot
+Library    MockLibrary    DateTime    WITH NAME    MockA
+Library    MockLibrary    DateTime    WITH NAME    MockB
+...
+MockA.Mock Keyword    Convert Time    return_value=from-a
+MockB.Mock Keyword    Convert Time    return_value=from-b
+${result}=    Convert Time    12:00:00      # from-b: MockA's mock was overwritten
+MockB.Reset Mocks
+${result}=    Convert Time    12:00:00      # the real keyword, although MockA never reset
+```
+
+Use a single alias per library, and separate aliases only for *different*
+libraries. `MockResource` is not affected: it keys mocks per resource file, so
+instances for different resources are independent.
+
 ### MockResource
 
 MockResource patches Robot Framework's keyword execution:

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

@@ -420,9 +420,39 @@ MockLibrary dynamically replaces keyword implementations:
 3. Stores original methods before mocking
 4. Replaces methods with mock implementations using Python's unittest.mock.Mock
 5. Returns mocked values or executes side effects
-6. Tracks call counts for verification
+6. Tracks call counts and call arguments for verification
 7. Raises AttributeError if attempting to mock a non-existent keyword
 
+#### Mocks are installed on the library class
+
+Step 4 replaces the method on the target library's **class**, not on the
+instance. Two consequences are worth knowing, because neither is reported as an
+error:
+
+**A mock stays active until `Reset Mocks`, across tests and suites.** The mock
+is not scoped to the test that created it. A test that mocks a keyword and
+leaves without resetting hands the mock to everything that follows. Reset in a
+teardown rather than at the end of a test body, so the mock is also removed when
+the test fails midway.
+
+**Two `MockLibrary` instances wrapping the same library share one mock.** Last
+registration wins, and resetting *either* instance restores the real method:
+
+```robot
+Library    MockLibrary    DateTime    WITH NAME    MockA
+Library    MockLibrary    DateTime    WITH NAME    MockB
+...
+MockA.Mock Keyword    Convert Time    return_value=from-a
+MockB.Mock Keyword    Convert Time    return_value=from-b
+${result}=    Convert Time    12:00:00      # from-b: MockA's mock was overwritten
+MockB.Reset Mocks
+${result}=    Convert Time    12:00:00      # the real keyword, although MockA never reset
+```
+
+Use a single alias per library, and separate aliases only for *different*
+libraries. `MockResource` is not affected: it keys mocks per resource file, so
+instances for different resources are independent.
+
 ### MockResource
 
 MockResource patches Robot Framework's keyword execution:

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

@@ -1,6 +1,6 @@
 [metadata]
 name = robotframework-mock
-version = 0.7.0
+version = 0.8.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.7.0 → robotframework_mock-0.8.0}/src/MockCoverage/__init__.py

@@ -60,6 +60,8 @@ except ModuleNotFoundError:  # pragma: no cover - exercised only on <3.11
 from robot.api import get_resource_model
 from robot.api.parsing import ModelVisitor
 
+from _mock_core import is_keyword_mocked
+
 
 DEFAULT_CONFIG_PATH = "mock-coverage.toml"
 DEFAULT_OUTPUT_PATH = "coverage.json"
@@ -571,6 +573,10 @@ class ExecutionTracker:
     def record(self, owner: Optional[str], name: str) -> None:
         """Record a keyword execution if it belongs to a measured resource.
 
+        Keywords whose body is currently replaced by a ``MockResource`` mock are
+        ignored: the real body never ran, so counting them would credit the
+        resource with coverage it did not earn.
+
         Args:
             owner: Robot's owner name for the keyword (resource base name).
             name: The executed keyword's name.
@@ -579,7 +585,7 @@ class ExecutionTracker:
         if owner not in self._owner_names:
             return
         source = self._resolve_source(owner, name)
-        if source:
+        if source and not is_keyword_mocked(source, name):
             self._executed.setdefault(source, set()).add(name)
 
     def _resolve_source(self, owner: str, name: str) -> Optional[str]:

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

@@ -1,5 +1,6 @@
 """Mock resource for Robot Framework keyword mocking in unit tests."""
 # pylint: disable=invalid-name
+import weakref
 from typing import Any, Callable
 from unittest.mock import Mock
 
@@ -9,7 +10,12 @@ from robot.running import Return
 from robot.running.namespace import Namespace
 from robot.utils import split_from_equals
 
-from _mock_core import CallInspectionMixin
+from _mock_core import (
+    CallInspectionMixin,
+    normalize_keyword_name,
+    register_mocked_keyword,
+    unregister_mocked_keyword,
+)
 
 # Robot resolves the values of a RETURN statement as variable expressions, so a
 # mocked return value cannot be embedded in one directly - anything that is not
@@ -18,6 +24,74 @@ from _mock_core import CallInspectionMixin
 # object (a query result set, a parsed JSON body, a list of pods...).
 RETURN_VARIABLE = '${__mock_resource_return__}'
 
+# Namespace.get_runner is patched once per process rather than once per
+# MockResource instance. Patching per instance chained a new wrapper around the
+# previous one for every library import, and nothing ever restored them, so
+# every keyword lookup in the run paid for each import. The single wrapper
+# consults the live instances below and is inert when none of them has mocks.
+_INSTANCES = []
+_ORIGINAL_GET_RUNNER = None
+
+
+def _live_instances():
+    """Return the MockResource instances that are still alive.
+
+    Instances are held weakly so a library instance going out of scope does not
+    keep its mocks alive, and dead references are pruned on access.
+
+    Returns:
+        The live instances, in the order they were created.
+    """
+    live = []
+    for reference in list(_INSTANCES):
+        instance = reference()
+        if instance is None:
+            _INSTANCES.remove(reference)
+        else:
+            live.append(instance)
+    return live
+
+
+def _install_shared_patch():
+    """Patch ``Namespace.get_runner`` once, routing to all live instances."""
+    global _ORIGINAL_GET_RUNNER  # pylint: disable=global-statement
+    if _ORIGINAL_GET_RUNNER is not None:
+        return
+    _ORIGINAL_GET_RUNNER = Namespace.get_runner
+    original_get_runner = _ORIGINAL_GET_RUNNER
+
+    def patched_get_runner(self, keyword_name, recommend_on_failure):
+        keyword_runner = original_get_runner(self, keyword_name, recommend_on_failure)
+        resource_file = getattr(keyword_runner.keyword, "source", None)
+
+        for instance in _live_instances():
+            if instance.source not in str(resource_file):
+                continue
+            mock = instance.mocks.get(normalize_keyword_name(keyword_name))
+            if not mock:
+                continue
+            original_run = keyword_runner.run
+
+            def patched_run(data, result, context, run,
+                            _mock=mock, _original_run=original_run):
+                args, kwargs = _resolve_arguments(
+                    keyword_runner.keyword, data, context
+                )
+                mock_result = _mock(*args, **kwargs)
+                # Test scope, so the value is visible to the keyword's own
+                # body even when the mocked keyword is called from inside
+                # another keyword rather than directly from the test.
+                context.variables.set_test(RETURN_VARIABLE, mock_result)
+                keyword_runner.keyword.body._items = [Return(values=[RETURN_VARIABLE])]  # pylint: disable=protected-access
+                return _original_run(data, result, context, run)
+
+            keyword_runner.run = patched_run
+            break
+
+        return keyword_runner
+
+    Namespace.get_runner = patched_get_runner
+
 
 def _resolve_arguments(keyword_obj, data, context):
     """Split a keyword call's raw arguments into resolved args and kwargs.
@@ -72,44 +146,37 @@ class MockResource(CallInspectionMixin):
 
     def __init__(self, source):
         self._source = source
-        self._original_get_runner = Namespace.get_runner
         self._original_items = {}
         self._original_setups = {}
         self._original_teardowns = {}
+        self._mocked_sources = {}
         self._mocks = {}
-        self._install_patch()
-
-    def _install_patch(self):
-        original_get_runner = self._original_get_runner
-        active_mocks = self._mocks
-        source = self._source
-
-        def patched_get_runner(self, keyword_name, recommend_on_failure):
-            keyword_runner = original_get_runner(self, keyword_name, recommend_on_failure)
-            resource_file = getattr(keyword_runner.keyword, "source", None)
-
-            if source not in str(resource_file):
-                return keyword_runner
-
-            mock = active_mocks.get(keyword_name)
-            if mock:
-                original_run = keyword_runner.run
-                def patched_run(data, result, context, run):
-                    args, kwargs = _resolve_arguments(
-                        keyword_runner.keyword, data, context
-                    )
-                    mock_result = mock(*args, **kwargs)
-                    # Test scope, so the value is visible to the keyword's own
-                    # body even when the mocked keyword is called from inside
-                    # another keyword rather than directly from the test.
-                    context.variables.set_test(RETURN_VARIABLE, mock_result)
-                    keyword_runner.keyword.body._items = [Return(values=[RETURN_VARIABLE])]  # pylint: disable=protected-access
-                    return original_run(data, result, context, run)
-                keyword_runner.run = patched_run
-
-            return keyword_runner
-
-        Namespace.get_runner = patched_get_runner
+        _INSTANCES.append(weakref.ref(self))
+        _install_shared_patch()
+
+    @property
+    def source(self):
+        """Return the resource file this instance mocks keywords from."""
+        return self._source
+
+    @property
+    def mocks(self):
+        """Return the active mocks, keyed by normalized keyword name."""
+        return self._mocks
+
+    def _mock_key(self, keyword_name: str) -> str:
+        """Return the ``self._mocks`` key for *keyword_name*.
+
+        Mocks are keyed the way Robot Framework matches keyword names, so
+        inspecting a call works whatever case or spacing the test used.
+
+        Args:
+            keyword_name: Keyword name as written in the test.
+
+        Returns:
+            The normalized name used as the mock key.
+        """
+        return normalize_keyword_name(keyword_name)
 
     @keyword
     def mock_keyword(
@@ -150,9 +217,12 @@ class MockResource(CallInspectionMixin):
         resource_file = getattr(keyword_runner.keyword, "source", None)
 
         if self._source not in str(resource_file):
-            raise AttributeError("fKeyword '{keyword_name}' not found in {self._source}")
+            raise AttributeError(
+                f"Keyword '{keyword_name}' not found in {self._source}"
+            )
 
         self._original_items[keyword_name] = keyword_runner.keyword.body._items  # pylint: disable=protected-access
+        self._mocked_sources[keyword_name] = resource_file
         if skip_setup:
             self._original_setups[keyword_name] = keyword_runner.keyword.setup
             keyword_runner.keyword.setup = None
@@ -160,7 +230,10 @@ class MockResource(CallInspectionMixin):
             self._original_teardowns[keyword_name] = keyword_runner.keyword.teardown
             keyword_runner.keyword.teardown = None
         mock = Mock(return_value=return_value, side_effect=side_effect)
-        self._mocks[keyword_name] = mock
+        self._mocks[normalize_keyword_name(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)
         return mock
 
     @keyword
@@ -174,6 +247,8 @@ class MockResource(CallInspectionMixin):
             | MockRes.Reset Mocks |
         """
         self._mocks.clear()
+        for keyword_name, source in self._mocked_sources.items():
+            unregister_mocked_keyword(source, keyword_name)
         for keyword_name, items in self._original_items.items():
             keyword_runner = BuiltIn()._namespace.get_runner(keyword_name, True)  # pylint: disable=protected-access
             keyword_runner.keyword.body._items = items  # pylint: disable=protected-access
@@ -186,6 +261,7 @@ class MockResource(CallInspectionMixin):
         self._original_items.clear()
         self._original_setups.clear()
         self._original_teardowns.clear()
+        self._mocked_sources.clear()
 
     @keyword
     def verify_keyword_called(self, keyword_name: str, times: int = None):
@@ -201,9 +277,6 @@ class MockResource(CallInspectionMixin):
         Example:
             | MockDB.Verify Keyword Called | Execute Sql | times=1 |
         """
-        if keyword_name not in self._mocks:
-            raise AssertionError(f"Keyword '{keyword_name}' was not mocked")
-
-        mock = self._mocks[keyword_name]
+        mock = self._get_mock(keyword_name)
         if times is not None and mock.call_count != times:
             raise AssertionError(f"Expected {times} calls, got {mock.call_count}")

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

@@ -8,10 +8,75 @@ implemented once here and mixed into both libraries, so the two cannot drift
 apart.
 """
 # pylint: disable=invalid-name
+import os
 from typing import Any, Dict, List
 from unittest.mock import call
 
 from robot.api.deco import keyword
+from robot.utils import normalize
+
+
+def normalize_keyword_name(name) -> str:
+    """Return a keyword name in the form Robot Framework matches on.
+
+    Robot treats keyword names as case-, space- and underscore-insensitive, so
+    mocks have to be keyed the same way. Without this, mocking ``Fetch Rows``
+    and calling ``fetch rows`` would silently run the real keyword.
+
+    Args:
+        name: Keyword name as written anywhere.
+
+    Returns:
+        The canonical comparison key for that name.
+    """
+    return normalize(str(name), ignore='_')
+
+
+# Keywords whose body is currently replaced by a mock, as
+# ``(absolute source path, normalized keyword name)`` pairs.
+#
+# MockCoverage consults this so a keyword that was only ever mocked is not
+# counted as covered: its real body never ran, and counting it would inflate the
+# reported coverage of the resource it lives in.
+MOCKED_KEYWORDS = set()
+
+
+def mocked_keyword_key(source, keyword_name) -> tuple:
+    """Build the registry key for a keyword in a resource file.
+
+    Args:
+        source: Path of the resource file defining the keyword.
+        keyword_name: Keyword name as written.
+
+    Returns:
+        The ``(source key, normalized name)`` tuple used by the registry.
+    """
+    return (os.path.normcase(os.path.abspath(str(source))),
+            normalize_keyword_name(keyword_name))
+
+
+def register_mocked_keyword(source, keyword_name) -> None:
+    """Record that a keyword's body is replaced by a mock."""
+    MOCKED_KEYWORDS.add(mocked_keyword_key(source, keyword_name))
+
+
+def unregister_mocked_keyword(source, keyword_name) -> None:
+    """Record that a keyword's body is restored."""
+    MOCKED_KEYWORDS.discard(mocked_keyword_key(source, keyword_name))
+
+
+def is_keyword_mocked(source_key: str, keyword_name) -> bool:
+    """Return whether a keyword is currently mocked.
+
+    Args:
+        source_key: Source path already normalised with ``os.path.normcase`` and
+            ``os.path.abspath``, as :func:`mocked_keyword_key` produces.
+        keyword_name: Keyword name as reported at execution time.
+
+    Returns:
+        ``True`` when the keyword's body is currently a mock.
+    """
+    return (source_key, normalize_keyword_name(keyword_name)) in MOCKED_KEYWORDS
 
 
 class CallInspectionMixin:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.7.0
+Version: 0.8.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -444,9 +444,39 @@ MockLibrary dynamically replaces keyword implementations:
 3. Stores original methods before mocking
 4. Replaces methods with mock implementations using Python's unittest.mock.Mock
 5. Returns mocked values or executes side effects
-6. Tracks call counts for verification
+6. Tracks call counts and call arguments for verification
 7. Raises AttributeError if attempting to mock a non-existent keyword
 
+#### Mocks are installed on the library class
+
+Step 4 replaces the method on the target library's **class**, not on the
+instance. Two consequences are worth knowing, because neither is reported as an
+error:
+
+**A mock stays active until `Reset Mocks`, across tests and suites.** The mock
+is not scoped to the test that created it. A test that mocks a keyword and
+leaves without resetting hands the mock to everything that follows. Reset in a
+teardown rather than at the end of a test body, so the mock is also removed when
+the test fails midway.
+
+**Two `MockLibrary` instances wrapping the same library share one mock.** Last
+registration wins, and resetting *either* instance restores the real method:
+
+```robot
+Library    MockLibrary    DateTime    WITH NAME    MockA
+Library    MockLibrary    DateTime    WITH NAME    MockB
+...
+MockA.Mock Keyword    Convert Time    return_value=from-a
+MockB.Mock Keyword    Convert Time    return_value=from-b
+${result}=    Convert Time    12:00:00      # from-b: MockA's mock was overwritten
+MockB.Reset Mocks
+${result}=    Convert Time    12:00:00      # the real keyword, although MockA never reset
+```
+
+Use a single alias per library, and separate aliases only for *different*
+libraries. `MockResource` is not affected: it keys mocks per resource file, so
+instances for different resources are independent.
+
 ### MockResource
 
 MockResource patches Robot Framework's keyword execution: