Added a few more unit tests to maximize coverage

src/test/java/com/dominik/tutorial/spring5/petclinicwebflux/controllers/BaseControllerTest.java

@@ -1,26 +1,49 @@
 package com.dominik.tutorial.spring5.petclinicwebflux.controllers;
 
+import com.dominik.tutorial.spring5.petclinicwebflux.exceptions.EntityNotFoundException;
 import com.dominik.tutorial.spring5.petclinicwebflux.exceptions.InvalidParameterException;
+import com.dominik.tutorial.spring5.petclinicwebflux.model.Owner;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.ui.Model;
 
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.then;
+import static org.mockito.Mockito.times;
 
 @DisplayName("Base Controller")
+@ExtendWith(MockitoExtension.class)
 class BaseControllerTest {
 
+    private final String MODEL_ATTRIBUTE_ERROR = "error";
+    private final String EXPECTED_VIEW_ERROR = "400error";
+
+    @Mock
+    private Model model;
+    private BaseController controller;
+
+    @BeforeEach
+    void setUp() {
+        this.controller = new BaseController();
+    }
+
     @DisplayName("should convert valid UUID")
     @Test
     void testFromStringOrThrowValid() {
         // given
-        BaseController controller = new BaseController();
         String id = UUID.randomUUID().toString();
 
         // when
-        String convertedId = controller.fromStringOrThrow(id, BaseController.class).toString();
+        String convertedId = this.controller.fromStringOrThrow(id, BaseController.class).toString();
 
         // then
         assertThat(id).isEqualTo(convertedId);
@@ -32,14 +55,32 @@ void testFromStringOrThrowInvalid() {
         // given
         String id = "123";
         String expectedMessage = "Given UUID '" + id + "' for entity BaseController is invalid";
-        BaseController controller = new BaseController();
 
         // when
         Exception exception = assertThrows(InvalidParameterException.class, () -> {
-            controller.fromStringOrThrow(id, BaseController.class);
+            this.controller.fromStringOrThrow(id, BaseController.class);
         });
 
         // then
         assertThat(expectedMessage).isEqualTo(exception.getMessage());
     }
+
+    @DisplayName("should add exceptions to model")
+    @Test
+    void testExceptionHandling() {
+        // given
+        ArgumentCaptor<Exception> captor = ArgumentCaptor.forClass(Exception.class);
+        EntityNotFoundException e1 = EntityNotFoundException.failedIdLookup(Owner.class, "123");
+        InvalidParameterException e2 = InvalidParameterException.invalidUUID(Owner.class, "123");
+
+        // when
+        String returnedView1 = this.controller.handleEntityNotFound(e1, this.model);
+        String returnedView2 = this.controller.handleInvalidParameter(e2, this.model);
+
+        // then
+        then(this.model).should(times(1)).addAttribute(eq(MODEL_ATTRIBUTE_ERROR), eq(e1));
+        then(this.model).should(times(1)).addAttribute(eq(MODEL_ATTRIBUTE_ERROR), eq(e2));
+        assertThat(EXPECTED_VIEW_ERROR).isEqualTo(returnedView1);
+        assertThat(EXPECTED_VIEW_ERROR).isEqualTo(returnedView2);
+    }
 }

src/test/java/com/dominik/tutorial/spring5/petclinicwebflux/controllers/VisitControllerTest.java

@@ -20,8 +20,10 @@
 import org.springframework.ui.Model;
 import org.springframework.validation.BindingResult;
 import org.springframework.web.bind.WebDataBinder;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.util.List;
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -253,6 +255,54 @@ void testCreateVisitValid() {
         assertThat(EXPECTED_REDIRECT_OWNER_DETAILS + owner.getId().toString()).isEqualTo(returnedView);
     }
 
+    @DisplayName("should get owner for model")
+    @Test
+    void testOwnerToModel() {
+        // given
+        Owner owner = this.testDataFactory.getOwner();
+        given(this.ownerService.getById(owner.getId())).willReturn(Mono.just(owner));
+
+        // when
+        Owner resultOwner = this.controller.addOwnerToModel(owner.getId().toString()).block();
+
+        // then
+        assertThat(owner).isEqualToComparingFieldByField(resultOwner);
+    }
+
+    @DisplayName("should get pet for model")
+    @Test
+    void testPetToModel() {
+        // given
+        Owner owner = this.testDataFactory.getOwner();
+        Pet pet = this.testDataFactory.getPet();
+        given(this.petService.findByIdAndOwner(pet.getId(), owner.getId())).willReturn(Mono.just(pet));
+
+        // when
+        Pet resultPet = this.controller.addPetToModel(owner.getId().toString(), pet.getId().toString()).block();
+
+        // then
+        assertThat(pet).isEqualToComparingFieldByField(resultPet);
+    }
+
+    @DisplayName("should get visits for model")
+    @Test
+    void testVisitsToModel() {
+        // given
+        Owner owner = this.testDataFactory.getOwner();
+        Pet pet = this.testDataFactory.getPet();
+        List<Visit> visits = this.testDataFactory.getVisits();
+        given(this.visitService.findByPet(pet.getId())).willReturn(Flux.fromIterable(visits));
+
+        // when
+        List<Visit> resultVisits = this.controller.addPetVisitsToModel(pet.getId().toString()).collectList().block();
+
+        // then
+        assertThat(resultVisits).hasSize(visits.size());
+        for (int i = 0; i < visits.size(); i++) {
+            assertThat(visits.get(i)).isEqualToComparingFieldByField(resultVisits.get(i));
+        }
+    }
+
     private void addDataBinderMock() {
         this.addDataBinderMock(false);
     }