PAN-7 Wrote unit tests for the DefinitionController

2019-02-24 15:30:05 -07:00
parent f2c05fb68f
commit 09cbc8c64a
5 changed files with 190 additions and 12 deletions
@@ -28,7 +28,6 @@ dependencies {
    compile group: 'org.hibernate', name: 'hibernate-core', version: '5.4.1.Final'
    compile group: 'com.vladmihalcea', name: 'hibernate-types-52', version: '2.4.1'

-
    compile fileTree(dir: 'lib', include: '**/*.jar')

    compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.15'
@@ -27,14 +27,14 @@ public class PersistenceTestConfig {
    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
-        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
-        em.setJpaVendorAdapter(vendorAdapter());
-        em.setDataSource(getDataSource());
-        em.setPersistenceProviderClass(HibernatePersistenceProvider.class);
-        em.setPackagesToScan("edu.msudenver.tsp.persistence");
-        em.setJpaProperties(additionalProperties());
+        final LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
+        entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter());
+        entityManagerFactoryBean.setDataSource(getDataSource());
+        entityManagerFactoryBean.setPersistenceProviderClass(HibernatePersistenceProvider.class);
+        entityManagerFactoryBean.setPackagesToScan("edu.msudenver.tsp.persistence");
+        entityManagerFactoryBean.setJpaProperties(additionalProperties());

-        return em;
+        return entityManagerFactoryBean;
    }

    @Bean
@@ -11,6 +11,8 @@ import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;

+import javax.validation.Valid;
+import javax.validation.groups.Default;
 import java.util.List;
 import java.util.Optional;

@@ -48,6 +50,7 @@ public class DefinitionController {
            LOG.error("ERROR: ID was null");
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }
+
        LOG.debug("Querying for definition with id " + id);

        final StopWatch stopWatch = new StopWatch();
@@ -70,14 +73,16 @@ public class DefinitionController {
    }

    @PostMapping("/")
+    @Validated({DefinitionDto.Insert.class, Default.class})
    public @ResponseBody ResponseEntity<DefinitionDto> insertDefinition(
-            @Validated(DefinitionDto.Insert.class) @RequestBody final DefinitionDto definitionDto,
+            @Valid @RequestBody final DefinitionDto definitionDto,
            final BindingResult bindingResult) {
        LOG.info("Received request to insert a new definition");
        if (bindingResult.hasErrors()) {
            LOG.error("Binding result is unprocessable");
            return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY);
        }
