robotframework-mock 0.2.0__tar.gz → 0.3.0__tar.gz

{robotframework_mock-0.2.0/src/robotframework_mock.egg-info → robotframework_mock-0.3.0}/PKG-INFO

@@ -1,209 +1,209 @@
-Metadata-Version: 2.4
-Name: robotframework-mock
-Version: 0.2.0
-Summary: A Robot Framework library for mocking keywords in unit tests
-Home-page: https://github.com/olesz/robotframework-mock
-Author: Lajos Olah
-Author-email: lajos.olah.jr@gmail.com
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: Framework :: Robot Framework
-Classifier: Framework :: Robot Framework :: Library
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: robotframework>=7.0
-Dynamic: license-file
-
-# robotframework-mock
-
-A Robot Framework library for mocking keywords in unit tests.
-
-## Installation
-
-### From PyPI (once published)
-
-```bash
-pip install robotframework-mock
-```
-
-### From source
-
-```bash
-git clone https://github.com/yourusername/robotframework-mock.git
-cd robotframework-mock
-pip install .
-```
-
-### For development
-
-```bash
-pip install -e .
-pip install -r requirements-dev.txt
-```
-
-## Features
-
-- Mock keywords from any Robot Framework library
-- Mock keywords from Robot Framework resource files
-- Mock Robot Framework's BuiltIn keywords
-- Support for keywords with custom names via @keyword decorator
-- Verify keyword calls and call counts
-- Simple API with three main keywords
-
-## Usage
-
-### Mock Library Keywords
-
-Import the library you want to mock, then create a MockLibrary instance for it:
-
-```robot
-*** Settings ***
-Library    DatabaseLibrary
-Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
-
-*** Test Cases ***
-Test With Mocked Keyword
-    MockDB.Mock Keyword    query    return_value=test_data
-    ${result}=    DatabaseLibrary.Query    SELECT * FROM users
-    Should Be Equal    ${result}    test_data
-    MockDB.Reset Mocks
-```
-
-### Verify Calls
-
-Verify that a keyword was called and optionally check the call count:
-
-```robot
-*** Test Cases ***
-Test Keyword Was Called
-    MockDB.Mock Keyword    execute_sql    return_value=${None}
-    Process User Registration
-    MockDB.Verify Keyword Called    execute_sql    times=1
-    MockDB.Reset Mocks
-```
-
-### Mock BuiltIn Keywords
-
-Mock Robot Framework's built-in keywords using the same MockLibrary with "BuiltIn" as the library name:
-
-```robot
-*** Settings ***
-Library    MockLibrary    BuiltIn    WITH NAME    MockBin
-
-*** Test Cases ***
-Test BuiltIn Mock
-    MockBin.Mock Keyword    Convert To Binary    return_value=test_data
-    ${result}=    Convert To Binary    aaa
-    Should Be Equal    ${result}    test_data
-    MockBin.Reset Mocks
-```
-
-### Mock Multiple Libraries
-
-You can mock multiple libraries in the same test:
-
-```robot
-*** Settings ***
-Library    DatabaseLibrary
-Library    RequestsLibrary
-Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
-Library    MockLibrary    RequestsLibrary    WITH NAME    MockReq
-
-*** Test Cases ***
-Test Multiple Mocks
-    MockDB.Mock Keyword    query    return_value=user_data
-    MockReq.Mock Keyword    get    return_value=api_response
-    # Your test code here
-    MockDB.Reset Mocks
-    MockReq.Reset Mocks
-```
-
-### Mock Resource Keywords
-
-Mock keywords from Robot Framework resource files:
-
-```robot
-*** Settings ***
-Resource    my_resource.robot
-Library     MockResource    my_resource.robot    WITH NAME    MockRes
-
-*** Test Cases ***
-Test Resource Keyword Mock
-    MockRes.Mock Keyword    My Custom Keyword    return_value=mocked_value
-    ${result}=    My Custom Keyword
-    Should Be Equal    ${result}    mocked_value
-    MockRes.Reset Mocks
-```
-
-## Keywords
-
-### Mock Keyword
-
-Mock a keyword with a return value or side effect.
-
-**Arguments:**
-- `keyword_name` - Name of the keyword to mock
-- `return_value` - Value to return when called (optional)
-- `side_effect` - Callable to execute instead (optional)
-
-**Example:**
-```robot
-MockDB.Mock Keyword    query    return_value=test_data
-```
-
-### Reset Mocks
-
-Restore all mocked keywords to their original implementations.
-
-**Example:**
-```robot
-MockDB.Reset Mocks
-```
-
-### Verify Keyword Called
-
-Verify a keyword was called, optionally checking call count.
-
-**Arguments:**
-- `keyword_name` - Name of the keyword to verify
-- `times` - Expected number of calls (optional)
-
-**Example:**
-```robot
-MockDB.Verify Keyword Called    execute_sql    times=1
-```
-
-## How It Works
-
-### MockLibrary
-
-MockLibrary dynamically replaces keyword implementations:
-1. Wraps the target library instance
-2. Resolves keyword names to function names (handles @keyword decorator)
-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
-7. Raises AttributeError if attempting to mock a non-existent keyword
-
-### MockResource
-
-MockResource patches Robot Framework's keyword execution:
-1. Patches the Namespace.get_runner method
-2. Intercepts keyword execution for the specified resource file
-3. Replaces keyword body with Return statement containing mocked value
-4. Tracks call counts for verification
-5. Restores original keyword body on reset
-
-## Notes
-
-- Both libraries use `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
-- Built on Python's unittest.mock.Mock for robust mocking capabilities
-- MockLibrary supports any Robot Framework library, including BuiltIn
-- MockResource works with resource files by patching the keyword execution pipeline
-
-## License
-
-See LICENSE file for details.
+Metadata-Version: 2.4
+Name: robotframework-mock
+Version: 0.3.0
+Summary: A Robot Framework library for mocking keywords in unit tests
+Home-page: https://github.com/olesz/robotframework-mock
+Author: Lajos Olah
+Author-email: lajos.olah.jr@gmail.com
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Library
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework>=7.0
+Dynamic: license-file
+
+# robotframework-mock
+
+A Robot Framework library for mocking keywords in unit tests.
+
+## Installation
+
+### From PyPI (once published)
+
+```bash
+pip install robotframework-mock
+```
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/robotframework-mock.git
+cd robotframework-mock
+pip install .
+```
+
+### For development
+
+```bash
+pip install -e .
+pip install -r requirements-dev.txt
+```
+
+## Features
+
+- Mock keywords from any Robot Framework library
+- Mock keywords from Robot Framework resource files
+- Mock Robot Framework's BuiltIn keywords
+- Support for keywords with custom names via @keyword decorator
+- Verify keyword calls and call counts
+- Simple API with three main keywords
+
+## Usage
+
+### Mock Library Keywords
+
+Import the library you want to mock, then create a MockLibrary instance for it:
+
+```robot
+*** Settings ***
+Library    DatabaseLibrary
+Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
+
+*** Test Cases ***
+Test With Mocked Keyword
+    MockDB.Mock Keyword    query    return_value=test_data
+    ${result}=    DatabaseLibrary.Query    SELECT * FROM users
+    Should Be Equal    ${result}    test_data
+    MockDB.Reset Mocks
+```
+
+### Verify Calls
+
+Verify that a keyword was called and optionally check the call count:
+
+```robot
+*** Test Cases ***
+Test Keyword Was Called
+    MockDB.Mock Keyword    execute_sql    return_value=${None}
+    Process User Registration
+    MockDB.Verify Keyword Called    execute_sql    times=1
+    MockDB.Reset Mocks
+```
+
+### Mock BuiltIn Keywords
+
+Mock Robot Framework's built-in keywords using the same MockLibrary with "BuiltIn" as the library name:
+
+```robot
+*** Settings ***
+Library    MockLibrary    BuiltIn    WITH NAME    MockBin
+
+*** Test Cases ***
+Test BuiltIn Mock
+    MockBin.Mock Keyword    Convert To Binary    return_value=test_data
+    ${result}=    Convert To Binary    aaa
+    Should Be Equal    ${result}    test_data
+    MockBin.Reset Mocks
+```
+
+### Mock Multiple Libraries
+
+You can mock multiple libraries in the same test:
+
+```robot
+*** Settings ***
+Library    DatabaseLibrary
+Library    RequestsLibrary
+Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
+Library    MockLibrary    RequestsLibrary    WITH NAME    MockReq
+
+*** Test Cases ***
+Test Multiple Mocks
+    MockDB.Mock Keyword    query    return_value=user_data
+    MockReq.Mock Keyword    get    return_value=api_response
+    # Your test code here
+    MockDB.Reset Mocks
+    MockReq.Reset Mocks
+```
+
+### Mock Resource Keywords
+
+Mock keywords from Robot Framework resource files:
+
+```robot
+*** Settings ***
+Resource    my_resource.robot
+Library     MockResource    my_resource.robot    WITH NAME    MockRes
+
+*** Test Cases ***
+Test Resource Keyword Mock
+    MockRes.Mock Keyword    My Custom Keyword    return_value=mocked_value
+    ${result}=    My Custom Keyword
+    Should Be Equal    ${result}    mocked_value
+    MockRes.Reset Mocks
+```
+
+## Keywords
+
+### Mock Keyword
+
+Mock a keyword with a return value or side effect.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to mock
+- `return_value` - Value to return when called (optional)
+- `side_effect` - Callable to execute instead (optional)
+
+**Example:**
+```robot
+MockDB.Mock Keyword    query    return_value=test_data
+```
+
+### Reset Mocks
+
+Restore all mocked keywords to their original implementations.
+
+**Example:**
+```robot
+MockDB.Reset Mocks
+```
+
+### Verify Keyword Called
+
+Verify a keyword was called, optionally checking call count.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to verify
+- `times` - Expected number of calls (optional)
+
+**Example:**
+```robot
+MockDB.Verify Keyword Called    execute_sql    times=1
+```
+
+## How It Works
+
+### MockLibrary
+
+MockLibrary dynamically replaces keyword implementations:
+1. Wraps the target library instance
+2. Resolves keyword names to function names (handles @keyword decorator)
+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
+7. Raises AttributeError if attempting to mock a non-existent keyword
+
+### MockResource
+
+MockResource patches Robot Framework's keyword execution:
+1. Patches the Namespace.get_runner method
+2. Intercepts keyword execution for the specified resource file
+3. Replaces keyword body with Return statement containing mocked value
+4. Tracks call counts for verification
+5. Restores original keyword body on reset
+
+## Notes
+
+- Both libraries use `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
+- Built on Python's unittest.mock.Mock for robust mocking capabilities
+- MockLibrary supports any Robot Framework library, including BuiltIn
+- MockResource works with resource files by patching the keyword execution pipeline
+
+## License
+
+See LICENSE file for details.

{robotframework_mock-0.2.0 → robotframework_mock-0.3.0}/setup.cfg

@@ -1,31 +1,31 @@
-[metadata]
-name = robotframework-mock
-version = 0.2.0
-author = Lajos Olah
-author_email = lajos.olah.jr@gmail.com
-description = A Robot Framework library for mocking keywords in unit tests
-long_description = file: README.md
-long_description_content_type = text/markdown
-url = https://github.com/olesz/robotframework-mock
-license = Apache-2.0
-classifiers = 
-	Programming Language :: Python :: 3
-	Operating System :: OS Independent
-	Framework :: Robot Framework
-	Framework :: Robot Framework :: Library
-
-[options]
-package_dir = 
-	= src
-packages = find:
-python_requires = >=3.7
-install_requires = 
-	robotframework>=7.0
-
-[options.packages.find]
-where = src
-
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[metadata]
+name = robotframework-mock
+version = 0.3.0
+author = Lajos Olah
+author_email = lajos.olah.jr@gmail.com
+description = A Robot Framework library for mocking keywords in unit tests
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/olesz/robotframework-mock
+license = Apache-2.0
+classifiers = 
+	Programming Language :: Python :: 3
+	Operating System :: OS Independent
+	Framework :: Robot Framework
+	Framework :: Robot Framework :: Library
+
+[options]
+package_dir = 
+	= src
+packages = find:
+python_requires = >=3.7
+install_requires = 
+	robotframework>=7.0
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

{robotframework_mock-0.2.0 → robotframework_mock-0.3.0}/src/MockLibrary/__init__.py

@@ -1,6 +1,8 @@
 """Mock library for Robot Framework keyword mocking in unit tests."""
 # pylint: disable=invalid-name
+import importlib.util
 import inspect
+import os
 from typing import Any, Callable
 from unittest.mock import Mock
 from robot.api.deco import keyword
@@ -28,6 +30,49 @@ def _get_library_instance(library_name_or_alias):
     return lib
 
 
+def _resolve_original_method(lib, method_name, keyword_name):
+    # Try direct attribute lookup first
+    try:
+        return getattr(lib, method_name), method_name
+    except AttributeError:
+        # If not found, search for methods with @keyword decorator custom names
+        for name, method in inspect.getmembers(
+                lib, inspect.ismethod
+        ):
+            if (hasattr(method, 'robot_name') and
+                    method.robot_name.lower() == keyword_name):
+                return getattr(lib, name), name
+
+    return None, method_name
+
+
+def _load_custom_resolver(resolver_path: str):
+    """Load a custom resolver from a Python file and instantiate it.
+
+    Args:
+        resolver_path: Relative path to a Python file containing a resolver class
+
+    Returns:
+        An instance of the resolver class found in the file
+
+    Raises:
+        FileNotFoundError: If the resolver file does not exist
+        AttributeError: If no class with resolve_original_method is found
+    """
+    abs_path = os.path.abspath(resolver_path)
+    if not os.path.isfile(abs_path):
+        raise FileNotFoundError(f"Custom resolver file not found: {abs_path}")
+    spec = importlib.util.spec_from_file_location("custom_resolver", abs_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    for _, obj in inspect.getmembers(module, inspect.isclass):
+        if hasattr(obj, 'resolve_original_method'):
+            return obj()
+    raise AttributeError(
+        f"No class with 'resolve_original_method' found in {abs_path}"
+    )
+
+
 class MockLibrary():
     """Mock keywords from any Robot Framework library for unit testing.
     
@@ -42,22 +87,22 @@ class MockLibrary():
 
     ROBOT_LIBRARY_SCOPE = 'GLOBAL'
 
-    def __init__(self, library_name_or_alias: str, lib: Any = None):
+    def __init__(self, library_name_or_alias: str, custom_resolver_path: str = None):
         """Initialize MockLibrary with a target library to mock.
         
         Args:
             library_name_or_alias: Name or alias of the library to mock
-            lib: Optional library instance (for testing purposes)
+            custom_resolver_path: Optional relative path to a Python file
+                containing a custom resolver class with a
+                resolve_original_method(lib, method_name, keyword_name) method
         """
-        # Store original method references before mocking
         self._original_methods = {}
-        # Store Mock objects for verification
         self._mocks = {}
-        # Get or set the library instance to mock
-        if lib:
-            self._library_instance = lib
-        else:
-            self._library_instance = _get_library_instance(library_name_or_alias)
+        self._library_instance = _get_library_instance(library_name_or_alias)
+        self._custom_resolver = (
+            _load_custom_resolver(custom_resolver_path)
+            if custom_resolver_path else None
+        )
 
     @keyword
     def mock_keyword(
@@ -80,20 +125,17 @@ class MockLibrary():
 
         # Only store original method once per keyword
         if method_name not in self._original_methods:
-            original_method = None
-            # Try direct attribute lookup first
-            try:
-                original_method = getattr(lib, method_name)
-            except AttributeError:
-                # If not found, search for methods with @keyword decorator custom names
-                for name, method in inspect.getmembers(
-                    lib, inspect.ismethod
-                ):
-                    if (hasattr(method, 'robot_name') and
-                            method.robot_name.lower() == keyword_name):
-                        original_method = getattr(lib, name)
-                        method_name = name
-                        break
+            if self._custom_resolver:
+                original_method, method_name = (
+                    self._custom_resolver.resolve_original_method(
+                        lib, method_name, keyword_name, side_effect
+                    )
+                )
+            else:
+                original_method, method_name = _resolve_original_method(
+                    lib, method_name, keyword_name
+                )
+
             # Raise error if keyword doesn't exist
             if not original_method:
                 raise AttributeError(f"Keyword '{keyword_name}' not found in {lib}")

{robotframework_mock-0.2.0 → robotframework_mock-0.3.0}/src/MockResource/__init__.py

@@ -1,113 +1,113 @@
-"""Mock resource for Robot Framework keyword mocking in unit tests."""
-# pylint: disable=invalid-name
-from typing import Any, Callable
-from unittest.mock import Mock
-
-from robot.api.deco import keyword
-from robot.libraries.BuiltIn import BuiltIn
-from robot.running import Return
-from robot.running.namespace import Namespace
-
-
-class MockResource:
-    """Mock keywords from Robot Framework resource files for unit testing.
-    
-    Example:
-        | Library | MockResource | my_resource.robot | WITH NAME | MockRes |
-        | MockRes.Mock Keyword | My Keyword | return_value=test_data |
-        | My Keyword |
-        | MockRes.Reset Mocks |
-    """
-
-    def __init__(self, source):
-        self._source = source
-        self._original_get_runner = Namespace.get_runner
-        self._original_items = {}
-        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):
-                    mock_result = mock(data.args)
-                    keyword_runner.keyword.body._items = [Return(values=[mock_result])]  # 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
-
-    @keyword
-    def mock_keyword(
-        self, keyword_name: str,
-        return_value: Any = None, side_effect: Callable = None
-    ):
-        """Mock a keyword from the resource file.
-        
-        Args:
-            keyword_name: Name of the keyword to mock
-            return_value: Value to return when the keyword is called
-            side_effect: Callable to execute instead of returning a value
-        
-        Example:
-            | MockRes.Mock Keyword | My Keyword | return_value=test_data |
-        """
-        keyword_runner = BuiltIn()._namespace.get_runner(keyword_name, True)  # pylint: disable=protected-access
-        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}")
-
-        self._original_items[keyword_name] = keyword_runner.keyword.body._items  # pylint: disable=protected-access
-        mock = Mock(return_value=return_value, side_effect=side_effect)
-        self._mocks[keyword_name] = mock
-
-    @keyword
-    def reset_mocks(self):
-        """Reset all mocks to their original implementations.
-        
-        Restores all mocked keywords to their original behavior.
-        
-        Example:
-            | MockRes.Reset Mocks |
-        """
-        self._mocks.clear()
-        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
-        self._original_items.clear()
-
-    @keyword
-    def verify_keyword_called(self, keyword_name: str, times: int = None):
-        """Verify that a mocked keyword was called.
-        
-        Args:
-            keyword_name: Name of the keyword to verify
-            times: Expected number of calls (optional)
-        
-        Raises:
-            AssertionError: If keyword was not mocked or call count doesn't match
-
-        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]
-        if times is not None and mock.call_count != times:
-            raise AssertionError(f"Expected {times} calls, got {mock.call_count}")
+"""Mock resource for Robot Framework keyword mocking in unit tests."""
+# pylint: disable=invalid-name
+from typing import Any, Callable
+from unittest.mock import Mock
+
+from robot.api.deco import keyword
+from robot.libraries.BuiltIn import BuiltIn
+from robot.running import Return
+from robot.running.namespace import Namespace
+
+
+class MockResource:
+    """Mock keywords from Robot Framework resource files for unit testing.
+    
+    Example:
+        | Library | MockResource | my_resource.robot | WITH NAME | MockRes |
+        | MockRes.Mock Keyword | My Keyword | return_value=test_data |
+        | My Keyword |
+        | MockRes.Reset Mocks |
+    """
+
+    def __init__(self, source):
+        self._source = source
+        self._original_get_runner = Namespace.get_runner
+        self._original_items = {}
+        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):
+                    mock_result = mock(data.args)
+                    keyword_runner.keyword.body._items = [Return(values=[mock_result])]  # 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
+
+    @keyword
+    def mock_keyword(
+        self, keyword_name: str,
+        return_value: Any = None, side_effect: Callable = None
+    ):
+        """Mock a keyword from the resource file.
+        
+        Args:
+            keyword_name: Name of the keyword to mock
+            return_value: Value to return when the keyword is called
+            side_effect: Callable to execute instead of returning a value
+        
+        Example:
+            | MockRes.Mock Keyword | My Keyword | return_value=test_data |
+        """
+        keyword_runner = BuiltIn()._namespace.get_runner(keyword_name, True)  # pylint: disable=protected-access
+        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}")
+
+        self._original_items[keyword_name] = keyword_runner.keyword.body._items  # pylint: disable=protected-access
+        mock = Mock(return_value=return_value, side_effect=side_effect)
+        self._mocks[keyword_name] = mock
+
+    @keyword
+    def reset_mocks(self):
+        """Reset all mocks to their original implementations.
+        
+        Restores all mocked keywords to their original behavior.
+        
+        Example:
+            | MockRes.Reset Mocks |
+        """
+        self._mocks.clear()
+        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
+        self._original_items.clear()
+
+    @keyword
+    def verify_keyword_called(self, keyword_name: str, times: int = None):
+        """Verify that a mocked keyword was called.
+        
+        Args:
+            keyword_name: Name of the keyword to verify
+            times: Expected number of calls (optional)
+        
+        Raises:
+            AssertionError: If keyword was not mocked or call count doesn't match
+
+        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]
+        if times is not None and mock.call_count != times:
+            raise AssertionError(f"Expected {times} calls, got {mock.call_count}")

{robotframework_mock-0.2.0 → robotframework_mock-0.3.0/src/robotframework_mock.egg-info}/PKG-INFO

@@ -1,209 +1,209 @@
-Metadata-Version: 2.4
-Name: robotframework-mock
-Version: 0.2.0
-Summary: A Robot Framework library for mocking keywords in unit tests
-Home-page: https://github.com/olesz/robotframework-mock
-Author: Lajos Olah
-Author-email: lajos.olah.jr@gmail.com
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: Framework :: Robot Framework
-Classifier: Framework :: Robot Framework :: Library
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: robotframework>=7.0
-Dynamic: license-file
-
-# robotframework-mock
-
-A Robot Framework library for mocking keywords in unit tests.
-
-## Installation
-
-### From PyPI (once published)
-
-```bash
-pip install robotframework-mock
-```
-
-### From source
-
-```bash
-git clone https://github.com/yourusername/robotframework-mock.git
-cd robotframework-mock
-pip install .
-```
-
-### For development
-
-```bash
-pip install -e .
-pip install -r requirements-dev.txt
-```
-
-## Features
-
-- Mock keywords from any Robot Framework library
-- Mock keywords from Robot Framework resource files
-- Mock Robot Framework's BuiltIn keywords
-- Support for keywords with custom names via @keyword decorator
-- Verify keyword calls and call counts
-- Simple API with three main keywords
-
-## Usage
-
-### Mock Library Keywords
-
-Import the library you want to mock, then create a MockLibrary instance for it:
-
-```robot
-*** Settings ***
-Library    DatabaseLibrary
-Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
-
-*** Test Cases ***
-Test With Mocked Keyword
-    MockDB.Mock Keyword    query    return_value=test_data
-    ${result}=    DatabaseLibrary.Query    SELECT * FROM users
-    Should Be Equal    ${result}    test_data
-    MockDB.Reset Mocks
-```
-
-### Verify Calls
-
-Verify that a keyword was called and optionally check the call count:
-
-```robot
-*** Test Cases ***
-Test Keyword Was Called
-    MockDB.Mock Keyword    execute_sql    return_value=${None}
-    Process User Registration
-    MockDB.Verify Keyword Called    execute_sql    times=1
-    MockDB.Reset Mocks
-```
-
-### Mock BuiltIn Keywords
-
-Mock Robot Framework's built-in keywords using the same MockLibrary with "BuiltIn" as the library name:
-
-```robot
-*** Settings ***
-Library    MockLibrary    BuiltIn    WITH NAME    MockBin
-
-*** Test Cases ***
-Test BuiltIn Mock
-    MockBin.Mock Keyword    Convert To Binary    return_value=test_data
-    ${result}=    Convert To Binary    aaa
-    Should Be Equal    ${result}    test_data
-    MockBin.Reset Mocks
-```
-
-### Mock Multiple Libraries
-
-You can mock multiple libraries in the same test:
-
-```robot
-*** Settings ***
-Library    DatabaseLibrary
-Library    RequestsLibrary
-Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
-Library    MockLibrary    RequestsLibrary    WITH NAME    MockReq
-
-*** Test Cases ***
-Test Multiple Mocks
-    MockDB.Mock Keyword    query    return_value=user_data
-    MockReq.Mock Keyword    get    return_value=api_response
-    # Your test code here
-    MockDB.Reset Mocks
-    MockReq.Reset Mocks
-```
-
-### Mock Resource Keywords
-
-Mock keywords from Robot Framework resource files:
-
-```robot
-*** Settings ***
-Resource    my_resource.robot
-Library     MockResource    my_resource.robot    WITH NAME    MockRes
-
-*** Test Cases ***
-Test Resource Keyword Mock
-    MockRes.Mock Keyword    My Custom Keyword    return_value=mocked_value
-    ${result}=    My Custom Keyword
-    Should Be Equal    ${result}    mocked_value
-    MockRes.Reset Mocks
-```
-
-## Keywords
-
-### Mock Keyword
-
-Mock a keyword with a return value or side effect.
-
-**Arguments:**
-- `keyword_name` - Name of the keyword to mock
-- `return_value` - Value to return when called (optional)
-- `side_effect` - Callable to execute instead (optional)
-
-**Example:**
-```robot
-MockDB.Mock Keyword    query    return_value=test_data
-```
-
-### Reset Mocks
-
-Restore all mocked keywords to their original implementations.
-
-**Example:**
-```robot
-MockDB.Reset Mocks
-```
-
-### Verify Keyword Called
-
-Verify a keyword was called, optionally checking call count.
-
-**Arguments:**
-- `keyword_name` - Name of the keyword to verify
-- `times` - Expected number of calls (optional)
-
-**Example:**
-```robot
-MockDB.Verify Keyword Called    execute_sql    times=1
-```
-
-## How It Works
-
-### MockLibrary
-
-MockLibrary dynamically replaces keyword implementations:
-1. Wraps the target library instance
-2. Resolves keyword names to function names (handles @keyword decorator)
-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
-7. Raises AttributeError if attempting to mock a non-existent keyword
-
-### MockResource
-
-MockResource patches Robot Framework's keyword execution:
-1. Patches the Namespace.get_runner method
-2. Intercepts keyword execution for the specified resource file
-3. Replaces keyword body with Return statement containing mocked value
-4. Tracks call counts for verification
-5. Restores original keyword body on reset
-
-## Notes
-
-- Both libraries use `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
-- Built on Python's unittest.mock.Mock for robust mocking capabilities
-- MockLibrary supports any Robot Framework library, including BuiltIn
-- MockResource works with resource files by patching the keyword execution pipeline
-
-## License
-
-See LICENSE file for details.
+Metadata-Version: 2.4
+Name: robotframework-mock
+Version: 0.3.0
+Summary: A Robot Framework library for mocking keywords in unit tests
+Home-page: https://github.com/olesz/robotframework-mock
+Author: Lajos Olah
+Author-email: lajos.olah.jr@gmail.com
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Library
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework>=7.0
+Dynamic: license-file
+
+# robotframework-mock
+
+A Robot Framework library for mocking keywords in unit tests.
+
+## Installation
+
+### From PyPI (once published)
+
+```bash
+pip install robotframework-mock
+```
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/robotframework-mock.git
+cd robotframework-mock
+pip install .
+```
+
+### For development
+
+```bash
+pip install -e .
+pip install -r requirements-dev.txt
+```
+
+## Features
+
+- Mock keywords from any Robot Framework library
+- Mock keywords from Robot Framework resource files
+- Mock Robot Framework's BuiltIn keywords
+- Support for keywords with custom names via @keyword decorator
+- Verify keyword calls and call counts
+- Simple API with three main keywords
+
+## Usage
+
+### Mock Library Keywords
+
+Import the library you want to mock, then create a MockLibrary instance for it:
+
+```robot
+*** Settings ***
+Library    DatabaseLibrary
+Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
+
+*** Test Cases ***
+Test With Mocked Keyword
+    MockDB.Mock Keyword    query    return_value=test_data
+    ${result}=    DatabaseLibrary.Query    SELECT * FROM users
+    Should Be Equal    ${result}    test_data
+    MockDB.Reset Mocks
+```
+
+### Verify Calls
+
+Verify that a keyword was called and optionally check the call count:
+
+```robot
+*** Test Cases ***
+Test Keyword Was Called
+    MockDB.Mock Keyword    execute_sql    return_value=${None}
+    Process User Registration
+    MockDB.Verify Keyword Called    execute_sql    times=1
+    MockDB.Reset Mocks
+```
+
+### Mock BuiltIn Keywords
+
+Mock Robot Framework's built-in keywords using the same MockLibrary with "BuiltIn" as the library name:
+
+```robot
+*** Settings ***
+Library    MockLibrary    BuiltIn    WITH NAME    MockBin
+
+*** Test Cases ***
+Test BuiltIn Mock
+    MockBin.Mock Keyword    Convert To Binary    return_value=test_data
+    ${result}=    Convert To Binary    aaa
+    Should Be Equal    ${result}    test_data
+    MockBin.Reset Mocks
+```
+
+### Mock Multiple Libraries
+
+You can mock multiple libraries in the same test:
+
+```robot
+*** Settings ***
+Library    DatabaseLibrary
+Library    RequestsLibrary
+Library    MockLibrary    DatabaseLibrary    WITH NAME    MockDB
+Library    MockLibrary    RequestsLibrary    WITH NAME    MockReq
+
+*** Test Cases ***
+Test Multiple Mocks
+    MockDB.Mock Keyword    query    return_value=user_data
+    MockReq.Mock Keyword    get    return_value=api_response
+    # Your test code here
+    MockDB.Reset Mocks
+    MockReq.Reset Mocks
+```
+
+### Mock Resource Keywords
+
+Mock keywords from Robot Framework resource files:
+
+```robot
+*** Settings ***
+Resource    my_resource.robot
+Library     MockResource    my_resource.robot    WITH NAME    MockRes
+
+*** Test Cases ***
+Test Resource Keyword Mock
+    MockRes.Mock Keyword    My Custom Keyword    return_value=mocked_value
+    ${result}=    My Custom Keyword
+    Should Be Equal    ${result}    mocked_value
+    MockRes.Reset Mocks
+```
+
+## Keywords
+
+### Mock Keyword
+
+Mock a keyword with a return value or side effect.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to mock
+- `return_value` - Value to return when called (optional)
+- `side_effect` - Callable to execute instead (optional)
+
+**Example:**
+```robot
+MockDB.Mock Keyword    query    return_value=test_data
+```
+
+### Reset Mocks
+
+Restore all mocked keywords to their original implementations.
+
+**Example:**
+```robot
+MockDB.Reset Mocks
+```
+
+### Verify Keyword Called
+
+Verify a keyword was called, optionally checking call count.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to verify
+- `times` - Expected number of calls (optional)
+
+**Example:**
+```robot
+MockDB.Verify Keyword Called    execute_sql    times=1
+```
+
+## How It Works
+
+### MockLibrary
+
+MockLibrary dynamically replaces keyword implementations:
+1. Wraps the target library instance
+2. Resolves keyword names to function names (handles @keyword decorator)
+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
+7. Raises AttributeError if attempting to mock a non-existent keyword
+
+### MockResource
+
+MockResource patches Robot Framework's keyword execution:
+1. Patches the Namespace.get_runner method
+2. Intercepts keyword execution for the specified resource file
+3. Replaces keyword body with Return statement containing mocked value
+4. Tracks call counts for verification
+5. Restores original keyword body on reset
+
+## Notes
+
+- Both libraries use `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
+- Built on Python's unittest.mock.Mock for robust mocking capabilities
+- MockLibrary supports any Robot Framework library, including BuiltIn
+- MockResource works with resource files by patching the keyword execution pipeline
+
+## License
+
+See LICENSE file for details.