robotframework-mock 0.4.0__tar.gz → 0.6.0__tar.gz

{robotframework_mock-0.4.0/src/robotframework_mock.egg-info → robotframework_mock-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.4.0
+Version: 0.6.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -61,6 +61,7 @@ pip install -r requirements-dev.txt
 - Mock Robot Framework's BuiltIn keywords
 - Support for keywords with custom names via @keyword decorator
 - Verify keyword calls and call counts
+- Inspect and verify the arguments a mocked keyword was called with
 - Measure resource-file keyword coverage with configurable thresholds
 - Simple API with three main keywords
 
@@ -319,6 +320,14 @@ 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}
+```
+
 ### Reset Mocks
 
 Restore all mocked keywords to their original implementations.
@@ -341,6 +350,67 @@ Verify a keyword was called, optionally checking call count.
 MockDB.Verify Keyword Called    execute_sql    times=1
 ```
 
+### Verify Keyword Called With
+
+Verify a keyword was called with the given arguments. Passes when **at least one**
+recorded call matches, so the order of calls does not matter.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to verify
+- `*args` - Expected positional arguments
+- `**kwargs` - Expected named arguments
+
+**Example:**
+```robot
+MockDB.Verify Keyword Called With    execute_sql    SELECT 1    timeout=${30}
+```
+
+Arguments are compared with Python equality, so types matter. Values are
+recorded exactly as Robot Framework passed them to the keyword: test data is
+string data, but Robot converts arguments of keywords that declare argument
+types, and which built-in keywords declare types differs between Robot
+Framework versions. When a recorded value is therefore not a string, give the
+expectation as a typed Robot variable (`timeout=${30}` rather than
+`timeout=30`), or read the call back with `Get Keyword Call Kwargs` and assert
+on it with a type-insensitive comparison.
+
+### Get Keyword Call Args
+
+Return the positional arguments of one call to a mocked keyword.
+
+**Arguments:**
+- `keyword_name` - Name of the mocked keyword
+- `index` - Zero-based call index, negative counts from the end (default `0`)
+
+**Example:**
+```robot
+${args}=    MockDB.Get Keyword Call Args    execute_sql    index=0
+Should Be Equal    ${args}[0]    SELECT 1
+```
+
+### Get Keyword Call Kwargs
+
+Return the named arguments of one call to a mocked keyword.
+
+**Arguments:**
+- `keyword_name` - Name of the mocked keyword
+- `index` - Zero-based call index, negative counts from the end (default `0`)
+
+**Example:**
+```robot
+${kwargs}=    MockDB.Get Keyword Call Kwargs    execute_sql
+Should Be Equal    ${kwargs}[timeout]    ${30}
+```
+
+### Get Keyword Call Count
+
+Return how many times a mocked keyword was called.
+
+**Example:**
+```robot
+${count}=    MockDB.Get Keyword Call Count    execute_sql
+```
+
 ## How It Works
 
 ### MockLibrary
@@ -359,9 +429,12 @@ MockLibrary dynamically replaces keyword implementations:
 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
+3. Resolves the call's arguments - variables are replaced, and a `name=value`
+   argument becomes a named argument when the keyword declares that name - so
+   mocks record what the keyword was really called with
+4. Replaces keyword body with Return statement containing mocked value
+5. Tracks call counts and call arguments for verification
+6. Restores original keyword body on reset
 
 ### MockCoverage
 

{robotframework_mock-0.4.0 → robotframework_mock-0.6.0}/README.md

@@ -37,6 +37,7 @@ pip install -r requirements-dev.txt
 - Mock Robot Framework's BuiltIn keywords
 - Support for keywords with custom names via @keyword decorator
 - Verify keyword calls and call counts
+- Inspect and verify the arguments a mocked keyword was called with
 - Measure resource-file keyword coverage with configurable thresholds
 - Simple API with three main keywords
 
@@ -295,6 +296,14 @@ 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}
+```
+
 ### Reset Mocks
 
 Restore all mocked keywords to their original implementations.
@@ -317,6 +326,67 @@ Verify a keyword was called, optionally checking call count.
 MockDB.Verify Keyword Called    execute_sql    times=1
 ```
 
