jest.spyOn() is used to: 1) Monitor method calls on objects, 2) Preserve original implementation while tracking calls, 3) Temporarily mock method behavior, 4) Restore original implementation using mockRestore(), 5) Access call history and mock functionality. Example: jest.spyOn(object, 'method')
Key differences: 1) jest.fn() creates new mock functions while spyOn monitors existing ones, 2) spyOn can restore original implementation, jest.fn() cannot, 3) spyOn requires an object and method, jest.fn() is standalone, 4) spyOn preserves original method by default, 5) jest.fn() starts as empty function.
ES6 class mocking: 1) Use jest.mock() for class, 2) Mock constructor and methods, 3) Implement instance methods with mockImplementation, 4) Mock static methods directly, 5) Handle inheritance if needed. Example: jest.mock('./MyClass', () => { return jest.fn().mockImplementation(() => { return {method: jest.fn()}; }); });
jest.fn() creates a mock function that allows: 1) Tracking calls and arguments, 2) Setting return values using mockReturnValue(), 3) Implementing custom behavior using mockImplementation(), 4) Clearing/resetting mock data, 5) Verifying call conditions. Example: const mock = jest.fn().mockReturnValue('result');
Async mocking involves: 1) mockResolvedValue() for successful promises, 2) mockRejectedValue() for failed promises, 3) mockImplementation() with async functions, 4) Chain .then handlers for complex cases, 5) Await mock function calls in tests. Example: mock.mockResolvedValue('result');
Manual mocks: 1) Created in __mocks__ directory, 2) Match module name and structure, 3) Exported as module.exports, 4) Can include complex implementations, 5) Automatically used when module is required. Used for consistent mock implementations across tests.
Module mocking uses: 1) jest.mock() for automatic mocking, 2) Manual mocks in __mocks__ directory, 3) mockImplementation() for custom behavior, 4) requireActual() for partial mocking, 5) hoisting of jest.mock() calls. Example: jest.mock('./module', () => ({ method: jest.fn() }));
Mock calls verified using: 1) toHaveBeenCalled() for call checking, 2) toHaveBeenCalledWith() for argument checking, 3) toHaveBeenCalledTimes() for call count, 4) mock.calls array for detailed inspection, 5) mock.results for return values. Example: expect(mock).toHaveBeenCalledWith(arg);
mockClear(): 1) Resets call history of mock function, 2) Used between tests to ensure isolation, 3) Doesn't reset implementation or return values, 4) Often used in beforeEach, 5) Helps prevent test interdependence. Example: beforeEach(() => { mock.mockClear(); });
Partial mocking involves: 1) Using jest.mock() with partial implementations, 2) requireActual() for original methods, 3) Mixing real and mocked exports, 4) Careful management of module state, 5) Clear documentation of mixed implementation. Example: jest.mock('./module', () => ({ ...jest.requireActual('./module'), specificMethod: jest.fn() }));
Mock contexts provide: 1) Custom this binding, 2) Shared state between calls, 3) Instance method simulation, 4) Constructor behavior, 5) Method chaining support. Used for complex object mocking scenarios.
Stateful mocks require: 1) Internal state management, 2) State-dependent behavior, 3) State reset mechanisms, 4) State verification, 5) Thread-safe state handling. Used for complex behavioral simulation.
Mock return values can be set using: 1) mockReturnValue() for fixed values, 2) mockReturnValueOnce() for single calls, 3) mockImplementation() for custom logic, 4) mockResolvedValue() for promises, 5) mockRejectedValue() for promise rejections. Example: mock.mockReturnValue('result');
Mock implementations: 1) Set using mockImplementation(), 2) Define custom behavior, 3) Can access call arguments, 4) Support async operations, 5) Can be changed between tests. Example: mock.mockImplementation((arg) => arg * 2);
HTTP request mocking: 1) Mock fetch/axios globally, 2) Use jest.mock() for HTTP clients, 3) Implement custom response handling, 4) Mock different response scenarios, 5) Handle async behavior properly. Consider using libraries like jest-fetch-mock.
Native object mocking: 1) Use jest.spyOn on prototype, 2) Mock specific methods, 3) Restore original behavior, 4) Handle inheritance chain, 5) Consider side effects. Example: jest.spyOn(console, 'log').mockImplementation();
Mock cleanup involves: 1) Using mockReset(), 2) mockRestore() for spies, 3) Cleanup in afterEach, 4) Handling partial restorations, 5) Managing global mocks. Ensures test isolation and prevents side effects.
