การฉีดม็อกด้วย @Mock และ @InjectMocks

Creating mocks manually with mock(Type.class) works, but for classes with several dependencies it becomes repetitive. Mockito offers annotations that declare and wire mocks for you.

• @Mock declares a mock field
• @InjectMocks builds the real object and injects the mocks

Imagine an OrderService that depends on a PaymentGateway. We want to test the service while controlling the gateway.

Annotate a field with @Mock and Mockito creates a mock instance for it automatically once the annotations are processed.

@InjectMocks tells Mockito to instantiate the target and inject any @Mock fields into it, via constructor, setter, or field injection.

Annotations do nothing on their own. With JUnit 5 you enable them using @ExtendWith(MockitoExtension.class) on the test class.

Without the extension you can call MockitoAnnotations.openMocks(this) in a @BeforeEach method. Prefer the extension when you can.

Now stub the injected mock and exercise the service. The service already holds the mocked gateway, so no manual wiring is needed.

Mockito tries injection in this order:

• Constructor injection (preferred)
• Setter injection
• Field injection

Constructor injection is the safest because it works with final fields.

A class with several collaborators just gets several @Mock fields. Mockito matches each by type during injection.

If a dependency cannot be matched, the field stays null rather than throwing. A NullPointerException at test time often means injection did not happen as expected. Verify types and constructor signatures.

Annotations remove repetitive mock(...) and new Service(...) calls, keeping each test focused on behavior instead of wiring.

You learned to wire mocks declaratively:

• @Mock declares a mock field
• @InjectMocks builds the target and injects mocks
• Enable with @ExtendWith(MockitoExtension.class)
• Constructor injection is preferred and supports final fields