From 8c9f2bbd9cb79f1a75c286ea598aba091fc90827 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 17:30:39 -0700 Subject: [PATCH 01/10] PAN-48 Updated the AccountsDto and the AccountsRepository --- .../edu/msudenver/tsp/persistence/dto/AccountsDto.java | 7 +++++-- .../tsp/persistence/repository/AccountsRepository.java | 4 ++-- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java index 6d689a5..ebc0a0a 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java @@ -9,6 +9,7 @@ import javax.persistence.Entity; import javax.persistence.EntityListeners; import javax.persistence.Temporal; import javax.persistence.TemporalType; +import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; import java.io.Serializable; @@ -19,10 +20,12 @@ import java.util.Date; @Data @EqualsAndHashCode(callSuper = true) public class AccountsDto extends BaseDto implements Serializable { - @Size(max = 50) private String username; - @Size(max = 256) private String password; + @NotBlank(groups = Insert.class, message = "A username must be specified") @Size(max = 50) private String username; + @NotBlank(groups = Insert.class, message = "A password must be specified") @Size(max = 256) private String password; @NotNull @JsonProperty("administrator_status") private boolean administratorStatus; @Temporal(TemporalType.DATE) @JsonProperty("last_login") private Date lastLogin; public static final long serialVersionUID = 7095627971593953734L; + + interface Insert {} } diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java index a2d0704..b1658be 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java @@ -1,9 +1,9 @@ package edu.msudenver.tsp.persistence.repository; import edu.msudenver.tsp.persistence.dto.AccountsDto; -import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; @Repository -public interface AccountsRepository extends JpaRepository { +public interface AccountsRepository extends CrudRepository { } From b77a750c3098793b9d4a4423c8837adcb5cab25c Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 19:14:17 -0700 Subject: [PATCH 02/10] PAN-48 Created the AccountController and created the copyNonNullProperties method --- .../controller/AccountController.java | 163 +++++++++++++++++- .../tsp/persistence/dto/AccountsDto.java | 2 +- .../utilities/build.gradle | 3 +- .../tsp/utilities/PersistenceUtilities.java | 27 +++ 4 files changed, 189 insertions(+), 6 deletions(-) create mode 100644 pandamonium-theorem-prover/utilities/src/main/java/edu/msudenver/tsp/utilities/PersistenceUtilities.java diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index 8404acb..25b1fe7 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -2,11 +2,22 @@ package edu.msudenver.tsp.persistence.controller; import edu.msudenver.tsp.persistence.dto.AccountsDto; import edu.msudenver.tsp.persistence.repository.AccountsRepository; +import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.util.StopWatch; +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; +@Slf4j @RestController @AllArgsConstructor @RequestMapping("/accounts") @@ -14,13 +25,157 @@ public class AccountController { private final AccountsRepository accountsRepository; @GetMapping("/") - public @ResponseBody Iterable getListOfAccounts() { - return accountsRepository.findAll(); + public @ResponseBody + ResponseEntity> getListOfAccounts() { + LOG.info("Received request to list all accounts"); + + LOG.debug("Querying for list of accounts"); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfAccounts = (List) accountsRepository.findAll(); + + stopWatch.stop(); + + LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning list of all accounts with size of " + listOfAccounts.size()); + + return new ResponseEntity<>(listOfAccounts, HttpStatus.OK); } @GetMapping("/{id}") public @ResponseBody - Optional getAccountById(@PathVariable("id") final Integer id) { - return accountsRepository.findById(id); + ResponseEntity getAccountById(@PathVariable("id") final Integer id) { + LOG.info("Received request to query for account with id " + id); + if (id == null) { + LOG.error("ERROR: ID was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for account with id " + id); + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional account = accountsRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + return account.map(accountDto -> { + LOG.info("Returning account with id " + id); + return new ResponseEntity<>(accountDto, HttpStatus.OK); + }).orElseGet( + () -> { + LOG.warn("No account was found with id " + id); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + ); + } + + @PostMapping("/") + @Validated({AccountsDto.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertAccount( + @Valid @RequestBody final AccountsDto accountsDto, final BindingResult bindingResult) { + + LOG.info("Received request to insert a new account"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (accountsDto == null) { + LOG.error("Passed account is unprocessable"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Saving new account"); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final AccountsDto savedAccount = accountsRepository.save(accountsDto); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning the newly created account"); + return new ResponseEntity<>(savedAccount, HttpStatus.CREATED); + } + + @PatchMapping("/{id}") + public @ResponseBody ResponseEntity updateAccount( + @PathVariable("id") final Integer id, + @RequestBody final AccountsDto accountsDto, final BindingResult bindingResult) { + + LOG.info("Received request to update an account"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (accountsDto == null) { + LOG.error("Passed entity is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + if (id == null) { + LOG.error("Account ID must be specified"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Checking for existence of account with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional existingAccount = accountsRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + if (!existingAccount.isPresent()) { + LOG.error("No account associated with id " + id); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + PersistenceUtilities.copyNonNullProperties(accountsDto, existingAccount.get()); + existingAccount.get().setVersion(existingAccount.get().getVersion()+ 1); + + LOG.info("Updating account with id " + id); + LOG.debug("Querying for account with ID " + id); + + stopWatch.start(); + + final AccountsDto updatedAccount = accountsRepository.save(existingAccount.get()); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + return new ResponseEntity<>(updatedAccount, HttpStatus.OK); + } + + @DeleteMapping("/{id}") + public @ResponseBody ResponseEntity deleteAccountById(@PathVariable("id") final Integer id) { + LOG.info("Received request to delete account with id " + id); + if (id == null) { + LOG.error("Specified Id is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Deleting account with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + accountsRepository.deleteById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + return new ResponseEntity<>(HttpStatus.NO_CONTENT); } } diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java index ebc0a0a..cd71505 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java @@ -27,5 +27,5 @@ public class AccountsDto extends BaseDto implements Serializable { public static final long serialVersionUID = 7095627971593953734L; - interface Insert {} + public interface Insert {} } diff --git a/pandamonium-theorem-prover/utilities/build.gradle b/pandamonium-theorem-prover/utilities/build.gradle index 007e3e1..b9e2ce9 100644 --- a/pandamonium-theorem-prover/utilities/build.gradle +++ b/pandamonium-theorem-prover/utilities/build.gradle @@ -18,6 +18,7 @@ repositories { } dependencies { - testCompile group: 'junit', name: 'junit', version: '4.12' compile fileTree(dir: 'lib', include: '**/*.jar') + + testCompile group: 'junit', name: 'junit', version: '4.12' } diff --git a/pandamonium-theorem-prover/utilities/src/main/java/edu/msudenver/tsp/utilities/PersistenceUtilities.java b/pandamonium-theorem-prover/utilities/src/main/java/edu/msudenver/tsp/utilities/PersistenceUtilities.java new file mode 100644 index 0000000..4b39e24 --- /dev/null +++ b/pandamonium-theorem-prover/utilities/src/main/java/edu/msudenver/tsp/utilities/PersistenceUtilities.java @@ -0,0 +1,27 @@ +package edu.msudenver.tsp.utilities; + +import lombok.AccessLevel; +import lombok.NoArgsConstructor; +import org.springframework.beans.BeanUtils; +import org.springframework.beans.BeanWrapper; +import org.springframework.beans.BeanWrapperImpl; + +import java.beans.FeatureDescriptor; +import java.util.stream.Stream; + +@NoArgsConstructor(access = AccessLevel.PRIVATE) +public abstract class PersistenceUtilities { + + private static String[] getNullPropertyNames(final Object source) { + final BeanWrapper wrappedSource = new BeanWrapperImpl(source); + return Stream.of(wrappedSource.getPropertyDescriptors()) + .map(FeatureDescriptor::getName) + .filter(propertyName -> wrappedSource.getPropertyValue(propertyName) == null + || propertyName.equals("id")) + .toArray(String[]::new); + } + + public static void copyNonNullProperties(final Object source, final Object target) { + BeanUtils.copyProperties(source, target, getNullPropertyNames(source)); + } +} From a3ab3f10bf7d45f8dd622039367505c12556702e Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 19:17:51 -0700 Subject: [PATCH 03/10] PAN-48 Created the updateDefinition method --- .../controller/DefinitionController.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) 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 cb74331..758e68c 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 @@ -2,6 +2,7 @@ package edu.msudenver.tsp.persistence.controller; import edu.msudenver.tsp.persistence.dto.DefinitionDto; import edu.msudenver.tsp.persistence.repository.DefinitionRepository; +import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.http.HttpStatus; @@ -102,6 +103,60 @@ public class DefinitionController { return new ResponseEntity<>(savedDefinition, HttpStatus.CREATED); } + @PatchMapping("/{id}") + public @ResponseBody ResponseEntity updateAccount( + @PathVariable("id") final Integer id, + @RequestBody final DefinitionDto definitionDto, final BindingResult bindingResult) { + + LOG.info("Received request to update an account"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (definitionDto == null) { + LOG.error("Passed entity is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + if (id == null) { + LOG.error("Definition ID must be specified"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Checking for existence of definition with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional existingDefinition = definitionRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + if (!existingDefinition.isPresent()) { + LOG.error("No definition associated with id " + id); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + PersistenceUtilities.copyNonNullProperties(definitionDto, existingDefinition.get()); + existingDefinition.get().setVersion(existingDefinition.get().getVersion()+ 1); + + LOG.info("Updating definition with id " + id); + LOG.debug("Querying for definition with ID " + id); + + stopWatch.start(); + + final DefinitionDto updatedDefinition = definitionRepository.save(existingDefinition.get()); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + return new ResponseEntity<>(updatedDefinition, HttpStatus.OK); + } + @DeleteMapping("/{id}") public @ResponseBody ResponseEntity deleteDefinitionById(@PathVariable("id") final Integer id) { LOG.info("Received request to delete definition with id " + id); From 9020b0fdbba314c21cfcfc88a2e23f1911c5ae19 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 19:48:18 -0700 Subject: [PATCH 04/10] PAN-48 Wrote unit tests for the updateDefinition method --- .../controller/DefinitionController.java | 2 +- .../controller/DefinitionControllerTest.java | 66 +++++++++++++++++++ 2 files changed, 67 insertions(+), 1 deletion(-) 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 758e68c..3b788a5 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 @@ -104,7 +104,7 @@ public class DefinitionController { } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateAccount( + public @ResponseBody ResponseEntity updateDefinition( @PathVariable("id") final Integer id, @RequestBody final DefinitionDto definitionDto, final BindingResult bindingResult) { 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 index df20891..b24d508 100644 --- 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 @@ -124,6 +124,72 @@ public class DefinitionControllerTest { verifyZeroInteractions(definitionRepository); } + @Test + public void testUpdateDefinition() { + final DefinitionDto existingDefinition = createDefinition(); + existingDefinition.setId(1); + existingDefinition.setVersion(1); + final DefinitionDto definitionUpdate = new DefinitionDto(); + definitionUpdate.setName("Test Update"); + final DefinitionDto updatedDefinition = existingDefinition; + updatedDefinition.setName("Test Update"); + when(definitionRepository.findById(anyInt())).thenReturn(Optional.of(existingDefinition)); + when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(updatedDefinition); + + final ResponseEntity responseEntity = definitionController.updateDefinition(1, definitionUpdate, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(updatedDefinition, responseEntity.getBody()); + verify(definitionRepository).findById(anyInt()); + verify(definitionRepository).save(any(DefinitionDto.class)); + } + + @Test + public void testUpdateDefinition_bindingResultErrors() { + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + @Test + public void testUpdateDefinition_definitionDtoIsNull() { + final ResponseEntity responseEntity = definitionController.updateDefinition(1, null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + @Test + public void testUpdateDefinition_idIsNull() { + final ResponseEntity responseEntity = definitionController.updateDefinition(null, createDefinition(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + @Test + public void testUpdateDefinition_definitionDoesntExist() { + when(definitionRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verify(definitionRepository, times(0)).save(any(DefinitionDto.class)); + } + @Test public void testDeleteDefinitionById() { doNothing().when(definitionRepository).deleteById(anyInt()); From 327724faf1d6adbcd2d52ff484dce93c3371bed9 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 19:59:49 -0700 Subject: [PATCH 05/10] PAN-48 Wrote unit tests for the AccountController --- .../controller/AccountControllerTest.java | 224 ++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java diff --git a/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java new file mode 100644 index 0000000..960a14c --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java @@ -0,0 +1,224 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.AccountsDto; +import edu.msudenver.tsp.persistence.repository.AccountsRepository; +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.any; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.*; + +@RunWith(MockitoJUnitRunner.class) +@WebMvcTest(controllers = AccountController.class) +public class AccountControllerTest { + @Mock + private AccountsRepository accountsRepository; + @InjectMocks + private AccountController accountController; + @Mock private BindingResult bindingResult; + + @Test + public void testGetAllAccounts() { + final AccountsDto accountsDto = createAccount(); + final List accountsDtoList = new ArrayList<>(); + accountsDtoList.add(accountsDto); + accountsDtoList.add(accountsDto); + + when(accountsRepository.findAll()).thenReturn(accountsDtoList); + + final ResponseEntity> responseEntity = accountController.getListOfAccounts(); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(account -> assertEquals(account, accountsDto)); + } + + @Test + public void testGetAccountById() { + final AccountsDto accountsDto = createAccount(); + when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(accountsDto)); + + final ResponseEntity responseEntity = accountController.getAccountById(1); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(accountsDto, responseEntity.getBody()); + verify(accountsRepository).findById(anyInt()); + } + + @Test + public void testGetAccountById_nullId() { + final ResponseEntity responseEntity = accountController.getAccountById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testGetAccountById_noAccountFound() { + when(accountsRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = accountController.getAccountById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + verify(accountsRepository).findById(anyInt()); + } + + @Test + public void testInsertAccount() { + final AccountsDto accountsDto = createAccount(); + when(accountsRepository.save(any(AccountsDto.class))).thenReturn(accountsDto); + + final ResponseEntity responseEntity = accountController.insertAccount(accountsDto, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); + assertEquals(accountsDto, responseEntity.getBody()); + verify(accountsRepository).save(any(AccountsDto.class)); + } + + @Test + public void testInsertAccount_accountsDtoIsNull() { + final ResponseEntity responseEntity = accountController.insertAccount(null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testInsertAccount_bindingResultHasErrors() { + final AccountsDto definitionDto = createAccount(); + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = accountController.insertAccount(definitionDto, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testUpdateAccount() { + final AccountsDto existingAccount = createAccount(); + existingAccount.setId(1); + existingAccount.setVersion(1); + final AccountsDto accountUpdate = new AccountsDto(); + accountUpdate.setUsername("Test Update"); + final AccountsDto updatedAccount = existingAccount; + updatedAccount.setUsername("Test Update"); + when(accountsRepository.findById(anyInt())).thenReturn(Optional.of(existingAccount)); + when(accountsRepository.save(any(AccountsDto.class))).thenReturn(updatedAccount); + + final ResponseEntity responseEntity = accountController.updateAccount(1, accountUpdate, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(updatedAccount, responseEntity.getBody()); + verify(accountsRepository).findById(anyInt()); + verify(accountsRepository).save(any(AccountsDto.class)); + } + + @Test + public void testUpdateAccount_bindingResultHasErrors() { + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testUpdateAccount_accountsDtoIsNull() { + final ResponseEntity responseEntity = accountController.updateAccount(1, null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testUpdateAccount_idIsNull() { + final ResponseEntity responseEntity = accountController.updateAccount(null, createAccount(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + @Test + public void testUpdateAccount_accountDoesNotExist() { + when(accountsRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verify(accountsRepository, times(0)).save(any(AccountsDto.class)); + } + + @Test + public void testDeleteAccountById() { + doNothing().when(accountsRepository).deleteById(anyInt()); + + final ResponseEntity responseEntity = accountController.deleteAccountById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode()); + verify(accountsRepository).deleteById(anyInt()); + } + + @Test + public void testDeleteAccountById_idIsNull() { + final ResponseEntity responseEntity = accountController.deleteAccountById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(accountsRepository); + } + + private AccountsDto createAccount() { + final AccountsDto accountsDto = new AccountsDto(); + accountsDto.setUsername("Test username"); + accountsDto.setPassword("test password"); + accountsDto.setAdministratorStatus(true); + + return accountsDto; + } +} \ No newline at end of file From 68fb41c0678abf2aa84da057be29c87ff8423871 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 20:13:01 -0700 Subject: [PATCH 06/10] PAN-48 Wrote IntegrationTests for Accounts --- .../persistence/AccountsIntegrationTest.java | 56 +++++++++++++++++++ .../DefinitionsIntegrationTest.java | 1 - 2 files changed, 56 insertions(+), 1 deletion(-) create mode 100644 pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java new file mode 100644 index 0000000..7af6e22 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -0,0 +1,56 @@ +package edu.msudenver.tsp.persistence; + +import edu.msudenver.tsp.persistence.repository.AccountsRepository; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.Optional; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = PersistenceTestConfig.class) +public class AccountsIntegrationTest { + @Autowired private AccountsRepository accountsRepository; + + @Test + public void testCRUDFunctionality() { + final AccountsDto accountsDto = createAccount(); + final AccountsDto savedAccount = accountsRepository.save(accountsDto); + + assertNotNull(savedAccount); + assertEquals(Integer.valueOf(0), savedAccount.getVersion()); + + final int id = savedAccount.getId(); + + assertEquals("Test username", savedAccount.getUsername()); + assertEquals("test password", savedAccount.getPassword()); + assertTrue(savedAccount.isAdministratorStatus()); + assertEquals(1, savedAccount.getVersion()); + + savedAccount.setPassword("Test Update"); + + final AccountsDto updatedAccount = accountsRepository.save(savedAccount); + + assertEquals("Test username", savedAccount.getUsername()); + assertEquals("Test Update", savedAccount.getPassword()); + assertTrue(savedAccount.isAdministratorStatus()); + assertEquals(2, savedAccount.getVersion()); + assertEquals(updatedAccount.getId(), id); + + accountsRepository.deleteById(id); + final Optional deletedAccount = accountsRepository.findById(id); + assertFalse(deletedDefinition.isPresent()); + } + + private AccountsDto createAccount() { + final AccountsDto accountsDto = new AccountsDto(); + accountsDto.setUsername("Test username"); + accountsDto.setPassword("test password"); + accountsDto.setAdministratorStatus(true); + + return accountsDto; + } + +} diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java index 824d5a8..b6544db 100644 --- a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java @@ -23,7 +23,6 @@ public class DefinitionsIntegrationTest { @Test public void testCRUDFunctionality() { - // Create a new definition final DefinitionDto definitionDto = createDefinition(); final DefinitionDto savedDefinition = definitionRepository.save(definitionDto); From 9ad185b033a6c81de9a2abbeef7a08898b98ee75 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 20:22:22 -0700 Subject: [PATCH 07/10] PAN-48 Wrote IntegrationTests for Accounts --- .../tsp/persistence/AccountsIntegrationTest.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java index 7af6e22..fd88915 100644 --- a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -1,5 +1,6 @@ package edu.msudenver.tsp.persistence; +import edu.msudenver.tsp.persistence.dto.AccountsDto; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -9,6 +10,8 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import java.util.Optional; +import static org.junit.Assert.*; + @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = PersistenceTestConfig.class) public class AccountsIntegrationTest { @@ -27,7 +30,6 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("test password", savedAccount.getPassword()); assertTrue(savedAccount.isAdministratorStatus()); - assertEquals(1, savedAccount.getVersion()); savedAccount.setPassword("Test Update"); @@ -36,12 +38,11 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); assertTrue(savedAccount.isAdministratorStatus()); - assertEquals(2, savedAccount.getVersion()); assertEquals(updatedAccount.getId(), id); - accountsRepository.deleteById(id); + accountsRepository.delete(accountsDto); final Optional deletedAccount = accountsRepository.findById(id); - assertFalse(deletedDefinition.isPresent()); + assertFalse(deletedAccount.isPresent()); } private AccountsDto createAccount() { From 030e66f51635d84e8bac9717815e855e6738d7f9 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 20:25:20 -0700 Subject: [PATCH 08/10] PAN-48 Added update test to Definition integration test --- .../DefinitionsIntegrationTest.java | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java index b6544db..93db37e 100644 --- a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java @@ -44,7 +44,25 @@ public class DefinitionsIntegrationTest { assertEquals("Test definition 2", definitionsList.get(1)); assertEquals("\\testLaTeX", notationList.get(0)); - definitionRepository.delete(savedDefinition); + savedDefinition.setName("Test Update"); + + final DefinitionDto updatedDefinition = definitionRepository.save(savedDefinition); + + assertEquals("Test Update", updatedDefinition.getName()); + assertNotNull(updatedDefinition.getDefinition()); + assertNotNull(updatedDefinition.getNotation()); + + final List updatedDefinitionsList = updatedDefinition.getDefinition().getDefinitions(); + final List updatedNotationsList = updatedDefinition.getNotation().getNotations(); + + assertEquals(2, updatedDefinitionsList.size()); + assertEquals(1, updatedNotationsList.size()); + assertEquals("Test definition 1", updatedDefinitionsList.get(0)); + assertEquals("Test definition 2", updatedDefinitionsList.get(1)); + assertEquals("\\testLaTeX", updatedNotationsList.get(0)); + assertEquals(id, updatedDefinition.getId()); + + definitionRepository.delete(updatedDefinition); final Optional deletedDefinition = definitionRepository.findById(id); assertFalse(deletedDefinition.isPresent()); } From 0734f6ff10b3a6fb53c5903aa966ff18fffd23ed Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 20:31:24 -0700 Subject: [PATCH 09/10] PAN-48 Added dependency on utilities to the persistence project --- pandamonium-theorem-prover/build.gradle | 7 ++ .../persistence/AccountsIntegrationTest.java | 24 +++---- .../controller/AccountController.java | 32 ++++----- .../dto/{AccountsDto.java => AccountDto.java} | 2 +- .../repository/AccountsRepository.java | 4 +- .../controller/AccountControllerTest.java | 70 +++++++++---------- 6 files changed, 73 insertions(+), 66 deletions(-) rename pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/{AccountsDto.java => AccountDto.java} (94%) diff --git a/pandamonium-theorem-prover/build.gradle b/pandamonium-theorem-prover/build.gradle index a89060e..6d49c57 100644 --- a/pandamonium-theorem-prover/build.gradle +++ b/pandamonium-theorem-prover/build.gradle @@ -45,6 +45,7 @@ allprojects { } subprojects { + apply plugin: 'java' repositories { mavenCentral() } @@ -108,6 +109,12 @@ dependencies { apt 'org.projectlombok:lombok:1.18.4' } +project(':persistence') { + dependencies { + compile project(':utilities') + } +} + test { if (System.properties['test.profile'] != 'integrationTest') { exclude '**/*integrationTest*' diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java index fd88915..b30a252 100644 --- a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.AccountsDto; +import edu.msudenver.tsp.persistence.dto.AccountDto; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -19,8 +19,8 @@ public class AccountsIntegrationTest { @Test public void testCRUDFunctionality() { - final AccountsDto accountsDto = createAccount(); - final AccountsDto savedAccount = accountsRepository.save(accountsDto); + final AccountDto accountDto = createAccount(); + final AccountDto savedAccount = accountsRepository.save(accountDto); assertNotNull(savedAccount); assertEquals(Integer.valueOf(0), savedAccount.getVersion()); @@ -33,25 +33,25 @@ public class AccountsIntegrationTest { savedAccount.setPassword("Test Update"); - final AccountsDto updatedAccount = accountsRepository.save(savedAccount); + final AccountDto updatedAccount = accountsRepository.save(savedAccount); assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); assertTrue(savedAccount.isAdministratorStatus()); assertEquals(updatedAccount.getId(), id); - accountsRepository.delete(accountsDto); - final Optional deletedAccount = accountsRepository.findById(id); + accountsRepository.delete(accountDto); + final Optional deletedAccount = accountsRepository.findById(id); assertFalse(deletedAccount.isPresent()); } - private AccountsDto createAccount() { - final AccountsDto accountsDto = new AccountsDto(); - accountsDto.setUsername("Test username"); - accountsDto.setPassword("test password"); - accountsDto.setAdministratorStatus(true); + private AccountDto createAccount() { + final AccountDto accountDto = new AccountDto(); + accountDto.setUsername("Test username"); + accountDto.setPassword("test password"); + accountDto.setAdministratorStatus(true); - return accountsDto; + return accountDto; } } diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index 25b1fe7..25f5368 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.AccountsDto; +import edu.msudenver.tsp.persistence.dto.AccountDto; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -26,7 +26,7 @@ public class AccountController { @GetMapping("/") public @ResponseBody - ResponseEntity> getListOfAccounts() { + ResponseEntity> getListOfAccounts() { LOG.info("Received request to list all accounts"); LOG.debug("Querying for list of accounts"); @@ -34,7 +34,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfAccounts = (List) accountsRepository.findAll(); + final List listOfAccounts = (List) accountsRepository.findAll(); stopWatch.stop(); @@ -46,7 +46,7 @@ public class AccountController { @GetMapping("/{id}") public @ResponseBody - ResponseEntity getAccountById(@PathVariable("id") final Integer id) { + ResponseEntity getAccountById(@PathVariable("id") final Integer id) { LOG.info("Received request to query for account with id " + id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -57,7 +57,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional account = accountsRepository.findById(id); + final Optional account = accountsRepository.findById(id); stopWatch.stop(); @@ -74,9 +74,9 @@ public class AccountController { } @PostMapping("/") - @Validated({AccountsDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertAccount( - @Valid @RequestBody final AccountsDto accountsDto, final BindingResult bindingResult) { + @Validated({AccountDto.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertAccount( + @Valid @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { LOG.info("Received request to insert a new account"); if (bindingResult.hasErrors()) { @@ -84,7 +84,7 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (accountsDto == null) { + if (accountDto == null) { LOG.error("Passed account is unprocessable"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -94,7 +94,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final AccountsDto savedAccount = accountsRepository.save(accountsDto); + final AccountDto savedAccount = accountsRepository.save(accountDto); stopWatch.stop(); @@ -104,9 +104,9 @@ public class AccountController { } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateAccount( + public @ResponseBody ResponseEntity updateAccount( @PathVariable("id") final Integer id, - @RequestBody final AccountsDto accountsDto, final BindingResult bindingResult) { + @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { LOG.info("Received request to update an account"); if (bindingResult.hasErrors()) { @@ -114,7 +114,7 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (accountsDto == null) { + if (accountDto == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -129,7 +129,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingAccount = accountsRepository.findById(id); + final Optional existingAccount = accountsRepository.findById(id); stopWatch.stop(); @@ -140,7 +140,7 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - PersistenceUtilities.copyNonNullProperties(accountsDto, existingAccount.get()); + PersistenceUtilities.copyNonNullProperties(accountDto, existingAccount.get()); existingAccount.get().setVersion(existingAccount.get().getVersion()+ 1); LOG.info("Updating account with id " + id); @@ -148,7 +148,7 @@ public class AccountController { stopWatch.start(); - final AccountsDto updatedAccount = accountsRepository.save(existingAccount.get()); + final AccountDto updatedAccount = accountsRepository.save(existingAccount.get()); stopWatch.stop(); diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java similarity index 94% rename from pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java rename to pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java index cd71505..717bc64 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java @@ -19,7 +19,7 @@ import java.util.Date; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class AccountsDto extends BaseDto implements Serializable { +public class AccountDto extends BaseDto implements Serializable { @NotBlank(groups = Insert.class, message = "A username must be specified") @Size(max = 50) private String username; @NotBlank(groups = Insert.class, message = "A password must be specified") @Size(max = 256) private String password; @NotNull @JsonProperty("administrator_status") private boolean administratorStatus; diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java index b1658be..454cd77 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java @@ -1,9 +1,9 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.AccountsDto; +import edu.msudenver.tsp.persistence.dto.AccountDto; import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; @Repository -public interface AccountsRepository extends CrudRepository { +public interface AccountsRepository extends CrudRepository { } diff --git a/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java index 960a14c..0b88630 100644 --- a/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java +++ b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.AccountsDto; +import edu.msudenver.tsp.persistence.dto.AccountDto; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -33,35 +33,35 @@ public class AccountControllerTest { @Test public void testGetAllAccounts() { - final AccountsDto accountsDto = createAccount(); - final List accountsDtoList = new ArrayList<>(); - accountsDtoList.add(accountsDto); - accountsDtoList.add(accountsDto); + final AccountDto accountDto = createAccount(); + final List accountDtoList = new ArrayList<>(); + accountDtoList.add(accountDto); + accountDtoList.add(accountDto); - when(accountsRepository.findAll()).thenReturn(accountsDtoList); + when(accountsRepository.findAll()).thenReturn(accountDtoList); - final ResponseEntity> responseEntity = accountController.getListOfAccounts(); + final ResponseEntity> responseEntity = accountController.getListOfAccounts(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); - responseEntity.getBody().forEach(account -> assertEquals(account, accountsDto)); + responseEntity.getBody().forEach(account -> assertEquals(account, accountDto)); } @Test public void testGetAccountById() { - final AccountsDto accountsDto = createAccount(); - when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(accountsDto)); + final AccountDto accountDto = createAccount(); + when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(accountDto)); - final ResponseEntity responseEntity = accountController.getAccountById(1); + final ResponseEntity responseEntity = accountController.getAccountById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(accountsDto, responseEntity.getBody()); + assertEquals(accountDto, responseEntity.getBody()); verify(accountsRepository).findById(anyInt()); } @@ -89,17 +89,17 @@ public class AccountControllerTest { @Test public void testInsertAccount() { - final AccountsDto accountsDto = createAccount(); - when(accountsRepository.save(any(AccountsDto.class))).thenReturn(accountsDto); + final AccountDto accountDto = createAccount(); + when(accountsRepository.save(any(AccountDto.class))).thenReturn(accountDto); - final ResponseEntity responseEntity = accountController.insertAccount(accountsDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(accountsDto, responseEntity.getBody()); - verify(accountsRepository).save(any(AccountsDto.class)); + assertEquals(accountDto, responseEntity.getBody()); + verify(accountsRepository).save(any(AccountDto.class)); } @Test @@ -114,7 +114,7 @@ public class AccountControllerTest { @Test public void testInsertAccount_bindingResultHasErrors() { - final AccountsDto definitionDto = createAccount(); + final AccountDto definitionDto = createAccount(); when(bindingResult.hasErrors()).thenReturn(true); final ResponseEntity responseEntity = accountController.insertAccount(definitionDto, bindingResult); @@ -127,31 +127,31 @@ public class AccountControllerTest { @Test public void testUpdateAccount() { - final AccountsDto existingAccount = createAccount(); + final AccountDto existingAccount = createAccount(); existingAccount.setId(1); existingAccount.setVersion(1); - final AccountsDto accountUpdate = new AccountsDto(); + final AccountDto accountUpdate = new AccountDto(); accountUpdate.setUsername("Test Update"); - final AccountsDto updatedAccount = existingAccount; + final AccountDto updatedAccount = existingAccount; updatedAccount.setUsername("Test Update"); when(accountsRepository.findById(anyInt())).thenReturn(Optional.of(existingAccount)); - when(accountsRepository.save(any(AccountsDto.class))).thenReturn(updatedAccount); + when(accountsRepository.save(any(AccountDto.class))).thenReturn(updatedAccount); - final ResponseEntity responseEntity = accountController.updateAccount(1, accountUpdate, bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, accountUpdate, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertEquals(updatedAccount, responseEntity.getBody()); verify(accountsRepository).findById(anyInt()); - verify(accountsRepository).save(any(AccountsDto.class)); + verify(accountsRepository).save(any(AccountDto.class)); } @Test public void testUpdateAccount_bindingResultHasErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -161,7 +161,7 @@ public class AccountControllerTest { @Test public void testUpdateAccount_accountsDtoIsNull() { - final ResponseEntity responseEntity = accountController.updateAccount(1, null, bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -171,7 +171,7 @@ public class AccountControllerTest { @Test public void testUpdateAccount_idIsNull() { - final ResponseEntity responseEntity = accountController.updateAccount(null, createAccount(), bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(null, createAccount(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -183,12 +183,12 @@ public class AccountControllerTest { public void testUpdateAccount_accountDoesNotExist() { when(accountsRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); - verify(accountsRepository, times(0)).save(any(AccountsDto.class)); + verify(accountsRepository, times(0)).save(any(AccountDto.class)); } @Test @@ -213,12 +213,12 @@ public class AccountControllerTest { verifyZeroInteractions(accountsRepository); } - private AccountsDto createAccount() { - final AccountsDto accountsDto = new AccountsDto(); - accountsDto.setUsername("Test username"); - accountsDto.setPassword("test password"); - accountsDto.setAdministratorStatus(true); + private AccountDto createAccount() { + final AccountDto accountDto = new AccountDto(); + accountDto.setUsername("Test username"); + accountDto.setPassword("test password"); + accountDto.setAdministratorStatus(true); - return accountsDto; + return accountDto; } } \ No newline at end of file From 30988fa94a63dfadf856de0863885c5be1b6aaff Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Feb 2019 22:40:33 -0700 Subject: [PATCH 10/10] PAN-48 Updated the sonar configuration --- pandamonium-theorem-prover/build.gradle | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/pandamonium-theorem-prover/build.gradle b/pandamonium-theorem-prover/build.gradle index 6d49c57..6690226 100644 --- a/pandamonium-theorem-prover/build.gradle +++ b/pandamonium-theorem-prover/build.gradle @@ -37,6 +37,14 @@ sonarqube { } allprojects { + sonarqube { + properties { + property "sonar.host.url", "https://sonarcloud.io" + property "sonar.projectKey", "atusa17_ptp" + property "sonar.organization", "atusa17-github" + property "sonar.login", "9dcc611cd79f175459248b053b25450e36e38463" + } + } apply plugin: 'java' apply plugin: 'jacoco' apply plugin: 'org.unbroken-dome.test-sets'