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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.5.0
+Version: 0.7.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -320,6 +320,37 @@ Mock a keyword with a return value or side effect.
 MockDB.Mock Keyword    query    return_value=test_data
 ```
 
+`return_value` may be any Python object, not only a string, so a keyword that
+forwards a query result or a parsed response body can be mocked directly:
+
+```robot
+${rows}=    Evaluate    [['Europe/Budapest']]
+MockRes.Mock Keyword    Run Query    return_value=${rows}
+```
+
+### Mocked keyword setup and teardown
+
+`MockResource` replaces only a keyword's **body**. Its `[Setup]` and `[Teardown]`
+still run, which keeps them observable — a test can assert that a teardown
+released a lock, for instance.
+
+That is a problem when the teardown cleans up state the replaced body would have
+created, because it then fails on the mocked call. Suppress it per mock:
+
+```robot
+# Init Client acquires a lock in its body and releases it in its teardown.
+# Without the body there is no lock to release, so skip the teardown.
+MockRes.Mock Keyword    Init Client    return_value=alias    skip_teardown=${True}
+MockRes.Mock Keyword    Init Client    return_value=alias    skip_setup=${True}
+```
+
+Both default to `False`, so existing tests are unaffected. `Reset Mocks`
+restores a suppressed setup or teardown along with the body.
+
+Prefer the default when the setup or teardown is part of the contract you are
+testing, and skip it when it is an implementation detail of a keyword the test
+is only standing in for.
+
 ### Reset Mocks
 
 Restore all mocked keywords to their original implementations.

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

@@ -296,6 +296,37 @@ Mock a keyword with a return value or side effect.
 MockDB.Mock Keyword    query    return_value=test_data
 ```
 
+`return_value` may be any Python object, not only a string, so a keyword that
+forwards a query result or a parsed response body can be mocked directly:
+
+```robot
+${rows}=    Evaluate    [['Europe/Budapest']]
+MockRes.Mock Keyword    Run Query    return_value=${rows}
+```
+
+### Mocked keyword setup and teardown
+
+`MockResource` replaces only a keyword's **body**. Its `[Setup]` and `[Teardown]`
+still run, which keeps them observable — a test can assert that a teardown
+released a lock, for instance.
+
+That is a problem when the teardown cleans up state the replaced body would have
+created, because it then fails on the mocked call. Suppress it per mock:
+
+```robot
+# Init Client acquires a lock in its body and releases it in its teardown.
+# Without the body there is no lock to release, so skip the teardown.
+MockRes.Mock Keyword    Init Client    return_value=alias    skip_teardown=${True}
+MockRes.Mock Keyword    Init Client    return_value=alias    skip_setup=${True}
+```
+
+Both default to `False`, so existing tests are unaffected. `Reset Mocks`
+restores a suppressed setup or teardown along with the body.
+
+Prefer the default when the setup or teardown is part of the contract you are
+testing, and skip it when it is an implementation detail of a keyword the test
+is only standing in for.
+
 ### Reset Mocks
 
 Restore all mocked keywords to their original implementations.

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

@@ -1,6 +1,6 @@
 [metadata]
 name = robotframework-mock
-version = 0.5.0
+version = 0.7.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.5.0 → robotframework_mock-0.7.0}/src/MockResource/__init__.py

@@ -11,6 +11,13 @@ from robot.utils import split_from_equals
 
 from _mock_core import CallInspectionMixin
 
+# 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
+# a string raises a TypeError. The value is therefore published under this name
+# and the injected RETURN refers to it, which lets a mock return any Python
+# object (a query result set, a parsed JSON body, a list of pods...).
+RETURN_VARIABLE = '${__mock_resource_return__}'
+
 
 def _resolve_arguments(keyword_obj, data, context):
     """Split a keyword call's raw arguments into resolved args and kwargs.
@@ -67,6 +74,8 @@ class MockResource(CallInspectionMixin):
         self._source = source
         self._original_get_runner = Namespace.get_runner
         self._original_items = {}
+        self._original_setups = {}
+        self._original_teardowns = {}
         self._mocks = {}
         self._install_patch()
 
@@ -90,7 +99,11 @@ class MockResource(CallInspectionMixin):
                         keyword_runner.keyword, data, context
                     )
                     mock_result = mock(*args, **kwargs)
-                    keyword_runner.keyword.body._items = [Return(values=[mock_result])]  # pylint: disable=protected-access
+                    # 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
 
@@ -101,22 +114,37 @@ class MockResource(CallInspectionMixin):
     @keyword
     def mock_keyword(
         self, keyword_name: str,
-        return_value: Any = None, side_effect: Callable = None
+        return_value: Any = None, side_effect: Callable = None,
+        skip_setup: bool = False, skip_teardown: bool = False
     ):
         """Mock a keyword from the resource file.