+
        if (definitionDto == null) {
            LOG.error("Passed entity is unprocessable");
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
@@ -9,7 +9,7 @@ import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.EntityListeners;
 import javax.persistence.Table;
-import javax.validation.constraints.NotNull;
+import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.Size;
 import java.io.Serializable;

@@ -19,8 +19,13 @@ import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = true)
 public class DefinitionDto extends BaseDto implements Serializable {
-    @NotNull(groups = Insert.class) @Size(min = 1, max = 200, message = "Must be between 1 and 200 characters") private String name;
-    @NotNull(groups = Insert.class) @Type(type = "json") @Column(columnDefinition = "jsonb") private Definition definition;
+    @NotBlank(groups = Insert.class, message = "A name must be specified")
+    @Size(min = 1, max = 200, message = "Must be between 1 and 200 characters")
+    private String name;
+
+    @NotBlank(groups = Insert.class, message = "At least one (1) definition must be specified")
+    @Type(type = "json") @Column(columnDefinition = "jsonb") private Definition definition;
+
    @Type(type = "json") @Column(columnDefinition = "jsonb") private Notation notation;

    public static final long serialVersionUID = -5314619286352932857L;
@@ -0,0 +1,169 @@
+package edu.msudenver.tsp.persistence.controller;
+
+import edu.msudenver.tsp.persistence.dto.Definition;
+import edu.msudenver.tsp.persistence.dto.DefinitionDto;
+import edu.msudenver.tsp.persistence.dto.Notation;
+import edu.msudenver.tsp.persistence.repository.DefinitionRepository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.BindingResult;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+@WebMvcTest(controllers = DefinitionController.class)
+public class DefinitionControllerTest {
+    @Mock private DefinitionRepository definitionRepository;
+    @InjectMocks private DefinitionController definitionController;
+    @Mock private BindingResult bindingResult;
+
+    @Test
+    public void testGetAllDefinitions() {
+        final DefinitionDto definitionDto = createDefinition();
+        final List<DefinitionDto> definitionDtoList = new ArrayList<>();
+        definitionDtoList.add(definitionDto);
+        definitionDtoList.add(definitionDto);
+
+        when(definitionRepository.findAll()).thenReturn(definitionDtoList);
+
+        final ResponseEntity<Iterable<DefinitionDto>> responseEntity = definitionController.getAllDefinitions();
+
+        assertNotNull(responseEntity);
+        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
+        assertTrue(responseEntity.hasBody());
+        assertNotNull(responseEntity.getBody());
+
+        responseEntity.getBody().forEach(definition -> assertEquals(definition, definitionDto));
+    }
+
+    @Test
+    public void testGetDefinitionsById() {
+        final DefinitionDto definitionDto = createDefinition();
+        when(definitionRepository.findById(anyInt())).thenReturn(Optional.ofNullable(definitionDto));
+
+        final ResponseEntity<DefinitionDto> responseEntity = definitionController.getDefinitionById(1);
+
+        assertNotNull(responseEntity);
+        assertTrue(responseEntity.hasBody());
+        assertNotNull(responseEntity.getBody());
+        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
+        assertEquals(definitionDto, responseEntity.getBody());
+        verify(definitionRepository).findById(anyInt());
+    }
+
+    @Test
+    public void testGetDefinitionById_nullId() {
+        final ResponseEntity responseEntity = definitionController.getDefinitionById(null);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode());
+        verifyZeroInteractions(definitionRepository);
+    }
+
+    @Test
+    public void testGetDefinitionById_noDefinitionFound() {
+        when(definitionRepository.findById(anyInt())).thenReturn(Optional.empty());
+
+        final ResponseEntity responseEntity = definitionController.getDefinitionById(1);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode());
+        verify(definitionRepository).findById(anyInt());
+    }
+
+    @Test
+    public void testInsertDefinition() {
+        final DefinitionDto definitionDto = createDefinition();
+        when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(definitionDto);
+
+        final ResponseEntity<DefinitionDto> responseEntity = definitionController.insertDefinition(definitionDto, bindingResult);
+
+        assertNotNull(responseEntity);
+        assertTrue(responseEntity.hasBody());
+        assertNotNull(responseEntity.getBody());
+        assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
+        assertEquals(definitionDto, responseEntity.getBody());
+        verify(definitionRepository).save(any(DefinitionDto.class));
+    }
+
+    @Test
+    public void testInsertDefinition_definitionDtoIsNull() {
+        final ResponseEntity responseEntity = definitionController.insertDefinition(null, bindingResult);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode());
+        verifyZeroInteractions(definitionRepository);
+    }
+
+    @Test
+    public void testInsertDefinition_bindingResultHasErrors() {
+        final DefinitionDto definitionDto = createDefinition();
+        when(bindingResult.hasErrors()).thenReturn(true);
+
+        final ResponseEntity responseEntity = definitionController.insertDefinition(definitionDto, bindingResult);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode());
+        verifyZeroInteractions(definitionRepository);
+    }
+
+    @Test
+    public void testDeleteDefinitionById() {
+        doNothing().when(definitionRepository).deleteById(anyInt());
+
+        final ResponseEntity responseEntity = definitionController.deleteDefinitionById(1);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode());
+        verify(definitionRepository).deleteById(anyInt());
+    }
+
+    @Test
+    public void testDeleteDefinitionById_nullId() {
+        final ResponseEntity responseEntity = definitionController.deleteDefinitionById(null);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode());
+        verifyZeroInteractions(definitionRepository);
+    }
+
+    private DefinitionDto createDefinition() {
+        final List<String> definitionList = new ArrayList<>();
+        definitionList.add("Test definition 1");
+
+        final Definition definition = new Definition();
+        definition.setDefinitions(definitionList);
+
+        final List<String> notationList = new ArrayList<>();
+        notationList.add("\\testLaTeX");
+
+        final Notation notation = new Notation();
+        notation.setNotations(notationList);
+
+        final DefinitionDto definitionDto = new DefinitionDto();
+        definitionDto.setName("Test Name");
+        definitionDto.setDefinition(definition);
+        definitionDto.setNotation(notation);
+
+        return definitionDto;
+    }
+}