🧪
Testing

Unit Testing with Mockito

@Mock, @InjectMocks
💡 Mockito ek STUNT DOUBLE hai FILM SHOOTING mein — REAL actor (actual dependency, jaise database) ko RISKY/SLOW scene mein use karने ke bajaye, ek STUNT DOUBLE (mock object) use karte ho jo EXACTLY WAISE hi BEHAVE karta hai jaisा tum bolo, bina ACTUAL risk/cost ke.

Unit testing mein, ek CLASS ko ISOLATION mein test karna hota hai — uski DEPENDENCIES (database, external APIs) REAL nahi honi chahiye (SLOW, UNRELIABLE, setup-heavy). Mockito is problem ko SOLVE karta hai — @Mock se FAKE dependency object banता hai, when().thenReturn() se uska BEHAVIOR define hota hai.

@InjectMocks TARGET class (jo test ho rahi hai) banaता hai, aur SAARI @Mock-annotated dependencies AUTOMATICALLY us mein INJECT kar deta hai. Isse REAL Spring container START karne ki zaroorat NAHI — test EXTREMELY FAST run hote hain.

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock
    private PaymentGateway paymentGateway;
    @Mock
    private OrderRepository orderRepository;

    @InjectMocks
    private OrderService orderService;

    @Test
    void shouldPlaceOrderSuccessfully() {
        when(paymentGateway.charge(any())).thenReturn(true);
        when(orderRepository.save(any())).thenReturn(new Order());

        Order result = orderService.placeOrder(new OrderDto(...));

        assertNotNull(result);
        verify(paymentGateway, times(1)).charge(any());
    }
}
🧪
Mockito ek STUNT DOUBLE hai FILM SHOOTING mein — REAL actor (actual dependency, jaise database) ko RISKY/SLOW scene mein use karने ke bajaye, ek STUNT DOUBLE (mock object) use karte ho jo EXACTLY WAISE hi BEHAVE karta hai jaisा tum bolo, bina ACTUAL risk/cost ke.
1 / 6
⚡ Quick Recap
  • @Mock = fake, predictable dependency object
  • @InjectMocks = target class + saari mocked dependencies inject
  • REAL Spring container START NAHI hota — tests EXTREMELY fast
Is page mein (2 subtopics)

Mockito ek MOCKING FRAMEWORK hai — REAL dependencies (jaise database-hitting repository) ki jagah, FAKE, PREDICTABLE "mock" objects use kiye jaate hain. @Mock ek mock object banata hai, @InjectMocks us mock ko TARGET class mein INJECT karta hai, when().thenReturn() mock ka BEHAVIOR define karta hai.

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock
    private OrderRepository repository;

    @InjectMocks
    private OrderService service;

    @Test
    void shouldFindOrder() {
        when(repository.findById(1L)).thenReturn(Optional.of(new Order()));
        Order result = service.getOrder(1L);
        assertNotNull(result);
    }
}

verify() CHECK karta hai ki MOCK object ke KISI method ko, KITNI baar, KIN parameters ke saath CALL kiya gaya — sirf RETURN VALUE nahi, BEHAVIOR (interactions) bhi test kiya ja sakta hai.

@Test
void shouldCallPaymentGatewayOnce() {
    service.placeOrder(orderDto);
    verify(paymentGateway, times(1)).charge(orderDto.getAmount());
    verify(inventoryService, never()).restock(any());
}