From 09cbc8c64ae6ae8c61c90ed48f64e1c9704cf9ed Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 15:30:05 -0700 Subject: [PATCH] PAN-7 Wrote unit tests for the DefinitionController --- .../persistence/build.gradle | 1 - .../persistence/PersistenceTestConfig.java | 14 +- .../controller/DefinitionController.java | 7 +- .../tsp/persistence/dto/DefinitionDto.java | 11 +- .../controller/DefinitionControllerTest.java | 169 ++++++++++++++++++ 5 files changed, 190 insertions(+), 12 deletions(-) create mode 100644 pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java diff --git a/pandamonium-theorem-prover/persistence/build.gradle b/pandamonium-theorem-prover/persistence/build.gradle index 17d840c..b832e7e 100644 --- a/pandamonium-theorem-prover/persistence/build.gradle +++ b/pandamonium-theorem-prover/persistence/build.gradle @@ -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' diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java index af3f81a..7427fa2 100644 --- a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java @@ -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 diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index dbccab2..cb74331 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -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 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); diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java index 89d4b67..806e84c 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java @@ -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; diff --git a/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java new file mode 100644 index 0000000..df20891 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java @@ -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 definitionDtoList = new ArrayList<>(); + definitionDtoList.add(definitionDto); + definitionDtoList.add(definitionDto); + + when(definitionRepository.findAll()).thenReturn(definitionDtoList); + + final ResponseEntity> 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 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 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 definitionList = new ArrayList<>(); + definitionList.add("Test definition 1"); + + final Definition definition = new Definition(); + definition.setDefinitions(definitionList); + + final List 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; + } +} \ No newline at end of file