+### Verify Keyword Called With
+
+Verify a keyword was called with the given arguments. Passes when **at least one**
+recorded call matches, so the order of calls does not matter.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to verify
+- `*args` - Expected positional arguments
+- `**kwargs` - Expected named arguments
+
+**Example:**
+```robot
+MockDB.Verify Keyword Called With    execute_sql    SELECT 1    timeout=${30}
+```
+
+Arguments are compared with Python equality, so types matter. Values are
+recorded exactly as Robot Framework passed them to the keyword: test data is
+string data, but Robot converts arguments of keywords that declare argument
+types, and which built-in keywords declare types differs between Robot
+Framework versions. When a recorded value is therefore not a string, give the
+expectation as a typed Robot variable (`timeout=${30}` rather than
+`timeout=30`), or read the call back with `Get Keyword Call Kwargs` and assert
+on it with a type-insensitive comparison.
+
+### Get Keyword Call Args
+
+Return the positional arguments of one call to a mocked keyword.
+
+**Arguments:**
+- `keyword_name` - Name of the mocked keyword
+- `index` - Zero-based call index, negative counts from the end (default `0`)
+
+**Example:**
+```robot
+${args}=    MockDB.Get Keyword Call Args    execute_sql    index=0
+Should Be Equal    ${args}[0]    SELECT 1
+```
+
+### Get Keyword Call Kwargs
+
+Return the named arguments of one call to a mocked keyword.
+
+**Arguments:**
+- `keyword_name` - Name of the mocked keyword
+- `index` - Zero-based call index, negative counts from the end (default `0`)
+
+**Example:**
+```robot
+${kwargs}=    MockDB.Get Keyword Call Kwargs    execute_sql
+Should Be Equal    ${kwargs}[timeout]    ${30}
+```
+
+### Get Keyword Call Count
+
+Return how many times a mocked keyword was called.
+
+**Example:**
+```robot
+${count}=    MockDB.Get Keyword Call Count    execute_sql
+```
+
 ## How It Works
 
 ### MockLibrary
@@ -335,9 +405,12 @@ MockLibrary dynamically replaces keyword implementations:
 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
+3. Resolves the call's arguments - variables are replaced, and a `name=value`
+   argument becomes a named argument when the keyword declares that name - so
+   mocks record what the keyword was really called with
+4. Replaces keyword body with Return statement containing mocked value
+5. Tracks call counts and call arguments for verification
+6. Restores original keyword body on reset
 
 ### MockCoverage
 

{robotframework_mock-0.4.0 → robotframework_mock-0.6.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = robotframework-mock
-version = 0.4.0
+version = 0.6.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.4.0 → robotframework_mock-0.6.0}/src/MockLibrary/__init__.py

@@ -8,6 +8,8 @@ from unittest.mock import Mock
 from robot.api.deco import keyword
 from robot.libraries.BuiltIn import BuiltIn
 
+from _mock_core import CallInspectionMixin
+
 
 def _get_library_instance(library_name_or_alias):
     """Retrieve a library instance from Robot Framework's runtime.
@@ -73,7 +75,7 @@ def _load_custom_resolver(resolver_path: str):
     )
 
 
-class MockLibrary():
+class MockLibrary(CallInspectionMixin):
     """Mock keywords from any Robot Framework library for unit testing.
     
     Example:
@@ -87,6 +89,20 @@ class MockLibrary():
 
     ROBOT_LIBRARY_SCOPE = 'GLOBAL'
 
