Mocking in Testing

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.8.0</version>
    <scope>test</scope>
</dependency>
<!-- Optional but recommended: Mockito with JUnit 5 -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>5.8.0</version>
    <scope>test</scope>
</dependency>

// UserRepository.java - Talks to database (we'll mock this!)
public interface UserRepository {
    User findById(Long id);
    void save(User user);
    List<User> findAll();
}
// User.java - Simple data class
public class User {
    private Long id;
    private String name;
    private String email;
    // Constructor, getters, setters...
}
// UserService.java - The class we want to test
public class UserService {
    private UserRepository repository;
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    public User getUserById(Long id) {
        return repository.findById(id);
    }
    public boolean isEmailValid(User user) {
        return user.getEmail() != null && user.getEmail().contains("@");
    }
    public void createUser(User user) {
        if (!isEmailValid(user)) {
            throw new IllegalArgumentException("Invalid email!");
        }
        repository.save(user);
    }
}

@ExtendWith(MockitoExtension.class)
class UserServiceAdvancedTest {
    @Mock
    private UserRepository mockRepository;
    private UserService service;
    @BeforeEach
    void setUp() {
        service = new UserService(mockRepository);
    }
    @Test
    void testCreateUserWithValidEmail() {
        // Create a user with valid email
        User user = new User(1L, "Jane", "jane@example.com");
        // We don't need to stub anything because save() returns void
        // Test it!
        service.createUser(user);
        // Verify save was called with our user
        verify(mockRepository).save(user);
    }
    @Test
    void testCreateUserWithInvalidEmail_ThrowsException() {
        // Create a user with INVALID email (no @)
        User user = new User(1L, "Bob", "invalid-email");
        // This should throw an exception!
        assertThrows(IllegalArgumentException.class, () -> {
            service.createUser(user);
        });
        // Verify save was NEVER called (because email was invalid)
        verify(mockRepository, never()).save(any());
    }
    @Test
    void testGetUserById_WhenUserNotFound() {
        // Tell mock to return null (user not found)
        when(mockRepository.findById(999L)).thenReturn(null);
        User result = service.getUserById(999L);
        assertNull(result);
        verify(mockRepository).findById(999L);
    }
    @Test
    void testIsEmailValid() {
        // This method doesn't use repository at all!
        User validUser = new User(1L, "Test", "test@example.com");
        User invalidUser = new User(2L, "Test", "invalid");
        assertTrue(service.isEmailValid(validUser));
        assertFalse(service.isEmailValid(invalidUser));
        // Verify repository was NEVER called (no mocking needed!)
        verifyNoInteractions(mockRepository);
    }
}

import static org.mockito.ArgumentMatchers.*;
@Test
void testArgumentMatchers() {
    UserService service = new UserService(mockRepository);
    // Match ANY Long value
    when(mockRepository.findById(anyLong()))
        .thenReturn(new User(1L, "Any", "any@example.com"));
    // Now it doesn't matter what ID we pass!
    User user1 = service.getUserById(1L);
    User user2 = service.getUserById(999L);
    User user3 = service.getUserById(42L);
    // All return the same mock user!
    assertEquals("Any", user1.getName());
    assertEquals("Any", user2.getName());
    assertEquals("Any", user3.getName());
}
@Test
void testSaveAnyUser() {
    UserService service = new UserService(mockRepository);
    // We don't care WHICH user is saved, just that save is called
    User user = new User(1L, "Test", "test@example.com");
    service.createUser(user);
    // Verify save was called with ANY User object
    verify(mockRepository).save(any(User.class));
}
@Test
void testComplexMatching() {
    // Only match if email contains "@example.com"
    when(mockRepository.findById(anyLong()))
        .thenAnswer(invocation -> {
            Long id = invocation.getArgument(0);
            return new User(id, "User" + id, "user" + id + "@example.com");
        });
    User user = service.getUserById(5L);
    assertEquals("user5@example.com", user.getEmail());
}

// EmailSender.java - Interface for sending emails
public interface EmailSender {
    void sendEmail(String to, String subject, String body);
}
// NotificationService.java - Sends notifications
public class NotificationService {
    private EmailSender emailSender;
    private UserRepository userRepository;
    public NotificationService(EmailSender emailSender, UserRepository userRepository) {
        this.emailSender = emailSender;
        this.userRepository = userRepository;
    }
    public void notifyUser(Long userId, String message) {
        User user = userRepository.findById(userId);
        if (user == null) {
            throw new IllegalArgumentException("User not found!");
        }
        String subject = "Notification for " + user.getName();
        emailSender.sendEmail(user.getEmail(), subject, message);
    }
    public void notifyAllUsers(String message) {
        List<User> users = userRepository.findAll();
        for (User user : users) {
            emailSender.sendEmail(user.getEmail(), "Broadcast", message);
        }
    }
}
// NotificationServiceTest.java
@ExtendWith(MockitoExtension.class)
class NotificationServiceTest {
    @Mock
    private EmailSender mockEmailSender;
    @Mock
    private UserRepository mockRepository;
    private NotificationService service;
    @BeforeEach
    void setUp() {
        service = new NotificationService(mockEmailSender, mockRepository);
    }
    @Test
    void testNotifyUser_Success() {
        // Setup: User exists
        User user = new User(1L, "Alice", "alice@example.com");
        when(mockRepository.findById(1L)).thenReturn(user);
        // Test
        service.notifyUser(1L, "Hello Alice!");
        // Verify email was sent to correct address
        verify(mockEmailSender).sendEmail(
            eq("alice@example.com"),
            contains("Alice"),
            eq("Hello Alice!")
        );
    }
    @Test
    void testNotifyUser_UserNotFound() {
        // Setup: User doesn't exist
        when(mockRepository.findById(999L)).thenReturn(null);
        // Test: Should throw exception
        assertThrows(IllegalArgumentException.class, () -> {
            service.notifyUser(999L, "Hello!");
        });
        // Verify email was NEVER sent
        verify(mockEmailSender, never()).sendEmail(anyString(), anyString(), anyString());
    }
    @Test
    void testNotifyAllUsers() {
        // Setup: Three users in database
        List<User> users = Arrays.asList(
            new User(1L, "Alice", "alice@example.com"),
            new User(2L, "Bob", "bob@example.com"),
            new User(3L, "Carol", "carol@example.com")
        );
        when(mockRepository.findAll()).thenReturn(users);
        // Test
        service.notifyAllUsers("System maintenance tonight!");
        // Verify email sent to ALL users
        verify(mockEmailSender, times(3)).sendEmail(
            anyString(),
            eq("Broadcast"),
            eq("System maintenance tonight!")
        );
        // Verify specific emails
        verify(mockEmailSender).sendEmail("alice@example.com", "Broadcast", "System maintenance tonight!");
        verify(mockEmailSender).sendEmail("bob@example.com", "Broadcast", "System maintenance tonight!");
        verify(mockEmailSender).sendEmail("carol@example.com", "Broadcast", "System maintenance tonight!");
    }
}