-        
+
+        Only the keyword's body is replaced. Its ``[Setup]`` and ``[Teardown]``
+        still run by default, which keeps them observable - a test can assert
+        that a teardown released a lock, for example. Suppress them when the
+        mocked keyword's own setup or teardown is an implementation detail the
+        test should not depend on, typically because it cleans up state that the
+        replaced body would have created and therefore fails.
+
         Args:
             keyword_name: Name of the keyword to mock
-            return_value: Value to return when the keyword is called
+            return_value: Value to return when the keyword is called. May be any
+                Python object.
             side_effect: Callable to execute instead of returning a value.
                 Receives the call's resolved arguments, the same way a
                 ``MockLibrary`` side effect does.
+            skip_setup: Do not run the keyword's ``[Setup]`` while mocked.
+            skip_teardown: Do not run the keyword's ``[Teardown]`` while mocked.
 
         Returns:
             The :class:`unittest.mock.Mock` backing the keyword.
 
+        Raises:
+            AttributeError: If the keyword is not found in the resource file.
+
         Example:
             | MockRes.Mock Keyword | My Keyword | return_value=test_data |
+            | MockRes.Mock Keyword | Init Client | skip_teardown=${True} |
         """
         keyword_runner = BuiltIn()._namespace.get_runner(keyword_name, True)  # pylint: disable=protected-access
         resource_file = getattr(keyword_runner.keyword, "source", None)
@@ -125,6 +153,12 @@ class MockResource(CallInspectionMixin):
             raise AttributeError("fKeyword '{keyword_name}' not found in {self._source}")
 
         self._original_items[keyword_name] = keyword_runner.keyword.body._items  # pylint: disable=protected-access
+        if skip_setup:
+            self._original_setups[keyword_name] = keyword_runner.keyword.setup
+            keyword_runner.keyword.setup = None
+        if skip_teardown:
+            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
         return mock
@@ -133,8 +167,9 @@ class MockResource(CallInspectionMixin):
     def reset_mocks(self):
         """Reset all mocks to their original implementations.
         
-        Restores all mocked keywords to their original behavior.
-        
+        Restores all mocked keywords to their original behavior, including any
+        ``[Setup]`` or ``[Teardown]`` that was suppressed while mocked.
+
         Example:
             | MockRes.Reset Mocks |
         """
@@ -142,7 +177,15 @@ class MockResource(CallInspectionMixin):
         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
+        for keyword_name, setup in self._original_setups.items():
+            keyword_runner = BuiltIn()._namespace.get_runner(keyword_name, True)  # pylint: disable=protected-access
+            keyword_runner.keyword.setup = setup
+        for keyword_name, teardown in self._original_teardowns.items():
+            keyword_runner = BuiltIn()._namespace.get_runner(keyword_name, True)  # pylint: disable=protected-access
+            keyword_runner.keyword.teardown = teardown
         self._original_items.clear()
+        self._original_setups.clear()
+        self._original_teardowns.clear()
 
     @keyword
     def verify_keyword_called(self, keyword_name: str, times: int = None):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.5.0
+Version: 0.7.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -320,6 +320,37 @@ Mock a keyword with a return value or side effect.
 MockDB.Mock Keyword    query    return_value=test_data
 ```
 
+`return_value` may be any Python object, not only a string, so a keyword that
+forwards a query result or a parsed response body can be mocked directly:
+
+```robot
+${rows}=    Evaluate    [['Europe/Budapest']]
+MockRes.Mock Keyword    Run Query    return_value=${rows}
+```
+
+### Mocked keyword setup and teardown
+
+`MockResource` replaces only a keyword's **body**. Its `[Setup]` and `[Teardown]`
+still run, which keeps them observable — a test can assert that a teardown
+released a lock, for instance.
+
+That is a problem when the teardown cleans up state the replaced body would have
+created, because it then fails on the mocked call. Suppress it per mock:
+
+```robot
+# Init Client acquires a lock in its body and releases it in its teardown.
+# Without the body there is no lock to release, so skip the teardown.
+MockRes.Mock Keyword    Init Client    return_value=alias    skip_teardown=${True}
+MockRes.Mock Keyword    Init Client    return_value=alias    skip_setup=${True}
+```
+
+Both default to `False`, so existing tests are unaffected. `Reset Mocks`
+restores a suppressed setup or teardown along with the body.
+
+Prefer the default when the setup or teardown is part of the contract you are
+testing, and skip it when it is an implementation detail of a keyword the test
+is only standing in for.
+
 ### Reset Mocks
 
 Restore all mocked keywords to their original implementations.