+    def _mock_key(self, keyword_name: str) -> str:
+        """Return the ``self._mocks`` key for *keyword_name*.
+
+        Mocks are stored under the method name, so the keyword name is
+        normalised the same way :meth:`mock_keyword` normalises it.
+
+        Args:
+            keyword_name: Keyword name as written in the test.
+
+        Returns:
+            The method name used as the mock key.
+        """
+        return keyword_name.lower().replace(' ', '_')
+
     def __init__(self, library_name_or_alias: str, custom_resolver_path: str = None):
         """Initialize MockLibrary with a target library to mock.
         

{robotframework_mock-0.4.0 → robotframework_mock-0.6.0}/src/MockResource/__init__.py

@@ -7,9 +7,60 @@ from robot.api.deco import keyword
 from robot.libraries.BuiltIn import BuiltIn
 from robot.running import Return
 from robot.running.namespace import Namespace
+from robot.utils import split_from_equals
 
+from _mock_core import CallInspectionMixin
 
-class MockResource:
+# 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.
+
+    Robot hands the listener the argument list exactly as written at the call
+    site, so variables are still unresolved (``${query} commit;``) and named
+    arguments are plain ``name=value`` strings. Both are resolved here so that
+    mocks record what the keyword was *really* called with, matching what
+    ``MockLibrary`` records for library keywords.
+
+    A ``name=value`` item only becomes a named argument when ``name`` is an
+    argument the keyword actually declares; otherwise it stays positional, so a
+    value that merely contains ``=`` is not misread.
+
+    Args:
+        keyword_obj: The keyword being called, used for its argument spec.
+        data: Robot keyword call data holding the raw arguments.
+        context: Robot execution context, used to resolve variables.
+
+    Returns:
+        A ``(args, kwargs)`` tuple of resolved arguments.
+    """
+    spec = getattr(keyword_obj, 'args', None)
+    accepted = set()
+    if spec is not None:
+        accepted.update(spec.positional or ())
+        accepted.update(spec.named_only or ())
+
+    args = []
+    kwargs = {}
+    for argument in context.variables.replace_list(data.args):
+        name, value = (
+            split_from_equals(argument) if isinstance(argument, str)
+            else (None, None)
+        )
+        if value is not None and name in accepted:
+            kwargs[name] = value
+        else:
+            args.append(argument)
+    return args, kwargs
+
+
+class MockResource(CallInspectionMixin):
     """Mock keywords from Robot Framework resource files for unit testing.
     
     Example:
@@ -42,8 +93,15 @@ class MockResource:
             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
+                    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
 
@@ -61,8 +119,13 @@ class MockResource:
         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
-        
+            side_effect: Callable to execute instead of returning a value.
+                Receives the call's resolved arguments, the same way a
+                ``MockLibrary`` side effect does.
+
+        Returns:
+            The :class:`unittest.mock.Mock` backing the keyword.
+
         Example:
             | MockRes.Mock Keyword | My Keyword | return_value=test_data |
         """
@@ -75,6 +138,7 @@ class MockResource:
         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
+        return mock
 
     @keyword
     def reset_mocks(self):

robotframework_mock-0.6.0/src/_mock_core/__init__.py

