Mocking Test Generator

Generate unit tests with proper mocking of external dependencies for Python and Java code.

Workflow

1. Analyze the code - Identify external dependencies, side effects, and testable units
2. Select framework - Determine Python (unittest.mock/pytest) or Java (Mockito/JUnit)
3. Generate mocks - Create mock objects for external dependencies
4. Write tests - Generate executable test code with assertions
5. Add documentation - Include clear comments explaining mocks and test logic

Step 1: Analyze the Code

Read the target code to identify:

• External dependencies: API clients, database connections, third-party libraries
• I/O operations: File reads/writes, network requests, system calls
• Side effects: Email sending, logging, state modifications
• Testable units: Functions, methods, or classes to test in isolation

Ask clarifying questions if:

• Multiple functions/classes exist (which to test?)
• Testing scope is unclear (unit vs integration?)
• Mock behavior needs specification (return values, exceptions?)

Step 2: Select Framework

Python: Use

unittest.mock

with

pytest

or

unittest

• Prefer

  @patch

  decorator for external calls
• Use

  Mock()

  objects for complex dependencies
• Apply

  pytest.fixture

  for reusable mocks

Java: Use Mockito with JUnit 5

• Use

  @Mock

  annotation for dependencies
• Apply

  @ExtendWith(MockitoExtension.class)

  to test class
• Use

  when().thenReturn()

  for stubbing

Step 3: Generate Mocks

Identify what to mock:

Always mock:

• External API calls (HTTP requests, REST clients)
• Database connections and queries
• File system operations
• Network I/O
• Time/date functions
• Random number generators
• Environment variables

Never mock (unless explicitly requested):

• Internal business logic
• Pure functions
• Data structures
• Simple utilities

For common patterns, reference:

• Python: See references/python_patterns.md
• Java: See references/java_patterns.md

Step 4: Write Tests

Generate test code that:

1. Imports - Include necessary testing and mocking libraries
2. Setup - Initialize mocks and test fixtures
3. Execution - Call the function/method under test
4. Assertions - Verify expected behavior and outputs
5. Verification - Confirm mocks were called correctly

Test structure:

# Python example
from unittest.mock import patch, Mock
import pytest

@patch('module.external_dependency')
def test_function_name(mock_dependency):
    # Arrange: Setup mock behavior
    mock_dependency.return_value = expected_value

    # Act: Execute function under test
    result = function_under_test(input_data)

    # Assert: Verify results
    assert result == expected_output
    mock_dependency.assert_called_once_with(expected_args)

// Java example
@ExtendWith(MockitoExtension.class)
class ServiceTest {
    @Mock
    private ExternalDependency dependency;

    @Test
    void testMethodName() {
        // Arrange: Setup mock behavior
        when(dependency.method()).thenReturn(expectedValue);

        // Act: Execute method under test
        Service service = new Service(dependency);
        String result = service.methodUnderTest();

        // Assert: Verify results
        assertEquals(expectedOutput, result);
        verify(dependency).method();
    }
}

Include:

• Multiple test cases for different scenarios (happy path, edge cases, errors)
• Descriptive test names that explain what is being tested
• Setup/teardown if needed for test isolation

Step 5: Add Documentation

Include comments that explain:

• What external dependency is being mocked and why
• What behavior the mock simulates
• What the test verifies

Keep comments concise and focused on non-obvious aspects.

Output Format

Provide:

1. Complete test file - Fully executable with all imports
2. Test class/module - Properly structured for the framework
3. Multiple test methods - Cover main scenarios
4. Clear naming - Descriptive test and variable names

Do not:

• Modify the original code under test
• Mock internal logic unless explicitly requested
• Generate incomplete or pseudo-code tests

Example Usage

User request: "Generate unit tests for this Python function that calls an external API"

Response:

1. Read the function code
2. Identify the API call to mock
3. Generate pytest test file with

   @patch

   decorator
4. Include tests for success case, error handling, and edge cases
5. Add comments explaining the mock setup

Framework-Specific Notes

Python (pytest):

• Use

  @pytest.fixture

  for reusable mock setups
• Apply

  @patch

  as decorator or context manager
• Use

  mock_open

  for file operations
• Apply

  @patch.dict

  for environment variables

Python (unittest):

• Use

  unittest.TestCase

  base class
• Apply

  @patch

  decorator or

  patch()

  context manager
• Use

  setUp()

  and

  tearDown()

  methods
• Call

  self.assert*

  methods

Java (Mockito + JUnit 5):

• Use

  @ExtendWith(MockitoExtension.class)

  on test class
• Apply

  @Mock

  for dependencies
• Use

  @BeforeEach

  for setup,

  @AfterEach

  for teardown
• Apply

  ArgumentCaptor

  to verify complex arguments
• Use

  MockedStatic

  for static method mocking (Mockito 3.4+)

Common Patterns

Reference files contain detailed examples for:

Python (references/python_patterns.md):

• External API calls
• Database operations
• File system operations
• Environment variables
• Time-dependent code
• Exception handling

Java (references/java_patterns.md):

• External API calls
• Database operations
• File system operations
• Void methods
• Exception handling
• Argument captors
• Static method mocking
• Constructor mocking