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

{robotframework_mock-0.1.0 → robotframework_mock-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.1.0
+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
@@ -46,6 +46,7 @@ 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
@@ -119,6 +120,23 @@ Test Multiple 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
@@ -159,6 +177,8 @@ 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)
@@ -168,11 +188,21 @@ MockLibrary dynamically replaces keyword implementations:
 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
 
-- The library uses `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
+- Both libraries use `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
 - Built on Python's unittest.mock.Mock for robust mocking capabilities
-- Supports any Robot Framework library, including BuiltIn
+- MockLibrary supports any Robot Framework library, including BuiltIn
+- MockResource works with resource files by patching the keyword execution pipeline
 
 ## License
 

robotframework_mock-0.1.0/src/robotframework_mock.egg-info/PKG-INFO → robotframework_mock-0.2.0/README.md

@@ -1,179 +1,191 @@
-Metadata-Version: 2.4
-Name: robotframework-mock
-Version: 0.1.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 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
-```
-
-## 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 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
-
-## Notes
-
-- The library uses `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
-- Built on Python's unittest.mock.Mock for robust mocking capabilities
-- Supports any Robot Framework library, including BuiltIn
-
-## License
-
-See LICENSE file for details.
+# 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.1.0 → robotframework_mock-0.2.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = robotframework-mock
-version = 0.1.0
+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

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

@@ -6,10 +6,19 @@ from unittest.mock import Mock
 from robot.api.deco import keyword
 from robot.libraries.BuiltIn import BuiltIn
 
-__version__ = "1.0.0"
-
 
 def _get_library_instance(library_name_or_alias):
+    """Retrieve a library instance from Robot Framework's runtime.
+    
+    Args:
+        library_name_or_alias: Name or alias of the library to retrieve
+        
+    Returns:
+        The library instance object
+        
+    Raises:
+        RuntimeError: If the library is not found in Robot Framework
+    """
     lib = BuiltIn().get_library_instance(library_name_or_alias)
     if not lib:
         raise RuntimeError(
@@ -34,8 +43,17 @@ class MockLibrary():
     ROBOT_LIBRARY_SCOPE = 'GLOBAL'
 
     def __init__(self, library_name_or_alias: str, lib: Any = 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)
+        """
+        # 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:
@@ -48,17 +66,26 @@ class MockLibrary():
     ):
         """Mock a keyword from the wrapped library.
         
+        Args:
+            keyword_name: Name of the keyword to mock (case-insensitive)
+            return_value: Value to return when the keyword is called
+            side_effect: Callable to execute instead of returning a value
+        
         Example:
             | MockDB.Mock Keyword | query | return_value=test_data |
         """
         lib = self._library_instance
+        # Convert keyword name to method name format (lowercase with underscores)
         method_name = keyword_name.lower().replace(' ', '_')
 
+        # 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
                 ):
@@ -67,36 +94,47 @@ class MockLibrary():
                         original_method = getattr(lib, name)
                         method_name = name
                         break
+            # Raise error if keyword doesn't exist
             if not original_method:
                 raise AttributeError(f"Keyword '{keyword_name}' not found in {lib}")
             self._original_methods[method_name] = original_method
 
+        # Create Mock object with specified behavior
         mock = Mock(return_value=return_value, side_effect=side_effect)
         self._mocks[method_name] = mock
 
+        # Replace the method on the class or instance
         try:
+            # Try to set on the class for bound methods
             owner_class = self._original_methods[method_name].__self__.__class__
             setattr(owner_class, method_name, mock)
         except AttributeError:
+            # Fall back to setting on the instance
             setattr(lib, method_name, mock)
 
-
         return mock
 
     @keyword
     def reset_mocks(self):
         """Reset all mocks to their original implementations.
         
+        Restores all mocked keywords to their original behavior and clears
+        all tracking data.
+        
         Example:
             | MockDB.Reset Mocks |
         """
+        # Restore each mocked method to its original implementation
         for method_name, original_method in self._original_methods.items():
             try:
+                # Restore on the class for bound methods
                 owner_class = original_method.__self__.__class__
                 setattr(owner_class, method_name, original_method)
             except AttributeError:
+                # Restore on the instance
                 setattr(self._library_instance, method_name, original_method)
 
+        # Clear all tracking dictionaries
         self._mocks.clear()
         self._original_methods.clear()
 
@@ -104,13 +142,23 @@ class MockLibrary():
     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, if None just checks it was called)
+        
+        Raises:
+            AssertionError: If keyword was not mocked or call count doesn't match
+        
         Example:
             | MockDB.Verify Keyword Called | execute_sql | times=1 |
         """
+        # Convert keyword name to method name format
         method_name = keyword_name.lower().replace(' ', '_')
+        # Check if the keyword was mocked
         if method_name not in self._mocks:
             raise AssertionError(f"Keyword '{keyword_name}' was not mocked")
 
+        # Verify call count if specified
         mock = self._mocks[method_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/src/MockResource/__init__.py

@@ -0,0 +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}")

robotframework_mock-0.1.0/README.md → robotframework_mock-0.2.0/src/robotframework_mock.egg-info/PKG-INFO

@@ -1,161 +1,209 @@
-# 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 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
-```
-
-## 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 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
-
-## Notes
-
-- The library uses `ROBOT_LIBRARY_SCOPE = 'GLOBAL'` to maintain state across test cases
-- Built on Python's unittest.mock.Mock for robust mocking capabilities
-- Supports any Robot Framework library, including BuiltIn
-
-## License
-
-See LICENSE file for details.
+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.

{robotframework_mock-0.1.0 → robotframework_mock-0.2.0}/src/robotframework_mock.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 setup.cfg
 setup.py
 src/MockLibrary/__init__.py
+src/MockResource/__init__.py
 src/robotframework_mock.egg-info/PKG-INFO
 src/robotframework_mock.egg-info/SOURCES.txt
 src/robotframework_mock.egg-info/dependency_links.txt

robotframework_mock-0.2.0/src/robotframework_mock.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+MockLibrary
+MockResource

robotframework_mock-0.1.0/src/robotframework_mock.egg-info/top_level.txt

@@ -1 +0,0 @@
-MockLibrary