Dark-Alex-17/ptp
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #23 from atusa17/PAN-52

Browse Source 
Pan 52
This commit is contained in:
dantanxiaotian
2019-03-20 16:20:03 -06:00
committed by GitHub
parent fe0912fc24 7b2d5c45a6
commit b15ef858b0
40 changed files with 1273 additions and 504 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.travis.yml
+13 -5
View File
@@ -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
build.gradle
-7
View File
@@ -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
persistence/build.gradle
+8
View File
@@ -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'
}
persistence/scripts/mysql/local_development.sql
+15 -1
View File
@@ -32,4 +32,18 @@ referenced_definitions json,
referenced_theorems json,
proven_status boolean default false,
version int default 1
)
);
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)
);
persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java
+12 -12
View File
@@ -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<AccountDto> deletedAccount = accountsRepository.findById(id);
accountsRepository.delete(account);
final Optional<Account> 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;
}
}
persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java
+14 -22
View File
@@ -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<String> definitionsList = savedDefinition.getDefinition().getDefinitions();
final List<String> notationList = savedDefinition.getNotation().getNotations();
final List<String> definitionsList = savedDefinition.getDefinition();
final List<String> 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<String> updatedDefinitionsList = updatedDefinition.getDefinition().getDefinitions();
final List<String> updatedNotationsList = updatedDefinition.getNotation().getNotations();
final List<String> updatedDefinitionsList = updatedDefinition.getDefinition();
final List<String> 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<DefinitionDto> deletedDefinition = definitionRepository.findById(id);
final Optional<Definition> deletedDefinition = definitionRepository.findById(id);
assertFalse(deletedDefinition.isPresent());
}
private DefinitionDto createDefinition() {
private Definition createDefinition() {
final List<String> definitionList = new ArrayList<>();
definitionList.add("Test definition 1");
definitionList.add("Test definition 2");
final Definition definition = new Definition();
definition.setDefinitions(definitionList);
final List<String> notationList = new ArrayList<>();
notationList.add("\\testLaTeX");
final Notation notation = new Notation();
notation.setNotations(notationList);
final 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;
}
}
persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java
+87
View File
@@ -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<Proof> deletedProof = proofRepository.findById(id);
assertFalse(deletedProof.isPresent());
}
private Proof createProof() {
final List<String> referencedTheoremsList = new ArrayList<>();
referencedTheoremsList.add("test theorem 1");
referencedTheoremsList.add("test theorem 2");
final List<String> 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;
}
}
persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java
+15 -15
View File
@@ -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<TheoremDto> deletedTheorem = theoremRepository.findById(id);
theoremRepository.delete(theorem);
final Optional<Theorem> deletedTheorem = theoremRepository.findById(id);
assertFalse(deletedTheorem.isPresent());
}
private TheoremDto createTheorem() {
private Theorem createTheorem() {
final List<String> 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;
}
}
persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java
+47 -47
View File
@@ -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<Iterable<AccountDto>> getListOfAccounts() {
ResponseEntity<Iterable<Account>> 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<AccountDto> listOfAccounts = (List<AccountDto>) accountsRepository.findAll();
final List<Account> listOfAccounts = (List<Account>) 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<AccountDto> getAccountById(@PathVariable("id") final Integer id) {
LOG.info("Received request to query for account with id " + id);
ResponseEntity<Account> 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<AccountDto> account = accountsRepository.findById(id);
final Optional<Account> 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<AccountDto> getAccountByUsername(@PathVariable("username") final String username) {
LOG.info("Received request to query for account with username " + username);
ResponseEntity<Account> 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<AccountDto> account = accountsRepository.findByUsername(username);
final Optional<Account> 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<AccountDto> insertAccount(
@Valid @RequestBody final AccountDto accountDto, final BindingResult bindingResult) {
@PostMapping({"","/"})
@Validated({Account.Insert.class, Default.class})
public @ResponseBody ResponseEntity<Account> 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<AccountDto> existingAccount = accountsRepository.findByUsername(accountDto.getUsername());
final Optional<Account> 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<AccountDto> updateAccount(
public @ResponseBody ResponseEntity<Account> 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<AccountDto> existingAccount = accountsRepository.findById(id);
final Optional<Account> 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<Void> 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);
}
persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java
+36 -36
View File
@@ -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<Iterable<DefinitionDto>> getAllDefinitions() {
ResponseEntity<Iterable<Definition>> 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<DefinitionDto> listOfDefinitions = definitionRepository.findAll();
final List<Definition> 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<DefinitionDto> getDefinitionById(@PathVariable("id") final Integer id) {
LOG.info("Received request to query for definition with id " + id);
ResponseEntity<Definition> 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<DefinitionDto> definition = definitionRepository.findById(id);
final Optional<Definition> 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<DefinitionDto> insertDefinition(
@Valid @RequestBody final DefinitionDto definitionDto,
@PostMapping({"","/"})
@Validated({Definition.Insert.class, Default.class})
public @ResponseBody ResponseEntity<Definition> 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<DefinitionDto> updateDefinition(
public @ResponseBody ResponseEntity<Definition> 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<DefinitionDto> existingDefinition = definitionRepository.findById(id);
final Optional<Definition> 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<Void> 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);
}
persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java
-11
View File
@@ -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;
}
persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java
+232 -2
View File
@@ -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<Iterable<Proof>> 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<Proof> 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<Proof> 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> 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<List<Proof>> 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<Proof> 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<List<Proof>> 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<Proof> 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<Proof> 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<Proof> 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<Proof> 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<Void> 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);
}
}
persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java
+84 -51
View File
@@ -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<Iterable<TheoremDto>> getAllTheorems() {
ResponseEntity<Iterable<Theorem>> 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<TheoremDto> listOfTheorems = theoremRepository.findAll();
final List<Theorem> 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<List<TheoremDto>> getAllTheoremsByBranch(@PathVariable("branch") final String branch) {
LOG.info("Received request to query for theorems related to the " + branch + " branch of mathematics");
ResponseEntity<List<Theorem>> 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<TheoremDto> listOfTheorems = theoremRepository.findByBranch(branch);
final List<Theorem> 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<List<TheoremDto>> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) {
LOG.info("Received request to query for theorems whose proven status is " + provenStatus);
ResponseEntity<List<Theorem>> 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<TheoremDto> listOfTheorems = theoremRepository.findByProvenStatus(provenStatus);
final List<Theorem> 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<TheoremDto> getTheoremById(@PathVariable("id") final Integer id) {
LOG.info("Received request to query for theorem with id " + id);
ResponseEntity<List<Theorem>> 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<Theorem> 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<Theorem> 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<TheoremDto> theorem = theoremRepository.findById(id);
final Optional<Theorem> 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<TheoremDto> insertTheorem(
@Valid @RequestBody final TheoremDto theoremDto,
@PostMapping({"","/"})
@Validated({Theorem.Insert.class, Default.class})
public @ResponseBody ResponseEntity<Theorem> 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<TheoremDto> updateTheorem(
public @ResponseBody ResponseEntity<Theorem> 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<TheoremDto> existingTheorem = theoremRepository.findById(id);
final Optional<Theorem> 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<Void> 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);
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java → persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java
+1 -1
View File
@@ -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;
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java
+27 -9
View File
@@ -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<String> 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<String> definition;
@Type(type = "json") @Column(columnDefinition = "jsonb") private List<String> notation;
private static final long serialVersionUID = -5314619286352932857L;
public interface Insert {}
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java
-34
View File
@@ -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 {}
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java
-16
View File
@@ -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<String> notations;
private static final long serialVersionUID = 2301438318932336121L;
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java
-4
View File
@@ -1,4 +0,0 @@
package edu.msudenver.tsp.persistence.dto;
public class NotationDto extends BaseDto {
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java
+91
View File
@@ -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<String> referencedDefinitions;
@Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List<String> 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<String> getReferencedDefinitions() {
return referencedDefinitions;
}
@JsonProperty("referenced_definitions")
public void setReferencedDefinitions(final List<String> referencedDefinitions) {
this.referencedDefinitions = referencedDefinitions;
}
@JsonProperty("referenced_theorems")
public List<String> getReferencedTheorems() {
return referencedTheorems;
}
@JsonProperty("referenced_theorems")
public void setReferencedTheorems(final List<String> 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 {}
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java
-4
View File
@@ -1,4 +0,0 @@
package edu.msudenver.tsp.persistence.dto;
public class ProofDto extends BaseDto {
}
persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java → persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java
+8 -5
View File
@@ -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<String> referencedDefinitions;
@Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List<String> 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 {}
}
persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java
+3 -3
View File
@@ -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<AccountDto, Integer> {
Optional<AccountDto> findByUsername(String username);
public interface AccountsRepository extends CrudRepository<Account, Integer> {
Optional<Account> findByUsername(String username);
}
persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java
+2 -2
View File
@@ -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<DefinitionDto, Integer> {
public interface DefinitionRepository extends JpaRepository<Definition, Integer> {
}
persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java
-7
View File
@@ -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<BaseDto, Long> {
}
persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java
+11 -3
View File
@@ -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<BaseDto, Long> {
import java.util.List;
@Repository
public interface ProofRepository extends JpaRepository<Proof, Integer> {
List<Proof> findByBranch(String branch);
List<Proof> findByTheoremName(String name);
}
persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java
+6 -4
View File
@@ -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<TheoremDto, Integer> {
public interface TheoremRepository extends JpaRepository<Theorem, Integer> {
List<TheoremDto> findByBranch(String branch);
List<Theorem> findByBranch(String branch);
List<TheoremDto> findByProvenStatus(Boolean provenStatus);
List<Theorem> findByProvenStatus(Boolean provenStatus);
List<Theorem> findByName(String name);
}
persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java
+43 -43
View File
@@ -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<AccountDto> accountDtoList = new ArrayList<>();
accountDtoList.add(accountDto);
accountDtoList.add(accountDto);
final Account accountDto = createAccount();
final List<Account> accountList = new ArrayList<>();
accountList.add(accountDto);
accountList.add(accountDto);
when(accountsRepository.findAll()).thenReturn(accountDtoList);
when(accountsRepository.findAll()).thenReturn(accountList);
final ResponseEntity<Iterable<AccountDto>> responseEntity = accountController.getListOfAccounts();
final ResponseEntity<Iterable<Account>> 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<AccountDto> responseEntity = accountController.getAccountById(1);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.getAccountByUsername("Test username");
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.insertAccount(accountDto, bindingResult);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.insertAccount(accountDto, bindingResult);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.updateAccount(1, accountUpdate, bindingResult);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.updateAccount(1, createAccount(), bindingResult);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.updateAccount(1, null, bindingResult);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.updateAccount(null, createAccount(), bindingResult);
final ResponseEntity<Account> 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<AccountDto> responseEntity = accountController.updateAccount(1, createAccount(), bindingResult);
final ResponseEntity<Account> 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;
}
}
persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java
+34 -42
View File
@@ -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<DefinitionDto> definitionDtoList = new ArrayList<>();
definitionDtoList.add(definitionDto);
definitionDtoList.add(definitionDto);
final Definition definitionDto = createDefinition();
final List<Definition> definitionList = new ArrayList<>();
definitionList.add(definitionDto);
definitionList.add(definitionDto);
when(definitionRepository.findAll()).thenReturn(definitionDtoList);
when(definitionRepository.findAll()).thenReturn(definitionList);
final ResponseEntity<Iterable<DefinitionDto>> responseEntity = definitionController.getAllDefinitions();
final ResponseEntity<Iterable<Definition>> 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<DefinitionDto> responseEntity = definitionController.getDefinitionById(1);
final ResponseEntity<Definition> 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<DefinitionDto> responseEntity = definitionController.insertDefinition(definitionDto, bindingResult);
final ResponseEntity<Definition> 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<DefinitionDto> responseEntity = definitionController.updateDefinition(1, definitionUpdate, bindingResult);
final ResponseEntity<Definition> 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<DefinitionDto> responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult);
final ResponseEntity<Definition> 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<DefinitionDto> responseEntity = definitionController.updateDefinition(1, null, bindingResult);
final ResponseEntity<Definition> 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<DefinitionDto> responseEntity = definitionController.updateDefinition(null, createDefinition(), bindingResult);
final ResponseEntity<Definition> 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<DefinitionDto> responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult);
final ResponseEntity<Definition> 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<String> definitionList = new ArrayList<>();
definitionList.add("Test definition 1");
final Definition definition = new Definition();
definition.setDefinitions(definitionList);
final List<String> notationList = new ArrayList<>();
notationList.add("\\testLaTeX");
final Notation notation = new Notation();
notation.setNotations(notationList);
final 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;
}
}
persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java
+308
View File
@@ -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<Proof> listOfProofs = new ArrayList<>();
listOfProofs.add(proofDto);
listOfProofs.add(proofDto);
when(proofRepository.findAll()).thenReturn(listOfProofs);
final ResponseEntity<Iterable<Proof>> 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<Proof> listOfProofs = new ArrayList<>();
listOfProofs.add(proofDto);
listOfProofs.add(proofDto);
when(proofRepository.findByBranch(anyString())).thenReturn(listOfProofs);
final ResponseEntity<List<Proof>> 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<List<Proof>> 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<List<Proof>> 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<Proof> listOfProofs = new ArrayList<>();
listOfProofs.add(proofDto);
listOfProofs.add(proofDto);
when(proofRepository.findByTheoremName(anyString())).thenReturn(listOfProofs);
final ResponseEntity<List<Proof>> 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<List<Proof>> 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<List<Proof>> 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<Proof> 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<Proof> 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<Proof> 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<Proof> 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<Proof> 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<Proof> 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<Proof> 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<String> referencedTheoremsList = new ArrayList<>();
referencedTheoremsList.add("test theorem 1");
referencedTheoremsList.add("test theorem 2");
final List<String> 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;
}
}
persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java
+85 -45
View File
@@ -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<TheoremDto> listOfTheorems = new ArrayList<>();
final Theorem theoremDto = createTheorem();
final List<Theorem> listOfTheorems = new ArrayList<>();
listOfTheorems.add(theoremDto);
listOfTheorems.add(theoremDto);
when(theoremRepository.findAll()).thenReturn(listOfTheorems);
final ResponseEntity<Iterable<TheoremDto>> responseEntity = theoremController.getAllTheorems();
final ResponseEntity<Iterable<Theorem>> 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<TheoremDto> responseEntity = theoremController.getTheoremById(1);
final ResponseEntity<Theorem> 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<TheoremDto> listOfTheorems = new ArrayList<>();
final Theorem theoremDto = createTheorem();
final List<Theorem> listOfTheorems = new ArrayList<>();
listOfTheorems.add(theoremDto);
listOfTheorems.add(theoremDto);
when(theoremRepository.findByBranch(anyString())).thenReturn(listOfTheorems);
final ResponseEntity<List<TheoremDto>> responseEntity = theoremController.getAllTheoremsByBranch("test");
final ResponseEntity<List<Theorem>> 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<List<TheoremDto>> responseEntity = theoremController.getAllTheoremsByBranch(null);
final ResponseEntity<List<Theorem>> 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<List<TheoremDto>> responseEntity = theoremController.getAllTheoremsByBranch("test nonexistent branch");
final ResponseEntity<List<Theorem>> 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<TheoremDto> listOfTheorems = new ArrayList<>();
final Theorem theoremDto = createTheorem();
final List<Theorem> listOfTheorems = new ArrayList<>();
listOfTheorems.add(theoremDto);
listOfTheorems.add(theoremDto);
when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(listOfTheorems);
final ResponseEntity<List<TheoremDto>> responseEntity = theoremController.getAllTheoremsByProvenStatus(true);
final ResponseEntity<List<Theorem>> 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<List<TheoremDto>> responseEntity = theoremController.getAllTheoremsByProvenStatus(null);
final ResponseEntity<List<Theorem>> 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<List<TheoremDto>> responseEntity = theoremController.getAllTheoremsByProvenStatus(false);
final ResponseEntity<List<Theorem>> 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<Theorem> listOfTheorems = new ArrayList<>();
listOfTheorems.add(theoremDto);
listOfTheorems.add(theoremDto);
when(theoremRepository.findByName(anyString())).thenReturn(listOfTheorems);
final ResponseEntity<List<Theorem>> 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<List<Theorem>> 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<List<Theorem>> 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<TheoremDto> responseEntity = theoremController.insertTheorem(theoremDto, bindingResult);
final ResponseEntity<Theorem> 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<TheoremDto> responseEntity = theoremController.updateTheorem(1, theoremUpdate, bindingResult);
final ResponseEntity<Theorem> 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<TheoremDto> responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult);
final ResponseEntity<Theorem> 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<TheoremDto> responseEntity = theoremController.updateTheorem(1, null, bindingResult);
final ResponseEntity<Theorem> 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<TheoremDto> responseEntity = theoremController.updateTheorem(null, createTheorem(), bindingResult);
final ResponseEntity<Theorem> 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<TheoremDto> responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult);
final ResponseEntity<Theorem> 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<String> 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;
}
}
services/build.gradle
+2 -1
View File
@@ -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'
}
services/src/main/java/edu/msudenver/tsp/services/RestService.java
+5
View File
@@ -53,6 +53,11 @@ public class RestService {
return send(requestFactory.put(uri, requestJson), auth, connectionTimeout, socketTimeout, type);
}
<T> Optional<T> patch(final String uri, final String requestJson, final TypeToken<T> 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 <T> Optional<T> send(final Request request, final String auth, final Integer connectionTimeout, final Integer socketTimeout, final TypeToken<T> type) {
try {
final Optional<HttpResponse> optionalHttpResponse = send(request, auth, connectionTimeout, socketTimeout);
services/src/main/java/edu/msudenver/tsp/services/dto/Account.java
+6 -3
View File
@@ -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;
services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java
+4
View File
@@ -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);
}
}
services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java
+5 -22
View File
@@ -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<String> 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(""))
{
services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java
-16
View File
@@ -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();
}
}
services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java
-8
View File
@@ -1,8 +0,0 @@
package edu.msudenver.tsp.services.scoring;
import org.springframework.stereotype.Service;
@Service
class TheoremScoringService {
}
services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java
+66
View File
@@ -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);
}
}
services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java
+3 -7
View File
@@ -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() {
services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java
-16
View File
@@ -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);
}
}