@@ -0,0 +1,180 @@
+"""Shared internals for the mock libraries.
+
+Private package - not part of the public API, and not meant to be imported by
+tests. ``MockLibrary`` and ``MockResource`` both keep their mocked keywords in a
+``self._mocks`` mapping of :class:`unittest.mock.Mock` objects, which already
+record every call. The keywords that expose those recorded calls are therefore
+implemented once here and mixed into both libraries, so the two cannot drift
+apart.
+"""
+# pylint: disable=invalid-name
+from typing import Any, Dict, List
+from unittest.mock import call
+
+from robot.api.deco import keyword
+
+
+class CallInspectionMixin:
+    """Keywords for inspecting how a mocked keyword was called.
+
+    The host library must provide:
+
+    - ``self._mocks``: mapping of mock key -> :class:`unittest.mock.Mock`
+    - ``self._mock_key(keyword_name)``: the ``self._mocks`` key for a keyword
+      name, in case the library does not key by the name as written
+    """
+
+    _mocks: Dict[str, Any]
+
+    def _mock_key(self, keyword_name: str) -> str:
+        """Return the ``self._mocks`` key for *keyword_name*.
+
+        Args:
+            keyword_name: Keyword name as written in the test.
+
+        Returns:
+            The key under which the mock is stored. Libraries that normalise
+            keyword names override this.
+        """
+        return keyword_name
+
+    def _get_mock(self, keyword_name: str):
+        """Return the mock for *keyword_name*.
+
+        Args:
+            keyword_name: Name of the mocked keyword.
+
+        Returns:
+            The :class:`unittest.mock.Mock` backing that keyword.
+
+        Raises:
+            AssertionError: If the keyword was not mocked.
+        """
+        key = self._mock_key(keyword_name)
+        if key not in self._mocks:
+            raise AssertionError(f"Keyword '{keyword_name}' was not mocked")
+        return self._mocks[key]
+
+    def _get_call(self, keyword_name: str, index):
+        """Return a single recorded call.
+
+        Args:
+            keyword_name: Name of the mocked keyword.
+            index: Zero-based call index. Negative values count from the end,
+                so ``-1`` is the most recent call.
+
+        Returns:
+            The :class:`unittest.mock.call` recorded at that index.
+
+        Raises:
+            AssertionError: If the keyword was not mocked, or fewer calls were
+                recorded than *index* requires.
+        """
+        calls = self._get_mock(keyword_name).call_args_list
+        index = int(index)
+        if not -len(calls) <= index < len(calls):
+            raise AssertionError(
+                f"No call recorded at index {index} for keyword "
+                f"'{keyword_name}', it was called {len(calls)} time(s)"
+            )
+        return calls[index]
+
+    @keyword
+    def get_keyword_call_count(self, keyword_name: str) -> int:
+        """Return how many times a mocked keyword was called.
+
+        Args:
+            keyword_name: Name of the mocked keyword.
+
+        Returns:
+            The number of recorded calls.
+
+        Raises:
+            AssertionError: If the keyword was not mocked.
+
+        Example:
+            | ${count}= | MockDB.Get Keyword Call Count | Execute Sql |
+        """
+        return self._get_mock(keyword_name).call_count
+
+    @keyword
+    def get_keyword_call_args(self, keyword_name: str, index=0) -> List[Any]:
+        """Return the positional arguments of one call to a mocked keyword.
+
+        Args:
+            keyword_name: Name of the mocked keyword.
+            index: Zero-based call index, negative counts from the end.
+
+        Returns:
+            The positional arguments of that call.
+
+        Raises:
+            AssertionError: If the keyword was not mocked or the call does not
+                exist.
+
+        Example:
+            | ${args}= | MockDB.Get Keyword Call Args | Execute Sql | index=0 |
+            | Should Be Equal | ${args}[0] | SELECT 1 |
+        """
+        return list(self._get_call(keyword_name, index).args)
+
+    @keyword
+    def get_keyword_call_kwargs(self, keyword_name: str, index=0) -> Dict[str, Any]:
+        """Return the named arguments of one call to a mocked keyword.
+
+        Args:
+            keyword_name: Name of the mocked keyword.
+            index: Zero-based call index, negative counts from the end.
+
+        Returns:
+            The named arguments of that call.
+
+        Raises:
+            AssertionError: If the keyword was not mocked or the call does not
+                exist.
+
+        Example:
+            | ${kwargs}= | MockDB.Get Keyword Call Kwargs | Execute Sql |
+            | Should Be Equal | ${kwargs}[timeout] | 30 |
+        """
+        return dict(self._get_call(keyword_name, index).kwargs)
+
+    @keyword
+    def verify_keyword_called_with(self, keyword_name: str, *args, **kwargs):
+        """Verify a mocked keyword was called with the given arguments.
+
+        Passes when **at least one** recorded call matches exactly, which keeps
+        the check usable when the order of calls is not significant. Use
+        :meth:`get_keyword_call_args` to assert on a specific call instead.
+
+        Arguments are compared with Python equality, so types matter. Values
+        are recorded exactly as Robot Framework passed them to the keyword, and
+        Robot converts arguments of keywords that declare argument types. Which
+        built-in keywords declare types differs between Robot Framework
+        versions, so a non-string expectation must be given as a typed Robot
+        variable (``timeout=${30}`` rather than ``timeout=30``).
+
+        Args:
+            keyword_name: Name of the mocked keyword.
+            *args: Expected positional arguments.
+            **kwargs: Expected named arguments.
+
+        Raises:
+            AssertionError: If the keyword was not mocked, or no recorded call
+                matches.
+
+        Example:
+            | MockDB.Verify Keyword Called With | Execute Sql | SELECT 1 |
+        """
+        mock = self._get_mock(keyword_name)
+        expected = call(*args, **kwargs)
+        if expected not in mock.call_args_list:
+            actual = (
+                '\n'.join(f'  {index}: {item}'
+                          for index, item in enumerate(mock.call_args_list))
+                or '  (never called)'
+            )
+            raise AssertionError(
+                f"Keyword '{keyword_name}' was not called with {expected}.\n"
+                f"Recorded calls:\n{actual}"
+            )

