Resetting Mocks Between Tests

Direct Answer

Mockito.reset(mock) removes both stubbings and recorded interactions, returning the mock close to a newly created state. clearInvocations(mock) removes only recorded calls and keeps stubbings. Most tests should get fresh mocks for each test method instead of resetting shared state. Reset can be reasonable when a container supplies the same injected mock to several phases that cannot be rebuilt cheaply, but it should be local and intentional.

Code Example

// ANTI-PATTERN: Shared mock with manual reset
class BadOrderServiceTest {
    private static PaymentGateway sharedGateway = mock(PaymentGateway.class);  // shared!

    @AfterEach
    void cleanup() {
        Mockito.reset(sharedGateway);  // trying to clean up between tests
    }

    @Test
    void testOne() { /* uses sharedGateway */ }

    @Test
    void testTwo() { /* reuses same mock, tests coupled */ }
}

// CORRECT: Per-test mock creation
@ExtendWith(MockitoExtension.class)
class GoodOrderServiceTest {
    @Mock  // Fresh mock for each test automatically
    private PaymentGateway paymentGateway;

    @InjectMocks
    private OrderService orderService;

    @Test
    void testOne() { /* uses fresh mock */ }

    @Test
    void testTwo() { /* different fresh mock, fully isolated */ }
}

Common Mistakes & Pitfalls

• Shared mutable mocks: class-level or static mocks can make tests order-dependent.
• Resetting in every cleanup method: a fresh per-test mock is usually simpler.
• Confusing the two operations: reset removes stubs and calls; clearInvocations removes calls only.
• Resetting too early: later verification cannot see erased interactions.
• Using reset to hide a long scenario: separate tests often express phases more clearly.