diff --git a/.travis.yml b/.travis.yml index f7ce2ec..658d4f9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,11 +30,19 @@ stages: jobs: include: - - stage: Load Database + - stage: "Load Database" script: ./gradlew loaddb - - stage: Build + - stage: "Build" script: ./gradlew build - - stage: Unit Tests + - stage: "Unit Tests" script: ./gradlew test - - stage: Integration Tests - script: ./gradlew integrationTest + - stage: "Integration Tests" + script: + - | + ./gradlew :persistence:startPersistenceApi & + APP_PID=$! + - | + ./gradlew integrationTest + - kill $APP_PID + - stage: "Sonar Analysis" + script: ./gradlew sonar diff --git a/build.gradle b/build.gradle index 6690226..cc21aa1 100644 --- a/build.gradle +++ b/build.gradle @@ -136,13 +136,6 @@ testSets { integrationTest } -compileKotlin { - kotlinOptions.jvmTarget = "1.8" -} -compileTestKotlin { - kotlinOptions.jvmTarget = "1.8" -} - wrapper { gradleVersion = '5.2.1' distributionType = Wrapper.DistributionType.ALL diff --git a/persistence/build.gradle b/persistence/build.gradle index b832e7e..811725d 100644 --- a/persistence/build.gradle +++ b/persistence/build.gradle @@ -50,3 +50,11 @@ task loadDb(type: Exec, group: 'Verification', description: 'Reloads the local d commandLine=['cmd','/c','loaddb.bat'] } } + +task startPersistenceApi(type: JavaExec, description: 'Starts the Persistence API') { + dependsOn 'loadDb' + dependsOn 'build' + classpath = files('build/libs/persistence-1.0.jar') + classpath += sourceSets.main.runtimeClasspath + main = 'edu.msudenver.tsp.persistence.PersistenceApi' +} diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 87984f0..52480e5 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -32,4 +32,18 @@ referenced_definitions json, referenced_theorems json, proven_status boolean default false, version int default 1 -) \ No newline at end of file +); +CREATE TABLE proofs +( + id INT NOT NULL AUTO_INCREMENT, + theorem_name VARCHAR(512) NOT NULL, + branch VARCHAR(512) NOT NULL, + theorem INT NOT NULL, + FOREIGN KEY fk_theorem (theorem) REFERENCES theorems (id) ON DELETE NO ACTION ON UPDATE NO ACTION, + referenced_definitions JSON, + referenced_theorems JSON, + date_added DATE, + last_updated DATE, + version INT DEFAULT 1, + PRIMARY KEY (id) +); \ No newline at end of file diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java index d442d01..42cce04 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/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.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; 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 AccountDto accountDto = createAccount(); - final AccountDto savedAccount = accountsRepository.save(accountDto); + final Account account = createAccount(); + final Account savedAccount = accountsRepository.save(account); assertNotNull(savedAccount); assertEquals(Integer.valueOf(0), savedAccount.getVersion()); @@ -33,25 +33,25 @@ public class AccountsIntegrationTest { savedAccount.setPassword("Test Update"); - final AccountDto updatedAccount = accountsRepository.save(savedAccount); + final Account updatedAccount = accountsRepository.save(savedAccount); assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); assertTrue(savedAccount.getAdministratorStatus()); assertEquals(updatedAccount.getId(), id); - accountsRepository.delete(accountDto); - final Optional deletedAccount = accountsRepository.findById(id); + accountsRepository.delete(account); + final Optional deletedAccount = accountsRepository.findById(id); assertFalse(deletedAccount.isPresent()); } - private AccountDto createAccount() { - final AccountDto accountDto = new AccountDto(); - accountDto.setUsername("Test username"); - accountDto.setPassword("test password"); - accountDto.setAdministratorStatus(true); + private Account createAccount() { + final Account account = new Account(); + account.setUsername("Test username"); + account.setPassword("test password"); + account.setAdministratorStatus(true); - return accountDto; + return account; } } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java index 93db37e..2c91789 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java @@ -1,8 +1,6 @@ package edu.msudenver.tsp.persistence; 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; @@ -23,8 +21,8 @@ public class DefinitionsIntegrationTest { @Test public void testCRUDFunctionality() { - final DefinitionDto definitionDto = createDefinition(); - final DefinitionDto savedDefinition = definitionRepository.save(definitionDto); + final Definition definition = createDefinition(); + final Definition savedDefinition = definitionRepository.save(definition); assertNotNull(savedDefinition); assertEquals(Integer.valueOf(0), savedDefinition.getVersion()); @@ -35,8 +33,8 @@ public class DefinitionsIntegrationTest { assertNotNull(savedDefinition.getDefinition()); assertNotNull(savedDefinition.getNotation()); - final List definitionsList = savedDefinition.getDefinition().getDefinitions(); - final List notationList = savedDefinition.getNotation().getNotations(); + final List definitionsList = savedDefinition.getDefinition(); + final List notationList = savedDefinition.getNotation(); assertEquals(2, definitionsList.size()); assertEquals(1, notationList.size()); @@ -46,14 +44,14 @@ public class DefinitionsIntegrationTest { savedDefinition.setName("Test Update"); - final DefinitionDto updatedDefinition = definitionRepository.save(savedDefinition); + final Definition 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(); + final List updatedDefinitionsList = updatedDefinition.getDefinition(); + final List updatedNotationsList = updatedDefinition.getNotation(); assertEquals(2, updatedDefinitionsList.size()); assertEquals(1, updatedNotationsList.size()); @@ -63,29 +61,23 @@ public class DefinitionsIntegrationTest { assertEquals(id, updatedDefinition.getId()); definitionRepository.delete(updatedDefinition); - final Optional deletedDefinition = definitionRepository.findById(id); + final Optional deletedDefinition = definitionRepository.findById(id); assertFalse(deletedDefinition.isPresent()); } - private DefinitionDto createDefinition() { + private Definition createDefinition() { final List definitionList = new ArrayList<>(); definitionList.add("Test definition 1"); definitionList.add("Test definition 2"); - 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 Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); - final DefinitionDto definitionDto = new DefinitionDto(); - definitionDto.setName("Test Name"); - definitionDto.setDefinition(definition); - definitionDto.setNotation(notation); - - return definitionDto; + return definition; } } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java new file mode 100644 index 0000000..4af0f76 --- /dev/null +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -0,0 +1,87 @@ +package edu.msudenver.tsp.persistence; + +import edu.msudenver.tsp.persistence.dto.Proof; +import edu.msudenver.tsp.persistence.repository.ProofRepository; +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.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = PersistenceTestConfig.class) +public class ProofsIntegrationTest { + @Autowired + private ProofRepository proofRepository; + + @Test + public void testCRUDFunctionality() { + final Proof proof = createProof(); + final Proof savedProof = proofRepository.save(proof); + + assertNotNull(savedProof); + assertEquals(Integer.valueOf(0), savedProof.getVersion()); + + final int id = savedProof.getId(); + + assertEquals("Test proof", savedProof.getTheoremName()); + assertEquals("Test branch", savedProof.getBranch()); + assertNotNull(savedProof.getDateCreated()); + assertNotNull(savedProof.getLastUpdated()); + assertEquals(2, savedProof.getReferencedTheorems().size()); + assertEquals(2, savedProof.getReferencedDefinitions().size()); + assertEquals("test theorem 1", savedProof.getReferencedTheorems().get(0)); + assertEquals("test theorem 2", savedProof.getReferencedTheorems().get(1)); + assertEquals("test definition 1", savedProof.getReferencedDefinitions().get(0)); + assertEquals("test definition 2", savedProof.getReferencedDefinitions().get(1)); + + savedProof.setBranch("Test Update"); + + final Proof updatedProof = proofRepository.save(savedProof); + + assertNotNull(updatedProof); + assertEquals(Integer.valueOf(0), updatedProof.getVersion()); + assertEquals("Test proof", updatedProof.getTheoremName()); + assertEquals("Test Update", updatedProof.getBranch()); + assertNotNull(updatedProof.getLastUpdated()); + assertNotNull(updatedProof.getDateCreated()); + assertNotEquals(updatedProof.getDateCreated().toInstant(), updatedProof.getLastUpdated().toInstant()); + assertEquals(2, updatedProof.getReferencedTheorems().size()); + assertEquals(2, updatedProof.getReferencedDefinitions().size()); + assertEquals("test theorem 1", updatedProof.getReferencedTheorems().get(0)); + assertEquals("test theorem 2", updatedProof.getReferencedTheorems().get(1)); + assertEquals("test definition 1", updatedProof.getReferencedDefinitions().get(0)); + assertEquals("test definition 2", updatedProof.getReferencedDefinitions().get(1)); + assertEquals(updatedProof.getId(), id); + + proofRepository.delete(proof); + final Optional deletedProof = proofRepository.findById(id); + assertFalse(deletedProof.isPresent()); + } + + private Proof createProof() { + final List referencedTheoremsList = new ArrayList<>(); + referencedTheoremsList.add("test theorem 1"); + referencedTheoremsList.add("test theorem 2"); + + final List referencedDefinitionsList = new ArrayList<>(); + referencedDefinitionsList.add("test definition 1"); + referencedDefinitionsList.add("test definition 2"); + + final Proof proof = new Proof(); + proof.setTheoremName("Test proof"); + proof.setBranch("Test branch"); + proof.setDateCreated(new Date()); + proof.setReferencedTheorems(referencedTheoremsList); + proof.setReferencedDefinitions(referencedDefinitionsList); + + return proof; + } +} diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java index a6109f2..d5c22c3 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import edu.msudenver.tsp.persistence.dto.TheoremType; import edu.msudenver.tsp.persistence.repository.TheoremRepository; import org.junit.Test; @@ -22,8 +22,8 @@ public class TheoremsIntegrationTest { @Test public void testCRUDFunctionality() { - final TheoremDto theoremDto = createTheorem(); - final TheoremDto savedTheorem = theoremRepository.save(theoremDto); + final Theorem theorem = createTheorem(); + final Theorem savedTheorem = theoremRepository.save(theorem); assertNotNull(savedTheorem); assertEquals(Integer.valueOf(0), savedTheorem.getVersion()); @@ -42,7 +42,7 @@ public class TheoremsIntegrationTest { savedTheorem.setBranch("Test Update"); - final TheoremDto updatedTheorem = theoremRepository.save(savedTheorem); + final Theorem updatedTheorem = theoremRepository.save(savedTheorem); assertNotNull(updatedTheorem); assertEquals(Integer.valueOf(0), updatedTheorem.getVersion()); @@ -57,12 +57,12 @@ public class TheoremsIntegrationTest { assertEquals("test definition 2", updatedTheorem.getReferencedDefinitions().get(1)); assertEquals(updatedTheorem.getId(), id); - theoremRepository.delete(theoremDto); - final Optional deletedTheorem = theoremRepository.findById(id); + theoremRepository.delete(theorem); + final Optional deletedTheorem = theoremRepository.findById(id); assertFalse(deletedTheorem.isPresent()); } - private TheoremDto createTheorem() { + private Theorem createTheorem() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); referencedTheoremsList.add("test theorem 2"); @@ -71,14 +71,14 @@ public class TheoremsIntegrationTest { referencedDefinitionsList.add("test definition 1"); referencedDefinitionsList.add("test definition 2"); - final TheoremDto theoremDto = new TheoremDto(); - theoremDto.setName("Test theorem"); - theoremDto.setBranch("Test branch"); - theoremDto.setProvenStatus(true); - theoremDto.setTheoremType(TheoremType.THEOREM); - theoremDto.setReferencedTheorems(referencedTheoremsList); - theoremDto.setReferencedDefinitions(referencedDefinitionsList); + final Theorem theorem = new Theorem(); + theorem.setName("Test theorem"); + theorem.setBranch("Test branch"); + theorem.setProvenStatus(true); + theorem.setTheoremType(TheoremType.THEOREM); + theorem.setReferencedTheorems(referencedTheoremsList); + theorem.setReferencedDefinitions(referencedDefinitionsList); - return theoremDto; + return theorem; } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index 2f60c56..3301f65 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/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.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -26,9 +26,9 @@ import java.util.Optional; public class AccountController { private final AccountsRepository accountsRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getListOfAccounts() { + ResponseEntity> getListOfAccounts() { LOG.info("Received request to list all accounts"); LOG.debug("Querying for list of accounts"); @@ -36,78 +36,78 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfAccounts = (List) accountsRepository.findAll(); + 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()); + LOG.debug("Successfully completed query. Query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all accounts with size of {}", listOfAccounts.size()); return new ResponseEntity<>(listOfAccounts, HttpStatus.OK); } - @GetMapping("/{id}") + @GetMapping("/id") public @ResponseBody - ResponseEntity getAccountById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for account with id " + id); + ResponseEntity getAccountById(@RequestParam("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); + LOG.debug("Querying for account with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional account = accountsRepository.findById(id); + final Optional account = accountsRepository.findById(id); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return account.map(accountDto -> { - LOG.info("Returning account with id " + id); + LOG.info("Returning account with id {}", id); return new ResponseEntity<>(accountDto, HttpStatus.OK); }).orElseGet( () -> { - LOG.warn("No account was found with id " + id); + LOG.warn("No account was found with id {}", id); return new ResponseEntity<>(HttpStatus.NOT_FOUND); } ); } - @GetMapping("/{username}") + @GetMapping("/username") public @ResponseBody - ResponseEntity getAccountByUsername(@PathVariable("username") final String username) { - LOG.info("Received request to query for account with username " + username); + ResponseEntity getAccountByUsername(@RequestParam("username") final String username) { + LOG.info("Received request to query for account with username {}", username); if (username == null) { LOG.error("ERROR: username was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Querying for account with username " + username); + LOG.debug("Querying for account with username {}", username); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional account = accountsRepository.findByUsername(username); + final Optional account = accountsRepository.findByUsername(username); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return account.map(accountDto -> { - LOG.info("Returning account with username " + username); + LOG.info("Returning account with username {}", username); return new ResponseEntity<>(accountDto, HttpStatus.OK); }).orElseGet( () -> { - LOG.warn("No account was found with username " + username); + LOG.warn("No account was found with username {}", username); return new ResponseEntity<>(HttpStatus.NOT_FOUND); } ); } - @PostMapping("/") - @Validated({AccountDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertAccount( - @Valid @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { + @PostMapping({"","/"}) + @Validated({Account.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertAccount( + @Valid @RequestBody final Account account, final BindingResult bindingResult) { LOG.info("Received request to insert a new account"); if (bindingResult.hasErrors()) { @@ -115,23 +115,23 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (accountDto == null) { + if (account == null) { LOG.error("Passed account is unprocessable"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.info("Checking for any existing users with username {}", accountDto.getUsername()); + LOG.info("Checking for any existing users with username {}", account.getUsername()); final Instant start = Instant.now(); LOG.debug("Querying for existing accounts"); - final Optional existingAccount = accountsRepository.findByUsername(accountDto.getUsername()); + final Optional existingAccount = accountsRepository.findByUsername(account.getUsername()); LOG.debug("Received response from the server: query took {} ms", Duration.between(start, Instant.now()).toMillis()); if (existingAccount.isPresent()) { - LOG.warn("An account already exists with username {}", accountDto.getUsername()); + LOG.warn("An account already exists with username {}", account.getUsername()); return new ResponseEntity<>(HttpStatus.CONFLICT); } @@ -140,19 +140,19 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final AccountDto savedAccount = accountsRepository.save(accountDto); + final Account savedAccount = accountsRepository.save(account); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); LOG.info("Returning the newly created account"); return new ResponseEntity<>(savedAccount, HttpStatus.CREATED); } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateAccount( + public @ResponseBody ResponseEntity updateAccount( @PathVariable("id") final Integer id, - @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { + @RequestBody final Account account, final BindingResult bindingResult) { LOG.info("Received request to update an account"); if (bindingResult.hasErrors()) { @@ -160,7 +160,7 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (accountDto == null) { + if (account == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -170,48 +170,48 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Checking for existence of account with id " + id); + LOG.debug("Checking for existence of account with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingAccount = accountsRepository.findById(id); + final Optional existingAccount = accountsRepository.findById(id); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); if (!existingAccount.isPresent()) { - LOG.error("No account associated with id " + id); + LOG.error("No account associated with id {}", id); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - PersistenceUtilities.copyNonNullProperties(accountDto, existingAccount.get()); + PersistenceUtilities.copyNonNullProperties(account, existingAccount.get()); existingAccount.get().setVersion(existingAccount.get().getVersion()+ 1); - LOG.info("Updating account with id " + id); - LOG.debug("Querying for account with ID " + id); + LOG.info("Updating account with id {}", id); + LOG.debug("Querying for account with id {}", id); stopWatch.start(); - final AccountDto updatedAccount = accountsRepository.save(existingAccount.get()); + final Account updatedAccount = accountsRepository.save(existingAccount.get()); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); 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); + 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); + LOG.debug("Deleting account with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -220,7 +220,7 @@ public class AccountController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index 3c8b4d1..720e5df 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Definition; import edu.msudenver.tsp.persistence.repository.DefinitionRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -24,59 +24,59 @@ import java.util.Optional; public class DefinitionController { private final DefinitionRepository definitionRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getAllDefinitions() { + ResponseEntity> getAllDefinitions() { LOG.info("Received request to list all definitions"); LOG.debug("Querying for list of all definitions"); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfDefinitions = definitionRepository.findAll(); + final List listOfDefinitions = definitionRepository.findAll(); stopWatch.stop(); - LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all definition with size " + listOfDefinitions.size()); + LOG.debug("Successfully completed query. Query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all definition with size {}", listOfDefinitions.size()); return new ResponseEntity<>(listOfDefinitions, HttpStatus.OK); } @GetMapping("/{id}") public @ResponseBody - ResponseEntity getDefinitionById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for definition with id " + id); + ResponseEntity getDefinitionById(@PathVariable("id") final Integer id) { + LOG.info("Received request to query for definition with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Querying for definition with id " + id); + LOG.debug("Querying for definition with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional definition = definitionRepository.findById(id); + final Optional definition = definitionRepository.findById(id); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return definition.map(definitionDto -> { - LOG.info("Returning definition with id " + id); + LOG.info("Returning definition with id {}", id); return new ResponseEntity<>(definitionDto, HttpStatus.OK); }).orElseGet( () -> { - LOG.warn("No definition was found with id " + id); + LOG.warn("No definition was found with id {}",id); return new ResponseEntity<>(HttpStatus.NOT_FOUND); }); } - @PostMapping("/") - @Validated({DefinitionDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertDefinition( - @Valid @RequestBody final DefinitionDto definitionDto, + @PostMapping({"","/"}) + @Validated({Definition.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertDefinition( + @Valid @RequestBody final Definition definition, final BindingResult bindingResult) { LOG.info("Received request to insert a new definition"); if (bindingResult.hasErrors()) { @@ -84,7 +84,7 @@ public class DefinitionController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (definitionDto == null) { + if (definition == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -94,19 +94,19 @@ public class DefinitionController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final DefinitionDto savedDefinition = definitionRepository.save(definitionDto); + final Definition savedDefinition = definitionRepository.save(definition); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); - LOG.info("Returning the newly created definition with id " + savedDefinition.getId()); + LOG.info("Returning the newly created definition with id {}", savedDefinition.getId()); return new ResponseEntity<>(savedDefinition, HttpStatus.CREATED); } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateDefinition( + public @ResponseBody ResponseEntity updateDefinition( @PathVariable("id") final Integer id, - @RequestBody final DefinitionDto definitionDto, final BindingResult bindingResult) { + @RequestBody final Definition definition, final BindingResult bindingResult) { LOG.info("Received request to update an account"); if (bindingResult.hasErrors()) { @@ -114,7 +114,7 @@ public class DefinitionController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (definitionDto == null) { + if (definition == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -124,48 +124,48 @@ public class DefinitionController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Checking for existence of definition with id " + id); + LOG.debug("Checking for existence of definition with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingDefinition = definitionRepository.findById(id); + final Optional existingDefinition = definitionRepository.findById(id); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); if (!existingDefinition.isPresent()) { - LOG.error("No definition associated with id " + id); + LOG.error("No definition associated with id {}", id); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - PersistenceUtilities.copyNonNullProperties(definitionDto, existingDefinition.get()); + PersistenceUtilities.copyNonNullProperties(definition, existingDefinition.get()); existingDefinition.get().setVersion(existingDefinition.get().getVersion()+ 1); - LOG.info("Updating definition with id " + id); - LOG.debug("Querying for definition with ID " + id); + LOG.info("Updating definition with id {}", id); + LOG.debug("Querying for definition with id {}", id); stopWatch.start(); - final DefinitionDto updatedDefinition = definitionRepository.save(existingDefinition.get()); + final Definition updatedDefinition = definitionRepository.save(existingDefinition.get()); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); 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); + LOG.info("Received request to delete definition with id {}", id); if (id == null) { LOG.error("Specified id is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Deleting definition with id " + id); + LOG.debug("Deleting definition with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -174,7 +174,7 @@ public class DefinitionController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java deleted file mode 100644 index b68bad1..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.persistence.controller; - -import edu.msudenver.tsp.persistence.repository.NotationRepository; -import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; - -@Component -@AllArgsConstructor -public class NotationController { - private final NotationRepository notationRepository; -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index e52b209..e60659a 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -1,11 +1,241 @@ package edu.msudenver.tsp.persistence.controller; +import edu.msudenver.tsp.persistence.dto.Proof; import edu.msudenver.tsp.persistence.repository.ProofRepository; +import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; +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.*; -@Component +import javax.validation.Valid; +import javax.validation.groups.Default; +import java.util.List; +import java.util.Optional; + +@Slf4j +@RestController @AllArgsConstructor +@RequestMapping("/proofs") public class ProofController { private final ProofRepository proofRepository; + + @GetMapping({"","/"}) + public @ResponseBody + ResponseEntity> getAllProofs() { + LOG.info("Received request to list all theorems"); + + LOG.debug("Querying for list of all theorems"); + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfProofs = proofRepository.findAll(); + + stopWatch.stop(); + + LOG.debug("Successfully completed query. Query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all theorems with size {}", listOfProofs.size()); + + return new ResponseEntity<>(listOfProofs, HttpStatus.OK); + } + + @GetMapping("/id") + public @ResponseBody + ResponseEntity getProofById(@RequestParam("id") final Integer id) { + LOG.info("Received request to query for proof with id {}", id); + if (id == null) { + LOG.error("ERROR: ID was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for proof with id {}", id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional proof = proofRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + return proof.map(proofDto -> { + LOG.info("Returning proof with id {}", id); + return new ResponseEntity<>(proofDto, HttpStatus.OK); + }).orElseGet( + () -> { + LOG.warn("No proof was found with id {}", id); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + }); + + } + + @GetMapping("/branch") + public @ResponseBody + ResponseEntity> getAllProofsByBranch(@RequestParam("branch") final String branch) { + LOG.info("Received request to query for proofs related to the {} branch of mathematics", branch); + if (branch == null) { + LOG.error("ERROR: branch was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for proofs with branch {}", branch); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfProofs = proofRepository.findByBranch(branch); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all proofs with size {}", listOfProofs.size()); + + if (listOfProofs.isEmpty()) { + LOG.warn("No proofs were found for branch {}", branch); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of proofs with branch {}", branch); + return new ResponseEntity<>(listOfProofs, HttpStatus.OK); + } + + @GetMapping("/theorem_name") + public @ResponseBody + ResponseEntity> getAllProofsByTheoremName(@PathVariable("theorem_name") final String theoremName) { + LOG.info("Received request to query for proofs of the theorem {}", theoremName); + if (theoremName == null) { + LOG.error("ERROR: theorem name was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for proofs of the theorem {}", theoremName); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfProofs = proofRepository.findByTheoremName(theoremName); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all proofs with size {}", listOfProofs.size()); + + if (listOfProofs.isEmpty()) { + LOG.warn("No proofs were found of the theorem {}", theoremName); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of proofs for the theorem {}", theoremName); + return new ResponseEntity<>(listOfProofs, HttpStatus.OK); + } + + @PostMapping({"","/"}) + @Validated({Proof.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertProof( + @Valid @RequestBody final Proof proof, + final BindingResult bindingResult) { + LOG.info("Received request to insert a new proof"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (proof == null) { + LOG.error("Passed entity is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Saving new proof"); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Proof savedProof = proofRepository.save(proof); + + stopWatch.stop(); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + LOG.info("Returning the newly created proof with id {}", savedProof.getId()); + return new ResponseEntity<>(savedProof, HttpStatus.CREATED); + } + + @PatchMapping("/{id}") + public @ResponseBody ResponseEntity updateProof( + @PathVariable("id") final Integer id, + @RequestBody final Proof proof, final BindingResult bindingResult) { + + LOG.info("Received request to update a proof"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (proof == null) { + LOG.error("Passed entity is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + if (id == null) { + LOG.error("Proof ID must be specified"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Checking for existence of proof with id {}", id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional existingProof = proofRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + if (!existingProof.isPresent()) { + LOG.error("No proof associated with id {}", id); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + PersistenceUtilities.copyNonNullProperties(proof, existingProof.get()); + existingProof.get().setVersion(existingProof.get().getVersion()+ 1); + + LOG.info("Updating proof with id {}", id); + LOG.debug("Querying for proof with ID {}", id); + + stopWatch.start(); + + final Proof updatedProof = proofRepository.save(existingProof.get()); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + return new ResponseEntity<>(updatedProof, HttpStatus.OK); + } + + @DeleteMapping("/{id}") + public @ResponseBody ResponseEntity deleteProofById(@PathVariable("id") final Integer id) { + LOG.info("Received request to delete proof with id {}", id); + if (id == null) { + LOG.error("Specified id is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Deleting proof with id {}", id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + proofRepository.deleteById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 9a0f699..ef0e760 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import edu.msudenver.tsp.persistence.repository.TheoremRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -9,9 +9,11 @@ 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; @@ -22,45 +24,45 @@ import java.util.Optional; public class TheoremController { private final TheoremRepository theoremRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getAllTheorems() { + ResponseEntity> getAllTheorems() { LOG.info("Received request to list all theorems"); LOG.debug("Querying for list of all theorems"); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findAll(); + final List listOfTheorems = theoremRepository.findAll(); stopWatch.stop(); - LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + LOG.debug("Successfully completed query. Query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all theorems with size {}", listOfTheorems.size()); return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{branch}") + @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllTheoremsByBranch(@PathVariable("branch") final String branch) { - LOG.info("Received request to query for theorems related to the " + branch + " branch of mathematics"); + ResponseEntity> getAllTheoremsByBranch(@RequestParam("branch") final String branch) { + LOG.info("Received request to query for theorems related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Querying for theorems with branch " + branch); + LOG.debug("Querying for theorems with branch {}", branch); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByBranch(branch); + final List listOfTheorems = theoremRepository.findByBranch(branch); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all theorems with size {}", listOfTheorems.size()); if (listOfTheorems.isEmpty()) { LOG.warn("No theorems were found for branch {}", branch); @@ -71,26 +73,26 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{proven_status}") + @GetMapping("/proven_status") public @ResponseBody - ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { - LOG.info("Received request to query for theorems whose proven status is " + provenStatus); + ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { + LOG.info("Received request to query for theorems whose proven status is {}", provenStatus); if (provenStatus == null) { LOG.error("ERROR: status was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Querying for theorems with proven status " + provenStatus); + LOG.debug("Querying for theorems with proven status {}", provenStatus); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByProvenStatus(provenStatus); + final List listOfTheorems = theoremRepository.findByProvenStatus(provenStatus); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all theorems with size {}", listOfTheorems.size()); if (listOfTheorems.isEmpty()) { LOG.warn("No theorems were found for proven status {}", provenStatus); @@ -101,39 +103,70 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{id}") + @GetMapping("/name") public @ResponseBody - ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for theorem with id " + id); + ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { + LOG.info("Received request to query for theorems whose name is {}", name); + if (name == null) { + LOG.error("ERROR: name was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for theorems with name {}", name); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfTheorems = theoremRepository.findByName(name); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + LOG.info("Returning list of all theorems with size {}", listOfTheorems.size()); + + if (listOfTheorems.isEmpty()) { + LOG.warn("No theorems were found with name {}", name); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of theorems with name {}", name); + return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); + } + + @GetMapping("/id") + public @ResponseBody + ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { + LOG.info("Received request to query for theorem with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Querying for theorem with id " + id); + LOG.debug("Querying for theorem with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional theorem = theoremRepository.findById(id); + final Optional theorem = theoremRepository.findById(id); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return theorem.map(theoremDto -> { - LOG.info("Returning theorem with id " + id); + LOG.info("Returning theorem with id {}", id); return new ResponseEntity<>(theoremDto, HttpStatus.OK); }).orElseGet( () -> { - LOG.warn("No theorem was found with id " + id); + LOG.warn("No theorem was found with id {}", id); return new ResponseEntity<>(HttpStatus.NOT_FOUND); }); } - @PostMapping("/") - public @ResponseBody ResponseEntity insertTheorem( - @Valid @RequestBody final TheoremDto theoremDto, + @PostMapping({"","/"}) + @Validated({Theorem.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertTheorem( + @Valid @RequestBody final Theorem theorem, final BindingResult bindingResult) { LOG.info("Received request to insert a new theorem"); if (bindingResult.hasErrors()) { @@ -141,7 +174,7 @@ public class TheoremController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (theoremDto == null) { + if (theorem == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -151,27 +184,27 @@ public class TheoremController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final TheoremDto savedTheorem = theoremRepository.save(theoremDto); + final Theorem savedTheorem = theoremRepository.save(theorem); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); - LOG.info("Returning the newly created theorem with id " + savedTheorem.getId()); + LOG.info("Returning the newly created theorem with id {}", savedTheorem.getId()); return new ResponseEntity<>(savedTheorem, HttpStatus.CREATED); } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateTheorem( + public @ResponseBody ResponseEntity updateTheorem( @PathVariable("id") final Integer id, - @RequestBody final TheoremDto theoremDto, final BindingResult bindingResult) { + @RequestBody final Theorem theorem, final BindingResult bindingResult) { - LOG.info("Received request to update an account"); + LOG.info("Received request to update a theorem"); if (bindingResult.hasErrors()) { LOG.error("Binding result is unprocessable"); return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (theoremDto == null) { + if (theorem == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -181,48 +214,48 @@ public class TheoremController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Checking for existence of theorem with id " + id); + LOG.debug("Checking for existence of theorem with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingTheorem = theoremRepository.findById(id); + final Optional existingTheorem = theoremRepository.findById(id); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); if (!existingTheorem.isPresent()) { - LOG.error("No theorem associated with id " + id); + LOG.error("No theorem associated with id {}", id); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - PersistenceUtilities.copyNonNullProperties(theoremDto, existingTheorem.get()); + PersistenceUtilities.copyNonNullProperties(theorem, existingTheorem.get()); existingTheorem.get().setVersion(existingTheorem.get().getVersion()+ 1); - LOG.info("Updating theorem with id " + id); - LOG.debug("Querying for theorem with ID " + id); + LOG.info("Updating theorem with id {}", id); + LOG.debug("Querying for theorem with id {}", id); stopWatch.start(); - final TheoremDto updatedTheorem = theoremRepository.save(existingTheorem.get()); + final Theorem updatedTheorem = theoremRepository.save(existingTheorem.get()); stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return new ResponseEntity<>(updatedTheorem, HttpStatus.OK); } @DeleteMapping("/{id}") public @ResponseBody ResponseEntity deleteTheoremById(@PathVariable("id") final Integer id) { - LOG.info("Received request to delete theorem with id " + id); + LOG.info("Received request to delete theorem with id {}", id); if (id == null) { LOG.error("Specified id is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Deleting theorem with id " + id); + LOG.debug("Deleting theorem with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -231,7 +264,7 @@ public class TheoremController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java similarity index 96% rename from persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java rename to persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java index 2f71c71..a8fa430 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java @@ -16,7 +16,7 @@ import java.util.Date; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class AccountDto extends BaseDto implements Serializable { +public class Account 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 @Column(name = "administrator_status") private boolean administratorStatus; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java index b2a26cb..b18d743 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java @@ -1,17 +1,35 @@ package edu.msudenver.tsp.persistence.dto; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.hibernate.annotations.Type; +import org.springframework.data.jpa.domain.support.AuditingEntityListener; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.EntityListeners; +import javax.persistence.Table; +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.Size; import java.io.Serializable; import java.util.List; -@Getter -@Setter -@ToString -public class Definition implements Serializable { - private List definitions; +@Entity(name = "definitions") +@Table(name = "definitions") +@EntityListeners(AuditingEntityListener.class) +@Data +@EqualsAndHashCode(callSuper = true) +public class Definition extends BaseDto implements Serializable { + @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; - private static final long serialVersionUID = -2208496232532214840L; + @NotBlank(groups = Insert.class, message = "At least one (1) definition must be specified") + @Type(type = "json") @Column(columnDefinition = "jsonb") private List definition; + + @Type(type = "json") @Column(columnDefinition = "jsonb") private List notation; + + private static final long serialVersionUID = -5314619286352932857L; + + public interface Insert {} } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java deleted file mode 100644 index 89583ad..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java +++ /dev/null @@ -1,34 +0,0 @@ -package edu.msudenver.tsp.persistence.dto; - -import lombok.Data; -import lombok.EqualsAndHashCode; -import org.hibernate.annotations.Type; -import org.springframework.data.jpa.domain.support.AuditingEntityListener; - -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.EntityListeners; -import javax.persistence.Table; -import javax.validation.constraints.NotBlank; -import javax.validation.constraints.Size; -import java.io.Serializable; - -@Entity(name = "definitions") -@Table(name = "definitions") -@EntityListeners(AuditingEntityListener.class) -@Data -@EqualsAndHashCode(callSuper = true) -public class DefinitionDto extends BaseDto implements Serializable { - @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; - - private static final long serialVersionUID = -5314619286352932857L; - - public interface Insert {} -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java deleted file mode 100644 index 3936174..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java +++ /dev/null @@ -1,16 +0,0 @@ -package edu.msudenver.tsp.persistence.dto; - -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; - -import java.io.Serializable; -import java.util.List; - -@Getter -@Setter -@ToString -public class Notation implements Serializable { - private List notations; - private static final long serialVersionUID = 2301438318932336121L; -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java deleted file mode 100644 index feabde1..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dto; - -public class NotationDto extends BaseDto { -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java new file mode 100644 index 0000000..683039b --- /dev/null +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java @@ -0,0 +1,91 @@ +package edu.msudenver.tsp.persistence.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.hibernate.annotations.Type; +import org.springframework.data.jpa.domain.support.AuditingEntityListener; + +import javax.persistence.*; +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.Date; +import java.util.List; + +@Entity(name = "proofs") +@EntityListeners(AuditingEntityListener.class) +@Data +@EqualsAndHashCode(callSuper = true) +public class Proof extends BaseDto implements Serializable { + @NotBlank(groups = Insert.class) + @Size(min = 1, max = 512, message = "The name must be at least 1 character and at most 512 characters") + @Column(name = "theorem_name") + private String theoremName; + @NotBlank(groups = Insert.class) + @Size(min = 1, max = 512, message = "The branch must be at least 1 character and at most 512 characters") + private String branch; + @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private List referencedDefinitions; + @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List referencedTheorems; + @Temporal(TemporalType.DATE) @Column(name = "date_created") private Date dateCreated; + @Temporal(TemporalType.DATE) @Column(name = "last_updated") private Date lastUpdated; + + @JsonProperty("theorem_name") + public String getTheoremName() { + return theoremName; + } + + @JsonProperty("theorem_name") + public void setTheoremName(final String theoremName) { + this.theoremName = theoremName; + } + + @JsonProperty("referenced_definitions") + public List getReferencedDefinitions() { + return referencedDefinitions; + } + + @JsonProperty("referenced_definitions") + public void setReferencedDefinitions(final List referencedDefinitions) { + this.referencedDefinitions = referencedDefinitions; + } + + @JsonProperty("referenced_theorems") + public List getReferencedTheorems() { + return referencedTheorems; + } + + @JsonProperty("referenced_theorems") + public void setReferencedTheorems(final List referencedTheorems) { + this.referencedTheorems = referencedTheorems; + } + + @JsonProperty("date_created") + public Date getDateCreated() { + return dateCreated; + } + + @JsonProperty("date_created") + public void setDateCreated(final Date dateCreated) { + this.dateCreated = dateCreated; + } + + @JsonProperty("last_updated") + public Date getLastUpdated() { + return lastUpdated; + } + + @JsonProperty("last_updated") + public void setLastUpdated(final Date lastUpdated) { + this.lastUpdated = lastUpdated; + } + + @PrePersist + public void prePersist() { + lastUpdated = new Date(); + } + + private static final long serialVersionUID = -7731220940349760402L; + + public interface Insert {} +} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java deleted file mode 100644 index 195340e..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dto; - -public class ProofDto extends BaseDto { -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java similarity index 78% rename from persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java rename to persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java index 6c48e32..14e1da1 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java @@ -19,13 +19,13 @@ import java.util.List; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class TheoremDto extends BaseDto implements Serializable { - @NotBlank @Size(min = 1, max = 512, message = "theorem name must be between 1 and 512 characters") private String name; - @NotNull @Column(name = "theorem_type") private TheoremType theoremType; - @NotNull(message = "a branch of mathematics that this theorem is associated with must be specified") private String branch; +public class Theorem extends BaseDto implements Serializable { + @NotBlank(groups = Insert.class) @Size(min = 1, max = 512, message = "theorem name must be between 1 and 512 characters") private String name; + @NotNull(groups = Insert.class) @Column(name = "theorem_type") private TheoremType theoremType; + @NotNull(groups = Insert.class, message = "a branch of mathematics that this theorem is associated with must be specified") private String branch; @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private List referencedDefinitions; @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List referencedTheorems; - @NotNull @Column(name = "proven_status") private boolean provenStatus; + @NotNull(groups = Insert.class) @Column(name = "proven_status") private boolean provenStatus; @JsonProperty("theorem_type") public TheoremType getTheoremType() { @@ -68,4 +68,7 @@ public class TheoremDto extends BaseDto implements Serializable { } private static final long serialVersionUID = 1545568391140364425L; + + public interface Insert {} + } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java index add1182..cfb0729 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java @@ -1,12 +1,12 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; import java.util.Optional; @Repository -public interface AccountsRepository extends CrudRepository { - Optional findByUsername(String username); +public interface AccountsRepository extends CrudRepository { + Optional findByUsername(String username); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java index 1cda40a..1b90a38 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java @@ -1,11 +1,11 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Definition; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository -public interface DefinitionRepository extends JpaRepository { +public interface DefinitionRepository extends JpaRepository { } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java deleted file mode 100644 index 47f0904..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java +++ /dev/null @@ -1,7 +0,0 @@ -package edu.msudenver.tsp.persistence.repository; - -import edu.msudenver.tsp.persistence.dto.BaseDto; -import org.springframework.data.repository.CrudRepository; - -public interface NotationRepository extends CrudRepository { -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java index 8466bbb..040f740 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -1,7 +1,15 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.BaseDto; -import org.springframework.data.repository.CrudRepository; +import edu.msudenver.tsp.persistence.dto.Proof; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; -public interface ProofRepository extends CrudRepository { +import java.util.List; + +@Repository +public interface ProofRepository extends JpaRepository { + + List findByBranch(String branch); + + List findByTheoremName(String name); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 75df2ee..03a17db 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -1,15 +1,17 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; import java.util.List; @Repository -public interface TheoremRepository extends JpaRepository { +public interface TheoremRepository extends JpaRepository { - List findByBranch(String branch); + List findByBranch(String branch); - List findByProvenStatus(Boolean provenStatus); + List findByProvenStatus(Boolean provenStatus); + + List findByName(String name); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java index 05a6ba9..503e2f6 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java +++ b/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.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -33,14 +33,14 @@ public class AccountControllerTest { @Test public void testGetAllAccounts() { - final AccountDto accountDto = createAccount(); - final List accountDtoList = new ArrayList<>(); - accountDtoList.add(accountDto); - accountDtoList.add(accountDto); + final Account accountDto = createAccount(); + final List accountList = new ArrayList<>(); + accountList.add(accountDto); + accountList.add(accountDto); - when(accountsRepository.findAll()).thenReturn(accountDtoList); + when(accountsRepository.findAll()).thenReturn(accountList); - final ResponseEntity> responseEntity = accountController.getListOfAccounts(); + final ResponseEntity> responseEntity = accountController.getListOfAccounts(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -52,16 +52,16 @@ public class AccountControllerTest { @Test public void testGetAccountById() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(accountDto)); + final Account account = createAccount(); + when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(account)); - 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(accountDto, responseEntity.getBody()); + assertEquals(account, responseEntity.getBody()); verify(accountsRepository).findById(anyInt()); } @@ -89,16 +89,16 @@ public class AccountControllerTest { @Test public void testGetAccountByUsername() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.ofNullable(accountDto)); + final Account account = createAccount(); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.ofNullable(account)); - final ResponseEntity responseEntity = accountController.getAccountByUsername("Test username"); + final ResponseEntity responseEntity = accountController.getAccountByUsername("Test username"); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(accountDto, responseEntity.getBody()); + assertEquals(account, responseEntity.getBody()); verify(accountsRepository).findByUsername(anyString()); } @@ -126,32 +126,32 @@ public class AccountControllerTest { @Test public void testInsertAccount() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.save(any(AccountDto.class))).thenReturn(accountDto); + final Account account = createAccount(); + when(accountsRepository.save(any(Account.class))).thenReturn(account); when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(account, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(accountDto, responseEntity.getBody()); - verify(accountsRepository).save(any(AccountDto.class)); + assertEquals(account, responseEntity.getBody()); + verify(accountsRepository).save(any(Account.class)); } @Test public void testInsertAccount_usernameAlreadyExists() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.of(accountDto)); + final Account account = createAccount(); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.of(account)); - final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(account, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.CONFLICT, responseEntity.getStatusCode()); verify(accountsRepository).findByUsername(anyString()); - verify(accountsRepository, times(0)).save(any(AccountDto.class)); + verify(accountsRepository, times(0)).save(any(Account.class)); } @Test @@ -166,10 +166,10 @@ public class AccountControllerTest { @Test public void testInsertAccount_bindingResultHasErrors() { - final AccountDto accountDto = createAccount(); + final Account account = createAccount(); when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(account, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -179,31 +179,31 @@ public class AccountControllerTest { @Test public void testUpdateAccount() { - final AccountDto existingAccount = createAccount(); + final Account existingAccount = createAccount(); existingAccount.setId(1); existingAccount.setVersion(1); - final AccountDto accountUpdate = new AccountDto(); + final Account accountUpdate = new Account(); accountUpdate.setUsername("Test Update"); - final AccountDto updatedAccount = existingAccount; + final Account updatedAccount = existingAccount; updatedAccount.setUsername("Test Update"); when(accountsRepository.findById(anyInt())).thenReturn(Optional.of(existingAccount)); - when(accountsRepository.save(any(AccountDto.class))).thenReturn(updatedAccount); + when(accountsRepository.save(any(Account.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(AccountDto.class)); + verify(accountsRepository).save(any(Account.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()); @@ -213,7 +213,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()); @@ -223,7 +223,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()); @@ -235,12 +235,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(AccountDto.class)); + verify(accountsRepository, times(0)).save(any(Account.class)); } @Test @@ -265,12 +265,12 @@ public class AccountControllerTest { verifyZeroInteractions(accountsRepository); } - private AccountDto createAccount() { - final AccountDto accountDto = new AccountDto(); - accountDto.setUsername("Test username"); - accountDto.setPassword("test password"); - accountDto.setAdministratorStatus(true); + private Account createAccount() { + final Account account = new Account(); + account.setUsername("Test username"); + account.setPassword("test password"); + account.setAdministratorStatus(true); - return accountDto; + return account; } } \ No newline at end of file diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java index e28cbb8..4b7fa77 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java @@ -1,8 +1,6 @@ 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; @@ -32,14 +30,14 @@ public class DefinitionControllerTest { @Test public void testGetAllDefinitions() { - final DefinitionDto definitionDto = createDefinition(); - final List definitionDtoList = new ArrayList<>(); - definitionDtoList.add(definitionDto); - definitionDtoList.add(definitionDto); + final Definition definitionDto = createDefinition(); + final List definitionList = new ArrayList<>(); + definitionList.add(definitionDto); + definitionList.add(definitionDto); - when(definitionRepository.findAll()).thenReturn(definitionDtoList); + when(definitionRepository.findAll()).thenReturn(definitionList); - final ResponseEntity> responseEntity = definitionController.getAllDefinitions(); + final ResponseEntity> responseEntity = definitionController.getAllDefinitions(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -51,16 +49,16 @@ public class DefinitionControllerTest { @Test public void testGetDefinitionsById() { - final DefinitionDto definitionDto = createDefinition(); - when(definitionRepository.findById(anyInt())).thenReturn(Optional.ofNullable(definitionDto)); + final Definition definition = createDefinition(); + when(definitionRepository.findById(anyInt())).thenReturn(Optional.ofNullable(definition)); - final ResponseEntity responseEntity = definitionController.getDefinitionById(1); + final ResponseEntity responseEntity = definitionController.getDefinitionById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(definitionDto, responseEntity.getBody()); + assertEquals(definition, responseEntity.getBody()); verify(definitionRepository).findById(anyInt()); } @@ -88,17 +86,17 @@ public class DefinitionControllerTest { @Test public void testInsertDefinition() { - final DefinitionDto definitionDto = createDefinition(); - when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(definitionDto); + final Definition definition = createDefinition(); + when(definitionRepository.save(any(Definition.class))).thenReturn(definition); - final ResponseEntity responseEntity = definitionController.insertDefinition(definitionDto, bindingResult); + final ResponseEntity responseEntity = definitionController.insertDefinition(definition, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(definitionDto, responseEntity.getBody()); - verify(definitionRepository).save(any(DefinitionDto.class)); + assertEquals(definition, responseEntity.getBody()); + verify(definitionRepository).save(any(Definition.class)); } @Test @@ -113,10 +111,10 @@ public class DefinitionControllerTest { @Test public void testInsertDefinition_bindingResultHasErrors() { - final DefinitionDto definitionDto = createDefinition(); + final Definition definition = createDefinition(); when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = definitionController.insertDefinition(definitionDto, bindingResult); + final ResponseEntity responseEntity = definitionController.insertDefinition(definition, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -126,31 +124,31 @@ public class DefinitionControllerTest { @Test public void testUpdateDefinition() { - final DefinitionDto existingDefinition = createDefinition(); + final Definition existingDefinition = createDefinition(); existingDefinition.setId(1); existingDefinition.setVersion(1); - final DefinitionDto definitionUpdate = new DefinitionDto(); + final Definition definitionUpdate = new Definition(); definitionUpdate.setName("Test Update"); - final DefinitionDto updatedDefinition = existingDefinition; + final Definition updatedDefinition = existingDefinition; updatedDefinition.setName("Test Update"); when(definitionRepository.findById(anyInt())).thenReturn(Optional.of(existingDefinition)); - when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(updatedDefinition); + when(definitionRepository.save(any(Definition.class))).thenReturn(updatedDefinition); - final ResponseEntity responseEntity = definitionController.updateDefinition(1, definitionUpdate, bindingResult); + 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)); + verify(definitionRepository).save(any(Definition.class)); } @Test public void testUpdateDefinition_bindingResultErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -160,7 +158,7 @@ public class DefinitionControllerTest { @Test public void testUpdateDefinition_definitionDtoIsNull() { - final ResponseEntity responseEntity = definitionController.updateDefinition(1, null, bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -170,7 +168,7 @@ public class DefinitionControllerTest { @Test public void testUpdateDefinition_idIsNull() { - final ResponseEntity responseEntity = definitionController.updateDefinition(null, createDefinition(), bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(null, createDefinition(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -182,12 +180,12 @@ public class DefinitionControllerTest { public void testUpdateDefinition_definitionDoesntExist() { when(definitionRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); + 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)); + verify(definitionRepository, times(0)).save(any(Definition.class)); } @Test @@ -212,24 +210,18 @@ public class DefinitionControllerTest { verifyZeroInteractions(definitionRepository); } - private DefinitionDto createDefinition() { + private Definition 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 Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); - final DefinitionDto definitionDto = new DefinitionDto(); - definitionDto.setName("Test Name"); - definitionDto.setDefinition(definition); - definitionDto.setNotation(notation); - - return definitionDto; + return definition; } } \ No newline at end of file diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java new file mode 100644 index 0000000..6e77bb3 --- /dev/null +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java @@ -0,0 +1,308 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.Proof; +import edu.msudenver.tsp.persistence.repository.ProofRepository; +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.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.BindingResult; + +import java.util.*; + +import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.*; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.*; + +@RunWith(MockitoJUnitRunner.class) +public class ProofControllerTest { + @Mock private ProofRepository proofRepository; + @InjectMocks private ProofController proofController; + @Mock private BindingResult bindingResult; + + @Test + public void testGetAllProofs() { + final Proof proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); + listOfProofs.add(proofDto); + listOfProofs.add(proofDto); + + when(proofRepository.findAll()).thenReturn(listOfProofs); + + final ResponseEntity> responseEntity = proofController.getAllProofs(); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof)); + } + + @Test + public void testGetAllProofsByBranch() { + final Proof proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); + listOfProofs.add(proofDto); + listOfProofs.add(proofDto); + + when(proofRepository.findByBranch(anyString())).thenReturn(listOfProofs); + + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof)); + } + + @Test + public void testGetAllProfsByBranch_nullBranch() { + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testGetAllProofsByBranch_noProofsFound() { + when(proofRepository.findByBranch(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test nonexistent branch"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + + @Test + public void testGetAllProofsByTheoremName() { + final Proof proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); + listOfProofs.add(proofDto); + listOfProofs.add(proofDto); + + when(proofRepository.findByTheoremName(anyString())).thenReturn(listOfProofs); + + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof)); + } + + @Test + public void testGetAllProfsByTheoremName_nullTheoremName() { + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testGetAllProofsByTheoremName_noProofsFound() { + when(proofRepository.findByTheoremName(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test nonexistent branch"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + + @Test + public void testGetProofById() { + final Proof proof = createProof(); + when(proofRepository.findById(anyInt())).thenReturn(Optional.ofNullable(proof)); + + final ResponseEntity responseEntity = proofController.getProofById(1); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(proof, responseEntity.getBody()); + verify(proofRepository).findById(anyInt()); + } + + @Test + public void testGetProofById_nullId() { + final ResponseEntity responseEntity = proofController.getProofById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testGetProofById_noProofFound() { + when(proofRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = proofController.getProofById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + verify(proofRepository).findById(anyInt()); + } + + @Test + public void testInsertProof() { + final Proof proof = createProof(); + when(proofRepository.save(any(Proof.class))).thenReturn(proof); + + final ResponseEntity responseEntity = proofController.insertProof(proof, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); + assertEquals(proof, responseEntity.getBody()); + verify(proofRepository).save(any(Proof.class)); + } + + @Test + public void testInsertProof_proofDtoIsNull() { + final ResponseEntity responseEntity = proofController.insertProof(null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testInsertProof_bindingResultHasErrors() { + final Proof proof = createProof(); + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = proofController.insertProof(proof, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof() { + final Proof existingProof = createProof(); + existingProof.setId(1); + existingProof.setVersion(1); + final Proof proofUpdate = new Proof(); + proofUpdate.setTheoremName("Test Update"); + final Proof updatedProof = existingProof; + updatedProof.setTheoremName("Test Update"); + when(proofRepository.findById(anyInt())).thenReturn(Optional.of(existingProof)); + when(proofRepository.save(any(Proof.class))).thenReturn(updatedProof); + + final ResponseEntity responseEntity = proofController.updateProof(1, proofUpdate, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(updatedProof, responseEntity.getBody()); + verify(proofRepository).findById(anyInt()); + verify(proofRepository).save(any(Proof.class)); + } + + @Test + public void testUpdateProof_bindingResultHasErrors() { + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof_proofDtoIsNull() { + final ResponseEntity responseEntity = proofController.updateProof(1, null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof_idIsNull() { + final ResponseEntity responseEntity = proofController.updateProof(null, createProof(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof_theoremDoesNotExist() { + when(proofRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verify(proofRepository, times(0)).save(any(Proof.class)); + } + + @Test + public void testDeleteProofById() { + doNothing().when(proofRepository).deleteById(anyInt()); + + final ResponseEntity responseEntity = proofController.deleteProofById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode()); + verify(proofRepository).deleteById(anyInt()); + } + + @Test + public void testDeleteProofById_idIsNull() { + final ResponseEntity responseEntity = proofController.deleteProofById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + private Proof createProof() { + final List referencedTheoremsList = new ArrayList<>(); + referencedTheoremsList.add("test theorem 1"); + referencedTheoremsList.add("test theorem 2"); + + final List referencedDefinitionsList = new ArrayList<>(); + referencedDefinitionsList.add("test definition 1"); + referencedDefinitionsList.add("test definition 2"); + + final Proof proof = new Proof(); + proof.setTheoremName("Test proof"); + proof.setBranch("Test branch"); + proof.setDateCreated(new Date()); + proof.setReferencedTheorems(referencedTheoremsList); + proof.setReferencedDefinitions(referencedDefinitionsList); + + return proof; + } +} \ No newline at end of file diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java index f3993cc..ffc0913 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import edu.msudenver.tsp.persistence.dto.TheoremType; import edu.msudenver.tsp.persistence.repository.TheoremRepository; import org.junit.Test; @@ -32,14 +32,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheorems() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findAll()).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheorems(); + final ResponseEntity> responseEntity = theoremController.getAllTheorems(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -51,16 +51,16 @@ public class TheoremControllerTest { @Test public void testGetTheoremById() { - final TheoremDto theoremDto = createTheorem(); - when(theoremRepository.findById(anyInt())).thenReturn(Optional.ofNullable(theoremDto)); + final Theorem theorem = createTheorem(); + when(theoremRepository.findById(anyInt())).thenReturn(Optional.ofNullable(theorem)); - final ResponseEntity responseEntity = theoremController.getTheoremById(1); + final ResponseEntity responseEntity = theoremController.getTheoremById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(theoremDto, responseEntity.getBody()); + assertEquals(theorem, responseEntity.getBody()); verify(theoremRepository).findById(anyInt()); } @@ -88,14 +88,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByBranch() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findByBranch(anyString())).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -107,7 +107,7 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByBranch_nullBranch() { - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch(null); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -119,7 +119,7 @@ public class TheoremControllerTest { public void testGetAllTheoremsByBranch_noTheoremsFound() { when(theoremRepository.findByBranch(anyString())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test nonexistent branch"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test nonexistent branch"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -128,14 +128,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByProvenStatus() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(true); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(true); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -147,7 +147,7 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByProvenStatus_nullProvenStatus() { - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(null); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -159,7 +159,47 @@ public class TheoremControllerTest { public void testGetAllTheoremsByProvenStatus_noTheoremsFound() { when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(false); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(false); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + + @Test + public void testGetAllTheoremsByName() { + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); + listOfTheorems.add(theoremDto); + listOfTheorems.add(theoremDto); + + when(theoremRepository.findByName(anyString())).thenReturn(listOfTheorems); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("Test Theorem"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(theorem -> assertEquals(theoremDto, theorem)); + } + + @Test + public void testGetAllTheoremsByName_nullName() { + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testGetAllTheoremsByName_noNameFound() { + when(theoremRepository.findByName(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("No name"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -168,17 +208,17 @@ public class TheoremControllerTest { @Test public void testInsertTheorem() { - final TheoremDto theoremDto = createTheorem(); - when(theoremRepository.save(any(TheoremDto.class))).thenReturn(theoremDto); + final Theorem theorem = createTheorem(); + when(theoremRepository.save(any(Theorem.class))).thenReturn(theorem); - final ResponseEntity responseEntity = theoremController.insertTheorem(theoremDto, bindingResult); + final ResponseEntity responseEntity = theoremController.insertTheorem(theorem, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(theoremDto, responseEntity.getBody()); - verify(theoremRepository).save(any(TheoremDto.class)); + assertEquals(theorem, responseEntity.getBody()); + verify(theoremRepository).save(any(Theorem.class)); } @Test @@ -193,10 +233,10 @@ public class TheoremControllerTest { @Test public void testInsertTheorem_bindingResultHasErrors() { - final TheoremDto theoremDto = createTheorem(); + final Theorem theorem = createTheorem(); when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = theoremController.insertTheorem(theoremDto, bindingResult); + final ResponseEntity responseEntity = theoremController.insertTheorem(theorem, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -206,31 +246,31 @@ public class TheoremControllerTest { @Test public void testUpdateTheorem() { - final TheoremDto existingTheorem = createTheorem(); + final Theorem existingTheorem = createTheorem(); existingTheorem.setId(1); existingTheorem.setVersion(1); - final TheoremDto theoremUpdate = new TheoremDto(); + final Theorem theoremUpdate = new Theorem(); theoremUpdate.setName("Test Update"); - final TheoremDto updatedTheorem = existingTheorem; + final Theorem updatedTheorem = existingTheorem; updatedTheorem.setName("Test Update"); when(theoremRepository.findById(anyInt())).thenReturn(Optional.of(existingTheorem)); - when(theoremRepository.save(any(TheoremDto.class))).thenReturn(updatedTheorem); + when(theoremRepository.save(any(Theorem.class))).thenReturn(updatedTheorem); - final ResponseEntity responseEntity = theoremController.updateTheorem(1, theoremUpdate, bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, theoremUpdate, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertEquals(updatedTheorem, responseEntity.getBody()); verify(theoremRepository).findById(anyInt()); - verify(theoremRepository).save(any(TheoremDto.class)); + verify(theoremRepository).save(any(Theorem.class)); } @Test public void testUpdateTheorem_bindingResultHasErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -240,7 +280,7 @@ public class TheoremControllerTest { @Test public void testUpdateTheorem_theoremDtoIsNull() { - final ResponseEntity responseEntity = theoremController.updateTheorem(1, null, bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -250,7 +290,7 @@ public class TheoremControllerTest { @Test public void testUpdateTheorem_idIsNull() { - final ResponseEntity responseEntity = theoremController.updateTheorem(null, createTheorem(), bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(null, createTheorem(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -262,12 +302,12 @@ public class TheoremControllerTest { public void testUpdateTheorem_theoremDoesNotExist() { when(theoremRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); - verify(theoremRepository, times(0)).save(any(TheoremDto.class)); + verify(theoremRepository, times(0)).save(any(Theorem.class)); } @Test @@ -292,7 +332,7 @@ public class TheoremControllerTest { verifyZeroInteractions(theoremRepository); } - private TheoremDto createTheorem() { + private Theorem createTheorem() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); referencedTheoremsList.add("test theorem 2"); @@ -301,14 +341,14 @@ public class TheoremControllerTest { referencedDefinitionsList.add("test definition 1"); referencedDefinitionsList.add("test definition 2"); - final TheoremDto theoremDto = new TheoremDto(); - theoremDto.setName("Test theorem"); - theoremDto.setBranch("Test branch"); - theoremDto.setProvenStatus(true); - theoremDto.setTheoremType(TheoremType.THEOREM); - theoremDto.setReferencedTheorems(referencedTheoremsList); - theoremDto.setReferencedDefinitions(referencedDefinitionsList); + final Theorem theorem = new Theorem(); + theorem.setName("Test theorem"); + theorem.setBranch("Test branch"); + theorem.setProvenStatus(true); + theorem.setTheoremType(TheoremType.THEOREM); + theorem.setReferencedTheorems(referencedTheoremsList); + theorem.setReferencedDefinitions(referencedDefinitionsList); - return theoremDto; + return theorem; } } \ No newline at end of file diff --git a/services/build.gradle b/services/build.gradle index 05efbeb..551f2b2 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -23,6 +23,7 @@ dependencies { compile group: 'org.apache.httpcomponents', name: 'fluent-hc', version: '4.5.7' compile group: 'com.google.code.gson', name: 'gson', version: '2.7' compile fileTree(dir: 'lib', include: '**/*.jar') - + + testCompile "org.springframework:spring-test:5.0.9.RELEASE" testCompile group: 'junit', name: 'junit', version: '4.12' } diff --git a/services/src/main/java/edu/msudenver/tsp/services/RestService.java b/services/src/main/java/edu/msudenver/tsp/services/RestService.java index 78f0cb9..67d2ef0 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/RestService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/RestService.java @@ -53,6 +53,11 @@ public class RestService { return send(requestFactory.put(uri, requestJson), auth, connectionTimeout, socketTimeout, type); } + Optional patch(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout) { + LOG.info("Sending PATCH {} with body: {}", uri, requestJson); + return send(requestFactory.patch(uri, requestJson), null, connectionTimeout, socketTimeout, type); + } + private Optional send(final Request request, final String auth, final Integer connectionTimeout, final Integer socketTimeout, final TypeToken type) { try { final Optional optionalHttpResponse = send(request, auth, connectionTimeout, socketTimeout); diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java index c82731a..139cd41 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java @@ -1,7 +1,8 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import lombok.Data; +import lombok.EqualsAndHashCode; import javax.persistence.Temporal; import javax.persistence.TemporalType; @@ -11,9 +12,11 @@ import javax.validation.constraints.Size; import java.io.Serializable; import java.util.Date; +@Data +@EqualsAndHashCode(callSuper = true) public class Account extends BaseDto implements Serializable { - @NotBlank(groups = AccountDto.Insert.class, message = "A username must be specified") @Size(max = 50) private String username; - @NotBlank(groups = AccountDto.Insert.class, message = "A password must be specified") @Size(max = 256) private String password; + @NotBlank(groups = edu.msudenver.tsp.persistence.dto.Account.Insert.class, message = "A username must be specified") @Size(max = 50) private String username; + @NotBlank(groups = edu.msudenver.tsp.persistence.dto.Account.Insert.class, message = "A password must be specified") @Size(max = 256) private String password; @NotNull @SerializedName("administrator_status") private boolean administratorStatus; @Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin; diff --git a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java index 726b9a8..eb4933d 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java +++ b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java @@ -22,4 +22,8 @@ public class RequestFactory { public Request put(final String uri, final String requestJson) { return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Put(uri); } + + public Request patch(final String uri, final String requestJson) { + return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Patch(uri); + } } \ No newline at end of file diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java b/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java index 0106b8b..c3f37e1 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java @@ -1,41 +1,24 @@ package edu.msudenver.tsp.services.parser; -import edu.msudenver.tsp.persistence.controller.DefinitionController; -import edu.msudenver.tsp.persistence.controller.NotationController; -import edu.msudenver.tsp.persistence.controller.ProofController; -import edu.msudenver.tsp.persistence.controller.TheoremController; -import org.springframework.beans.factory.annotation.Autowired; +import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import java.util.ArrayList; import java.util.List; +@Slf4j @Service class ParserService { - private final DefinitionController definitionController; - private final TheoremController theoremController; - private final NotationController notationController; - private final ProofController proofController; - private Node root; - - @Autowired - public ParserService(final DefinitionController definitionController, final TheoremController theoremController, - final NotationController notationController, final ProofController proofController) { - this.definitionController = definitionController; - this.theoremController = theoremController; - this.notationController = notationController; - this.proofController = proofController; - } public boolean parseUserInput(final String userInput) { try { final Node tree = parseRawInput(userInput); - final List statements = retrieveStatements(tree); + retrieveStatements(tree); return true; } catch(final Exception e) { - e.printStackTrace(); + LOG.error(e.getMessage()); } return false; } @@ -44,7 +27,7 @@ class ParserService { { input = input.toLowerCase(); - root = new Node(input, null); + final Node root = new Node(input, null); if(input.equals("")) { diff --git a/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java b/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java deleted file mode 100644 index 3a4aa63..0000000 --- a/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java +++ /dev/null @@ -1,16 +0,0 @@ -package edu.msudenver.tsp.services.scoring; - -import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.Configuration; - -@Configuration -@ComponentScan -//@PropertySource("classpath:development.properties") -public class ScoringConfig { - - @Bean - public TheoremScoringService theoremScoringService() { - return new TheoremScoringService(); - } -} diff --git a/services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java b/services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java deleted file mode 100644 index 6dad106..0000000 --- a/services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java +++ /dev/null @@ -1,8 +0,0 @@ -package edu.msudenver.tsp.services.scoring; - -import org.springframework.stereotype.Service; - -@Service -class TheoremScoringService { - -} diff --git a/services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java b/services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java new file mode 100644 index 0000000..1f21b28 --- /dev/null +++ b/services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java @@ -0,0 +1,66 @@ +package edu.msudenver.tsp.services.factory; + +import org.apache.http.client.fluent.Request; +import org.junit.Test; + +import static org.junit.Assert.assertNotNull; + +public class RequestFactoryTest { + private final RequestFactory requestFactory = new RequestFactory(); + + @Test + public void testDelete() { + final Request testRequest = requestFactory.delete("testUri"); + + assertNotNull(testRequest); + } + + @Test + public void testGet() { + final Request testRequest = requestFactory.get("testUri"); + + assertNotNull(testRequest); + } + + @Test + public void testPost() { + final Request testRequest = requestFactory.post("testUri", "testJson"); + + assertNotNull(testRequest); + } + + @Test + public void testPost_blankRequestJson() { + final Request testRequest = requestFactory.post("testUri", null); + + assertNotNull(testRequest); + } + + @Test + public void testPut() { + final Request testRequest = requestFactory.put("testUri", "testJson"); + + assertNotNull(testRequest); + } + + @Test + public void testPut_blankRequestJson() { + final Request testRequest = requestFactory.put("testUri", null); + + assertNotNull(testRequest); + } + + @Test + public void testPatch() { + final Request testRequest = requestFactory.patch("testUri", "testJson"); + + assertNotNull(testRequest); + } + + @Test + public void testPatch_blankRequestJson() { + final Request testRequest = requestFactory.patch("testUri", null); + + assertNotNull(testRequest); + } +} \ No newline at end of file diff --git a/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java index 829a02a..fdfecf0 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java @@ -1,9 +1,9 @@ package edu.msudenver.tsp.services.parser; -import edu.msudenver.tsp.persistence.controller.DefinitionController; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; import java.util.ArrayList; @@ -12,18 +12,14 @@ import java.util.List; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ParserServiceTest { - private final DefinitionController definitionControllerMock = mock(DefinitionController.class); - private final ParserService mockParserService = mock(ParserService.class); + @Mock private ParserService mockParserService; - @InjectMocks - private final ParserService parserService = new ParserService(definitionControllerMock, null, - null, null); + @InjectMocks private ParserService parserService; @Test public void testEmptyStringEqualsEmptyString() { diff --git a/services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java deleted file mode 100644 index f116fb6..0000000 --- a/services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java +++ /dev/null @@ -1,16 +0,0 @@ -package edu.msudenver.tsp.services.scoring; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.runners.MockitoJUnitRunner; - -import static org.junit.Assert.assertEquals; - -@RunWith(MockitoJUnitRunner.class) -public class TheoremScoringServiceTest { - - @Test - public void test() { - assertEquals(3,3); - } -} \ No newline at end of file