Criação de testes para envio de e-mail

src/main/java/br/com/springnoobs/reminderapi/mail/service/EmailService.java

@@ -50,12 +50,11 @@ public void send(Reminder reminder) {
         sendEmailWithFailureHandling(reminder, mimeMessage, variables);
     }
 
-    private void dispatchEmail(MimeMessage mimeMessage) throws EmailSendException {
+    void dispatchEmail(MimeMessage mimeMessage) throws EmailSendException {
         mailEngine.sendEmail(mimeMessage);
     }
 
-    private void sendEmailWithFailureHandling(
-            Reminder reminder, MimeMessage mimeMessage, Map<String, String> variables) {
+    void sendEmailWithFailureHandling(Reminder reminder, MimeMessage mimeMessage, Map<String, String> variables) {
         try {
             dispatchEmail(mimeMessage);
         } catch (EmailSendException e) {
@@ -65,7 +64,7 @@ private void sendEmailWithFailureHandling(
         }
     }
 
-    private void registerEmailFailure(Map<String, String> variables, String errorMessage) {
+    void registerEmailFailure(Map<String, String> variables, String errorMessage) {
         EmailSendFailure emailSendFailure = new EmailSendFailure();
 
         emailSendFailure.setName(variables.get("name"));

src/test/java/br/com/springnoobs/reminderapi/mail/service/EmailServiceTest.java

@@ -1,23 +1,43 @@
 package br.com.springnoobs.reminderapi.mail.service;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import br.com.springnoobs.reminderapi.mail.engine.MailEngine;
+import br.com.springnoobs.reminderapi.mail.entity.EmailSendFailure;
+import br.com.springnoobs.reminderapi.mail.exception.EmailSendException;
+import br.com.springnoobs.reminderapi.mail.repository.EmailSendFailureRepository;
 import br.com.springnoobs.reminderapi.reminder.entity.Reminder;
 import br.com.springnoobs.reminderapi.user.entity.Contact;
 import br.com.springnoobs.reminderapi.user.entity.User;
+import jakarta.mail.internet.MimeMessage;
 import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
+import org.springframework.mail.javamail.JavaMailSender;
 
 class EmailServiceTest {
 
     @Mock
     private MailEngine mailEngine;
 
+    @Mock
+    private JavaMailSender mailSender;
+
+    @Mock
+    private EmailSendFailureRepository emailSendFailureRepository;
+
     @InjectMocks
     private EmailService emailService;
 
@@ -42,15 +62,100 @@ void shouldSendEmailWhenReminderHasDueDate() {
         reminder.setDueDate(Instant.now());
         reminder.setUser(user);
 
+        MimeMessage message = mock(MimeMessage.class);
+        when(mailSender.createMimeMessage()).thenReturn(message);
+        when(mailEngine.createEmailMessage(any())).thenReturn(message);
+
         // Act
         emailService.send(reminder);
 
         // Assert
-        // verify(mailEngine).sendEmail(anyMap());
+        verify(mailEngine).sendEmail(message);
     }
 
     @Test
-    void shouldSendEmailWhenReminderHasRemindAtDate() {
+    void shouldThrowEmailSendExceptionWhenTrySendEmailWithFailureHandling() {
+        // Arrange
+        User user = new User();
+        user.setFirstName("John");
+        Contact contact = new Contact();
+        contact.setEmail("[email protected]");
+
+        user.setContact(contact);
+        contact.setUser(user);
+
+        Reminder reminder = new Reminder();
+        reminder.setTitle("Test Reminder");
+        reminder.setDueDate(Instant.now());
+        reminder.setUser(user);
+
+        MimeMessage mimeMessage = mock(MimeMessage.class);
+        Map<String, String> variables = new HashMap<>();
+
+        EmailService service = Mockito.spy(new EmailService(mailEngine, emailSendFailureRepository));
+
+        doThrow(new EmailSendException("SMTP Error")).when(mailEngine).sendEmail(mimeMessage);
+
+        // Act
+        service.sendEmailWithFailureHandling(reminder, mimeMessage, variables);
+
+        // Assert
+        Mockito.verify(service).registerEmailFailure(variables, "SMTP Error");
+        verify(emailSendFailureRepository).save(any());
+    }
+
+    @Test
+    void shouldSendEmailWhenRetryEmailSendFailureWithRemindAtDate() {
+        // Arrange
+        EmailSendFailure emailSendFailure = new EmailSendFailure();
+
+        emailSendFailure.setName("Lucas");
+        emailSendFailure.setEmail("[email protected]");
+        emailSendFailure.setTitle("Test Reminder");
+        emailSendFailure.setRemindAt("11/12/2025");
+        emailSendFailure.setDueDate("11/12/2025");
+        emailSendFailure.setDisableNotificationUrl("#");
+        emailSendFailure.setSubject("Test - Subject");
+        emailSendFailure.setErrorMessage("SMTP Error");
+
+        MimeMessage message = mock(MimeMessage.class);
+        when(mailEngine.createEmailMessage(any())).thenReturn(message);
+
+        EmailService service = Mockito.spy(new EmailService(mailEngine, emailSendFailureRepository));
+
+        // Act
+        service.retryEmailSendFailure(emailSendFailure);
+
+        // Assert
+        verify(service).dispatchEmail(any());
+    }
+
+    @Test
+    void shouldReturnWhenRetryEmailSendFailureWithNullMimeMessageAndWithoutRemindAtDate() {
+        // Arrange
+        EmailSendFailure emailSendFailure = new EmailSendFailure();
+
+        emailSendFailure.setName("Lucas");
+        emailSendFailure.setEmail("[email protected]");
+        emailSendFailure.setTitle("Test Reminder");
+        emailSendFailure.setDueDate("11/12/2025");
+        emailSendFailure.setDisableNotificationUrl("#");
+        emailSendFailure.setSubject("Test - Subject");
+        emailSendFailure.setErrorMessage("SMTP Error");
+
+        when(mailEngine.createEmailMessage(any())).thenReturn(null);
+
+        EmailService service = Mockito.spy(new EmailService(mailEngine, emailSendFailureRepository));
+
+        // Act
+        service.retryEmailSendFailure(emailSendFailure);
+
+        // Assert
+        verify(service, never()).dispatchEmail(any());
+    }
+
+    @Test
+    void shouldNotSendEmailWhenReminderHasRemindAtDateAndNotCreateMimeMessage() {
         // Arrange
         User user = new User();
         user.setFirstName("John");
@@ -66,11 +171,15 @@ void shouldSendEmailWhenReminderHasRemindAtDate() {
         reminder.setDueDate(Instant.now());
         reminder.setUser(user);
 
+        when(mailEngine.createEmailMessage(any())).thenReturn(null);
+
+        EmailService service = Mockito.spy(new EmailService(mailEngine, emailSendFailureRepository));
+
         // Act
-        emailService.send(reminder);
+        service.send(reminder);
 
         // Assert
-        // verify(mailEngine).sendEmail(anyMap());
+        verify(service, never()).sendEmailWithFailureHandling(any(), any(), any());
     }
 
     @Test