{robotframework_mock-0.4.0 → robotframework_mock-0.6.0/src/robotframework_mock.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-mock
-Version: 0.4.0
+Version: 0.6.0
 Summary: A Robot Framework library for mocking keywords in unit tests
 Home-page: https://github.com/olesz/robotframework-mock
 Author: Lajos Olah
@@ -61,6 +61,7 @@ pip install -r requirements-dev.txt
 - Mock Robot Framework's BuiltIn keywords
 - Support for keywords with custom names via @keyword decorator
 - Verify keyword calls and call counts
+- Inspect and verify the arguments a mocked keyword was called with
 - Measure resource-file keyword coverage with configurable thresholds
 - Simple API with three main keywords
 
@@ -319,6 +320,14 @@ 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}
+```
+
 ### Reset Mocks
 
 Restore all mocked keywords to their original implementations.
@@ -341,6 +350,67 @@ Verify a keyword was called, optionally checking call count.
 MockDB.Verify Keyword Called    execute_sql    times=1
 ```
 
+### Verify Keyword Called With
+
+Verify a keyword was called with the given arguments. Passes when **at least one**
+recorded call matches, so the order of calls does not matter.
+
+**Arguments:**
+- `keyword_name` - Name of the keyword to verify
+- `*args` - Expected positional arguments
+- `**kwargs` - Expected named arguments
+
+**Example:**
+```robot
+MockDB.Verify Keyword Called With    execute_sql    SELECT 1    timeout=${30}
+```
+
+Arguments are compared with Python equality, so types matter. Values are
+recorded exactly as Robot Framework passed them to the keyword: test data is
+string data, but Robot converts arguments of keywords that declare argument
+types, and which built-in keywords declare types differs between Robot
+Framework versions. When a recorded value is therefore not a string, give the
+expectation as a typed Robot variable (`timeout=${30}` rather than
+`timeout=30`), or read the call back with `Get Keyword Call Kwargs` and assert
+on it with a type-insensitive comparison.
+
+### Get Keyword Call Args
+
+Return the positional arguments of one call to a mocked keyword.
+
+**Arguments:**
+- `keyword_name` - Name of the mocked keyword
+- `index` - Zero-based call index, negative counts from the end (default `0`)
+
+**Example:**
+```robot
+${args}=    MockDB.Get Keyword Call Args    execute_sql    index=0
+Should Be Equal    ${args}[0]    SELECT 1
+```
+
+### Get Keyword Call Kwargs
+
+Return the named arguments of one call to a mocked keyword.
+
+**Arguments:**
+- `keyword_name` - Name of the mocked keyword
+- `index` - Zero-based call index, negative counts from the end (default `0`)
+
+**Example:**
+```robot
+${kwargs}=    MockDB.Get Keyword Call Kwargs    execute_sql
+Should Be Equal    ${kwargs}[timeout]    ${30}
+```
+
+### Get Keyword Call Count
+
+Return how many times a mocked keyword was called.
+
+**Example:**
+```robot
+${count}=    MockDB.Get Keyword Call Count    execute_sql
+```
+
 ## How It Works
 
 ### MockLibrary
@@ -359,9 +429,12 @@ MockLibrary dynamically replaces keyword implementations:
 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
+3. Resolves the call's arguments - variables are replaced, and a `name=value`
+   argument becomes a named argument when the keyword declares that name - so
+   mocks record what the keyword was really called with
+4. Replaces keyword body with Return statement containing mocked value
+5. Tracks call counts and call arguments for verification
+6. Restores original keyword body on reset
 
 ### MockCoverage
 

{robotframework_mock-0.4.0 → robotframework_mock-0.6.0}/src/robotframework_mock.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ setup.py
 src/MockCoverage/__init__.py
 src/MockLibrary/__init__.py
 src/MockResource/__init__.py
+src/_mock_core/__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.4.0 → robotframework_mock-0.6.0}/src/robotframework_mock.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 MockCoverage
 MockLibrary
 MockResource
+_mock_core