From d8422f67d72fe424dd0683e8cc6087dc4b40957b Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 16:25:49 -0700 Subject: [PATCH 01/34] TEST --- .../main/java/edu/msudenver/tsp/persistence/PersistenceApi.java | 1 + 1 file changed, 1 insertion(+) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java index 39a3f11..f309965 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java @@ -105,5 +105,6 @@ public class PersistenceApi { properties.setProperty("hibernate.id.new_generator_mappings","false"); return properties; + } } From f6de79a3d40ff249e304c293e4fbe081ee072906 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 18:25:46 -0700 Subject: [PATCH 02/34] PAN-50 Added the creation of the theorems table to the local_development.sql --- persistence/scripts/mysql/local_development.sql | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 1f885cc..87984f0 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -22,4 +22,14 @@ name varchar(200) not null, definition json not null, notation json, version int default 1 -); \ No newline at end of file +); +create table theorems ( +id int not null auto_increment primary key unique, +name varchar(512) not null, +theorem_type enum ('THEOREM', 'PROPOSITION', 'LEMMA', 'COROLLARY') not null, +branch varchar(512) not null, +referenced_definitions json, +referenced_theorems json, +proven_status boolean default false, +version int default 1 +) \ No newline at end of file From 9d7673ebf2b1716bd2e0d760a85ff3b68155ce08 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 18:36:14 -0700 Subject: [PATCH 03/34] PAN-50 Created the DTO for theorems --- .../msudenver/tsp/persistence/dto/TheoremDto.java | 15 +++++++++++++++ .../tsp/persistence/dto/TheoremType.java | 5 +++++ 2 files changed, 20 insertions(+) create mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremType.java diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index 0761432..36be47a 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -1,4 +1,19 @@ package edu.msudenver.tsp.persistence.dto; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.hibernate.annotations.Type; + +import javax.persistence.Column; +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import java.util.List; + public class TheoremDto extends BaseDto { + @NotBlank @Size(min = 1, max = 512, message = "theorem name must be between 1 and 512 characters") private String name; + @NotNull @JsonProperty("theorem_type") private TheoremType theoremType; + @NotNull private String branch; + @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_definitions") private List referencedDefinitions; + @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_theorems") private List referencedTheorems; + @NotNull @JsonProperty("proven_status") private boolean provenStatus; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremType.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremType.java new file mode 100644 index 0000000..c69b4e7 --- /dev/null +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremType.java @@ -0,0 +1,5 @@ +package edu.msudenver.tsp.persistence.dto; + +public enum TheoremType { + THEOREM, PROPOSITION, LEMMA, COROLLARY +} From ca8dc5c5df7f3fb9bf13761b17e18e32b6a5a75e Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 18:38:29 -0700 Subject: [PATCH 04/34] PAN-50 Created the DTO for theorems --- .../tsp/persistence/dto/TheoremDto.java | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index 36be47a..75c22cc 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -1,19 +1,33 @@ 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.Column; +import javax.persistence.Entity; +import javax.persistence.EntityListeners; +import javax.persistence.Table; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; +import java.io.Serializable; import java.util.List; -public class TheoremDto extends BaseDto { +@Entity(name = "theorems") +@Table(name = "theorems") +@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 @JsonProperty("theorem_type") private TheoremType theoremType; @NotNull private String branch; @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_definitions") private List referencedDefinitions; @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_theorems") private List referencedTheorems; @NotNull @JsonProperty("proven_status") private boolean provenStatus; + + public static final long serialVersionUID = 1545568391140364425L; } From 4999227e1bebd80ff2411b045016a91b75acac74 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 18:43:16 -0700 Subject: [PATCH 05/34] PAN-50 Created the TheoremRepository --- .../tsp/persistence/repository/TheoremRepository.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index c4237ce..1bf2e50 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -1,7 +1,9 @@ package edu.msudenver.tsp.persistence.repository; import edu.msudenver.tsp.persistence.dto.BaseDto; -import org.springframework.data.repository.CrudRepository; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; -public interface TheoremRepository extends CrudRepository { +@Repository +public interface TheoremRepository extends JpaRepository { } From 3762c10359bde48d747a517a722f69ff4cdd058d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 19:03:48 -0700 Subject: [PATCH 06/34] PAN-50 Fixed the .travis.yml file --- .travis.yml | 3 +- .../controller/DefinitionController.java | 2 +- .../controller/TheoremController.java | 37 +++++++++++++++++-- .../tsp/persistence/dto/TheoremDto.java | 4 +- .../repository/TheoremRepository.java | 4 +- 5 files changed, 39 insertions(+), 11 deletions(-) diff --git a/.travis.yml b/.travis.yml index 8faab01..f7ce2ec 100644 --- a/.travis.yml +++ b/.travis.yml @@ -13,8 +13,7 @@ addons: - mysql-client before_install: - - chmod +x pandamonium-theorem-prover/gradlew - - cd pandamonium-theorem-prover + - chmod +x gradlew before_script: - mysql_upgrade --force -uroot diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index 3b788a5..e93a5be 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -20,7 +20,7 @@ import java.util.Optional; @Slf4j @RestController @AllArgsConstructor -@RequestMapping(path = "/definitions/") +@RequestMapping(path = "/definitions") public class DefinitionController { private final DefinitionRepository definitionRepository; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 080ed54..dafd34f 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -1,11 +1,42 @@ package edu.msudenver.tsp.persistence.controller; +import edu.msudenver.tsp.persistence.dto.TheoremDto; import edu.msudenver.tsp.persistence.repository.TheoremRepository; 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.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.ResponseBody; +import org.springframework.web.bind.annotation.RestController; -@Component +import java.util.List; + +@Slf4j +@RestController @AllArgsConstructor +@RequestMapping(path = "/theorems") public class TheoremController { - final private TheoremRepository theoremRepository; + private final TheoremRepository theoremRepository; + + @GetMapping("/") + public @ResponseBody + ResponseEntity> getAllTheorems() { + LOG.info("Received request to list all theorems"); + + LOG.debug("Querying for list of all theorems"); + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfTheorems = theoremRepository.findAll(); + + 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()); + + return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); + } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index 75c22cc..32e0bc4 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -9,7 +9,6 @@ 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.NotNull; import javax.validation.constraints.Size; @@ -17,14 +16,13 @@ import java.io.Serializable; import java.util.List; @Entity(name = "theorems") -@Table(name = "theorems") @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 @JsonProperty("theorem_type") private TheoremType theoremType; - @NotNull private String branch; + @NotNull(message = "a branch of mathematics that this theorem is associated with must be specified") private String branch; @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_definitions") private List referencedDefinitions; @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_theorems") private List referencedTheorems; @NotNull @JsonProperty("proven_status") private boolean provenStatus; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 1bf2e50..14f6b45 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -1,9 +1,9 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.BaseDto; +import edu.msudenver.tsp.persistence.dto.TheoremDto; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository -public interface TheoremRepository extends JpaRepository { +public interface TheoremRepository extends JpaRepository { } From a0753903b253111e4f0885946be65b37e192c5cf Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 21:12:07 -0700 Subject: [PATCH 07/34] PAN-50 Updated the DTO's --- .../edu/msudenver/tsp/persistence/dto/AccountDto.java | 5 ++--- .../edu/msudenver/tsp/persistence/dto/TheoremDto.java | 9 ++++----- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java index 717bc64..3c15eee 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java @@ -1,6 +1,5 @@ package edu.msudenver.tsp.persistence.dto; -import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Data; import lombok.EqualsAndHashCode; import org.springframework.data.jpa.domain.support.AuditingEntityListener; @@ -22,8 +21,8 @@ import java.util.Date; public class AccountDto extends BaseDto implements Serializable { @NotBlank(groups = Insert.class, message = "A username must be specified") @Size(max = 50) private String username; @NotBlank(groups = Insert.class, message = "A password must be specified") @Size(max = 256) private String password; - @NotNull @JsonProperty("administrator_status") private boolean administratorStatus; - @Temporal(TemporalType.DATE) @JsonProperty("last_login") private Date lastLogin; + @NotNull private boolean administrator_status; + @Temporal(TemporalType.DATE) private Date last_login; public static final long serialVersionUID = 7095627971593953734L; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index 32e0bc4..4369173 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -1,6 +1,5 @@ package edu.msudenver.tsp.persistence.dto; -import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Data; import lombok.EqualsAndHashCode; import org.hibernate.annotations.Type; @@ -21,11 +20,11 @@ import java.util.List; @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 @JsonProperty("theorem_type") private TheoremType theoremType; + @NotNull private TheoremType theorem_type; @NotNull(message = "a branch of mathematics that this theorem is associated with must be specified") private String branch; - @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_definitions") private List referencedDefinitions; - @Type(type = "json") @Column(columnDefinition = "jsonb") @JsonProperty("referenced_theorems") private List referencedTheorems; - @NotNull @JsonProperty("proven_status") private boolean provenStatus; + @Type(type = "json") @Column(columnDefinition = "jsonb") private List referenced_definitions; + @Type(type = "json") @Column(columnDefinition = "jsonb") private List referenced_theorems; + @NotNull private boolean proven_status; public static final long serialVersionUID = 1545568391140364425L; } From d6b18c2279d98b80ca342ffb2d8ffb5a6ac32e11 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 7 Mar 2019 10:27:51 -0700 Subject: [PATCH 08/34] PAN-50 Began creation of the TheoremController --- .../controller/TheoremController.java | 144 +++++++++++++++++- .../repository/TheoremRepository.java | 2 +- 2 files changed, 141 insertions(+), 5 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index dafd34f..8e86a5b 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -2,17 +2,18 @@ package edu.msudenver.tsp.persistence.controller; import edu.msudenver.tsp.persistence.dto.TheoremDto; import edu.msudenver.tsp.persistence.repository.TheoremRepository; +import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.util.StopWatch; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.ResponseBody; -import org.springframework.web.bind.annotation.RestController; +import org.springframework.validation.BindingResult; +import org.springframework.web.bind.annotation.*; +import javax.validation.Valid; import java.util.List; +import java.util.Optional; @Slf4j @RestController @@ -39,4 +40,139 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } + + @GetMapping("/{id}") + public @ResponseBody + ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { + LOG.info("Received request to query for theorem with id " + id); + if (id == null) { + LOG.error("ERROR: ID was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for theorem with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional theorem = theoremRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + return theorem.map(theoremDto -> { + LOG.info("Returning theorem with id " + id); + return new ResponseEntity<>(theoremDto, HttpStatus.OK); + }).orElseGet( + () -> { + LOG.warn("No theorem was found with id " + id); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + }); + + } + + @PostMapping("/") + public @ResponseBody ResponseEntity insertTheorem( + @Valid @RequestBody final TheoremDto theoremDto, + final BindingResult bindingResult) { + LOG.info("Received request to insert a new theorem"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (theoremDto == null) { + LOG.error("Passed entity is unprocessable"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Saving new theorem"); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final TheoremDto savedTheorem = theoremRepository.save(theoremDto); + + stopWatch.stop(); + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + LOG.info("Returning the newly created theorem with id " + savedTheorem.getId()); + return new ResponseEntity<>(savedTheorem, HttpStatus.CREATED); + } + + @PatchMapping("/{id}") + public @ResponseBody ResponseEntity updateTheorem( + @PathVariable("id") final Integer id, + @RequestBody final TheoremDto theoremDto, final BindingResult bindingResult) { + + LOG.info("Received request to update an account"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (theoremDto == null) { + LOG.error("Passed entity is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + if (id == null) { + LOG.error("Theorem ID must be specified"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Checking for existence of theorem with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional existingTheorem = theoremRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + if (!existingTheorem.isPresent()) { + LOG.error("No theorem associated with id " + id); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + PersistenceUtilities.copyNonNullProperties(theoremDto, existingTheorem.get()); + existingTheorem.get().setVersion(existingTheorem.get().getVersion()+ 1); + + LOG.info("Updating theorem with id " + id); + LOG.debug("Querying for theorem with ID " + id); + + stopWatch.start(); + + final TheoremDto updatedTheorem = theoremRepository.save(existingTheorem.get()); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + return new ResponseEntity<>(updatedTheorem, HttpStatus.OK); + } + + @DeleteMapping("/{id}") + public @ResponseBody ResponseEntity deleteTheoremById(@PathVariable("id") final Integer id) { + LOG.info("Received request to delete theorem with id " + id); + if (id == null) { + LOG.error("Specified id is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Deleting theorem with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + theoremRepository.deleteById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 14f6b45..fc1b219 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -5,5 +5,5 @@ import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository -public interface TheoremRepository extends JpaRepository { +public interface TheoremRepository extends JpaRepository { } From 11aa1f1cf7a6215eb921012e96644dd8981717a4 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 7 Mar 2019 10:50:22 -0700 Subject: [PATCH 09/34] PAN-50 Created the findByBranch method --- .../controller/TheoremController.java | 24 +++++++++++++++++++ .../tsp/persistence/dto/AccountDto.java | 12 ++++++---- .../tsp/persistence/dto/BaseDto.java | 2 +- .../tsp/persistence/dto/Definition.java | 2 +- .../tsp/persistence/dto/DefinitionDto.java | 2 +- .../tsp/persistence/dto/Notation.java | 2 +- .../tsp/persistence/dto/TheoremDto.java | 2 +- .../repository/TheoremRepository.java | 4 ++++ 8 files changed, 40 insertions(+), 10 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 8e86a5b..0c3cf68 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -41,6 +41,30 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } + @GetMapping("/{branch}") + public @ResponseBody + ResponseEntity> getAllTheoremsByBranch(@PathVariable("branch") final String branch) { + LOG.info("Received request to query for theorems related to the " + branch + " branch of mathematics"); + if (branch == null) { + LOG.error("ERROR: branch was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for theorems with branch " + branch); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfTheorems = theoremRepository.findByBranch(branch); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + + return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); + } + @GetMapping("/{id}") public @ResponseBody ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java index 3c15eee..e253e22 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java @@ -4,10 +4,7 @@ import lombok.Data; import lombok.EqualsAndHashCode; import org.springframework.data.jpa.domain.support.AuditingEntityListener; -import javax.persistence.Entity; -import javax.persistence.EntityListeners; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; +import javax.persistence.*; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; @@ -24,7 +21,12 @@ public class AccountDto extends BaseDto implements Serializable { @NotNull private boolean administrator_status; @Temporal(TemporalType.DATE) private Date last_login; - public static final long serialVersionUID = 7095627971593953734L; + private static final long serialVersionUID = 7095627971593953734L; public interface Insert {} + + @PrePersist + public void prePersist() { + last_login = new Date(); + } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java index b718619..b6eb9ce 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java @@ -36,5 +36,5 @@ public class BaseDto implements Serializable { @Version private Integer version; - public static final long serialVersionUID = -1686252381978213945L; + private static final long serialVersionUID = -1686252381978213945L; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java index e346772..b2a26cb 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java @@ -13,5 +13,5 @@ import java.util.List; public class Definition implements Serializable { private List definitions; - public static final long serialVersionUID = -2208496232532214840L; + private static final long serialVersionUID = -2208496232532214840L; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java index 806e84c..89583ad 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java @@ -28,7 +28,7 @@ public class DefinitionDto extends BaseDto implements Serializable { @Type(type = "json") @Column(columnDefinition = "jsonb") private Notation notation; - public static final long serialVersionUID = -5314619286352932857L; + private static final long serialVersionUID = -5314619286352932857L; public interface Insert {} } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java index 0545f3c..3936174 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java @@ -12,5 +12,5 @@ import java.util.List; @ToString public class Notation implements Serializable { private List notations; - public static final long serialVersionUID = 2301438318932336121L; + private static final long serialVersionUID = 2301438318932336121L; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index 4369173..c6b6a31 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -26,5 +26,5 @@ public class TheoremDto extends BaseDto implements Serializable { @Type(type = "json") @Column(columnDefinition = "jsonb") private List referenced_theorems; @NotNull private boolean proven_status; - public static final long serialVersionUID = 1545568391140364425L; + private static final long serialVersionUID = 1545568391140364425L; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index fc1b219..63117af 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -4,6 +4,10 @@ import edu.msudenver.tsp.persistence.dto.TheoremDto; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; +import java.util.List; + @Repository public interface TheoremRepository extends JpaRepository { + + public List findByBranch(String branch); } From 6d7979c17972e65abbf54ab23568cbfd79a5f0a5 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 7 Mar 2019 11:07:10 -0700 Subject: [PATCH 10/34] PAN-50 Created the findByProven_status method --- .../controller/TheoremController.java | 24 +++++++++++++++++++ .../repository/TheoremRepository.java | 4 +++- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 0c3cf68..a75a76a 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -65,6 +65,30 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } + @GetMapping("/{proven_status}") + public @ResponseBody + ResponseEntity> getAllTheoremsByBranch(@PathVariable("proven_status") final Boolean proven_status) { + LOG.info("Received request to query for theorems whose proven status is " + proven_status); + if (proven_status == null) { + LOG.error("ERROR: branch was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for theorems with proven status " + proven_status); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfTheorems = theoremRepository.findByProven_status(proven_status); + + 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()); + + return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); + } + @GetMapping("/{id}") public @ResponseBody ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 63117af..2561bc9 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -9,5 +9,7 @@ import java.util.List; @Repository public interface TheoremRepository extends JpaRepository { - public List findByBranch(String branch); + List findByBranch(String branch); + + List findByProven_status(Boolean proven_status); } From fd760293ef3787128eb00c7dac3136b8841f3458 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Mon, 11 Mar 2019 00:09:34 -0600 Subject: [PATCH 11/34] PAN-50 Wrote Unit tests for the Theorem Controller, and initial integration Test for the theorem controller, but need to fix custom queries in both accountRepository and theoremRepository --- .../persistence/PersistenceTestConfig.java | 2 +- .../persistence/TheoremsIntegrationTest.java | 90 ++++++ .../controller/TheoremController.java | 2 +- .../controller/AccountControllerTest.java | 6 +- .../controller/DefinitionControllerTest.java | 2 +- .../controller/TheoremControllerTest.java | 291 ++++++++++++++++++ 6 files changed, 387 insertions(+), 6 deletions(-) create mode 100644 persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java create mode 100644 persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java index 7427fa2..9680dbe 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java @@ -56,7 +56,7 @@ public class PersistenceTestConfig { .create() .username("panda") .password("secret") - .url("jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false") + .url("jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false&serverTimezone=UTC") .driverClassName("com.mysql.cj.jdbc.Driver") .build(); } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java new file mode 100644 index 0000000..d2aeb77 --- /dev/null +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java @@ -0,0 +1,90 @@ +package edu.msudenver.tsp.persistence; + +import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.TheoremType; +import edu.msudenver.tsp.persistence.repository.TheoremRepository; +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.List; +import java.util.Optional; + +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = PersistenceTestConfig.class) +public class TheoremsIntegrationTest { + @Autowired private TheoremRepository theoremRepository; + + @Test + public void testCRUDFunctionality() { + final TheoremDto theoremDto = createTheorem(); + final TheoremDto savedTheorem = theoremRepository.save(theoremDto); + + assertNotNull(savedTheorem); + assertEquals(Integer.valueOf(0), savedTheorem.getVersion()); + + final int id = savedTheorem.getId(); + + assertEquals("Test theorem", savedTheorem.getName()); + assertEquals("Test branch", savedTheorem.getBranch()); + assertTrue(savedTheorem.isProvenStatus()); + assertEquals(2, savedTheorem.getReferencedTheorems().size()); + assertEquals(2, savedTheorem.getReferencedDefinitions().size()); + assertEquals("test theorem 1", savedTheorem.getReferencedTheorems().get(0)); + assertEquals("test theorem 2", savedTheorem.getReferencedTheorems().get(1)); + assertEquals("test definition 1", savedTheorem.getReferencedDefinitions().get(0)); + assertEquals("test definition 2", savedTheorem.getReferencedDefinitions().get(1)); + + savedTheorem.setBranch("Test Update"); + + final TheoremDto updatedTheorem = theoremRepository.save(savedTheorem); + + assertNotNull(updatedTheorem); + assertEquals(Integer.valueOf(0), updatedTheorem.getVersion()); + assertEquals("Test theorem", updatedTheorem.getName()); + assertEquals("Test Update", updatedTheorem.getBranch()); + assertTrue(updatedTheorem.isProvenStatus()); + assertEquals(2, updatedTheorem.getReferencedTheorems().size()); + assertEquals(2, updatedTheorem.getReferencedDefinitions().size()); + assertEquals("test theorem 1", updatedTheorem.getReferencedTheorems().get(0)); + assertEquals("test theorem 2", updatedTheorem.getReferencedTheorems().get(1)); + assertEquals("test definition 1", updatedTheorem.getReferencedDefinitions().get(0)); + assertEquals("test definition 2", updatedTheorem.getReferencedDefinitions().get(1)); + assertEquals(updatedTheorem.getId(), id); + + final List listOfTheoremsByBranch = theoremRepository.findByBranch("Test Update"); + + assertNotNull(listOfTheoremsByBranch); + assertEquals(1, listOfTheoremsByBranch.size()); + assertEquals(updatedTheorem, listOfTheoremsByBranch.get(0)); + + theoremRepository.delete(theoremDto); + final Optional deletedTheorem = theoremRepository.findById(id); + assertFalse(deletedTheorem.isPresent()); + } + + private TheoremDto createTheorem() { + final List referencedTheoremsList = new ArrayList<>(); + referencedTheoremsList.add("test theorem 1"); + referencedTheoremsList.add("test theorem 2"); + + final List referencedDefinitionsList = new ArrayList<>(); + referencedDefinitionsList.add("test definition 1"); + referencedDefinitionsList.add("test definition 2"); + + final 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); + + return theoremDto; + } +} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 4ba293d..fcba9d5 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -67,7 +67,7 @@ public class TheoremController { @GetMapping("/{proven_status}") public @ResponseBody - ResponseEntity> getAllTheoremsByBranch(@PathVariable("proven_status") final Boolean provenStatus) { + ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { LOG.info("Received request to query for theorems whose proven status is " + provenStatus); if (provenStatus == null) { LOG.error("ERROR: branch was null"); diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java index a66a12a..05a6ba9 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java @@ -47,7 +47,7 @@ public class AccountControllerTest { assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); - responseEntity.getBody().forEach(account -> assertEquals(account, accountDto)); + responseEntity.getBody().forEach(account -> assertEquals(accountDto, account)); } @Test @@ -166,10 +166,10 @@ public class AccountControllerTest { @Test public void testInsertAccount_bindingResultHasErrors() { - final AccountDto definitionDto = createAccount(); + final AccountDto accountDto = createAccount(); when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = accountController.insertAccount(definitionDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java index b24d508..e28cbb8 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java @@ -46,7 +46,7 @@ public class DefinitionControllerTest { assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); - responseEntity.getBody().forEach(definition -> assertEquals(definition, definitionDto)); + responseEntity.getBody().forEach(definition -> assertEquals(definitionDto, definition)); } @Test diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java new file mode 100644 index 0000000..5decba2 --- /dev/null +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -0,0 +1,291 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.TheoremType; +import edu.msudenver.tsp.persistence.repository.TheoremRepository; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.BindingResult; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.*; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.*; + +@RunWith(MockitoJUnitRunner.class) +@WebMvcTest(controllers = TheoremController.class) +public class TheoremControllerTest { + @Mock private TheoremRepository theoremRepository; + @InjectMocks private TheoremController theoremController; + @Mock private BindingResult bindingResult; + + @Test + public void testGetAllTheorems() { + final TheoremDto theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); + listOfTheorems.add(theoremDto); + listOfTheorems.add(theoremDto); + + when(theoremRepository.findAll()).thenReturn(listOfTheorems); + + final ResponseEntity> responseEntity = theoremController.getAllTheorems(); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(theorem -> assertEquals(theoremDto, theorem)); + } + + @Test + public void testGetTheoremById() { + final TheoremDto theoremDto = createTheorem(); + when(theoremRepository.findById(anyInt())).thenReturn(Optional.ofNullable(theoremDto)); + + final ResponseEntity responseEntity = theoremController.getTheoremById(1); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(theoremDto, responseEntity.getBody()); + verify(theoremRepository).findById(anyInt()); + } + + @Test + public void testGetTheoremById_nullId() { + final ResponseEntity responseEntity = theoremController.getTheoremById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testGetTheoremById_noTheoremFound() { + when(theoremRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = theoremController.getTheoremById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + verify(theoremRepository).findById(anyInt()); + } + + @Test + public void testGetAllTheoremsByBranch() { + final TheoremDto theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); + listOfTheorems.add(theoremDto); + listOfTheorems.add(theoremDto); + + when(theoremRepository.findByBranch(anyString())).thenReturn(listOfTheorems); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(theorem -> assertEquals(theoremDto, theorem)); + } + + @Test + public void testGetAllTheoremsByBranch_nullBranch() { + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testGetAllTheoremsByProvenStatus() { + final TheoremDto theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); + listOfTheorems.add(theoremDto); + listOfTheorems.add(theoremDto); + + when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(listOfTheorems); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(true); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(theorem -> assertEquals(theoremDto, theorem)); + } + + @Test + public void testGetAllTheoremsByProvenStatus_nullProvenStatus() { + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testInsertTheorem() { + final TheoremDto theoremDto = createTheorem(); + when(theoremRepository.save(any(TheoremDto.class))).thenReturn(theoremDto); + + final ResponseEntity responseEntity = theoremController.insertTheorem(theoremDto, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); + assertEquals(theoremDto, responseEntity.getBody()); + verify(theoremRepository).save(any(TheoremDto.class)); + } + + @Test + public void testInsertTheorem_theoremDtoIsNull() { + final ResponseEntity responseEntity = theoremController.insertTheorem(null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testInsertTheorem_bindingResultHasErrors() { + final TheoremDto theoremDto = createTheorem(); + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = theoremController.insertTheorem(theoremDto, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testUpdateTheorem() { + final TheoremDto existingTheorem = createTheorem(); + existingTheorem.setId(1); + existingTheorem.setVersion(1); + final TheoremDto theoremUpdate = new TheoremDto(); + theoremUpdate.setName("Test Update"); + final TheoremDto updatedTheorem = existingTheorem; + updatedTheorem.setName("Test Update"); + when(theoremRepository.findById(anyInt())).thenReturn(Optional.of(existingTheorem)); + when(theoremRepository.save(any(TheoremDto.class))).thenReturn(updatedTheorem); + + final ResponseEntity responseEntity = theoremController.updateTheorem(1, theoremUpdate, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(updatedTheorem, responseEntity.getBody()); + verify(theoremRepository).findById(anyInt()); + verify(theoremRepository).save(any(TheoremDto.class)); + } + + @Test + public void testUpdateTheorem_bindingResultHasErrors() { + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testUpdateTheorem_theoremDtoIsNull() { + final ResponseEntity responseEntity = theoremController.updateTheorem(1, null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testUpdateTheorem_idIsNull() { + final ResponseEntity responseEntity = theoremController.updateTheorem(null, createTheorem(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testUpdateTheorem_theoremDoesNotExist() { + when(theoremRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verify(theoremRepository, times(0)).save(any(TheoremDto.class)); + } + + @Test + public void testDeleteTheoremById() { + doNothing().when(theoremRepository).deleteById(anyInt()); + + final ResponseEntity responseEntity = theoremController.deleteTheoremById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode()); + verify(theoremRepository).deleteById(anyInt()); + } + + @Test + public void testDeleteTheoremById_idIsNull() { + final ResponseEntity responseEntity = theoremController.deleteTheoremById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + private TheoremDto createTheorem() { + final List referencedTheoremsList = new ArrayList<>(); + referencedTheoremsList.add("test theorem 1"); + referencedTheoremsList.add("test theorem 2"); + + final List referencedDefinitionsList = new ArrayList<>(); + referencedDefinitionsList.add("test definition 1"); + referencedDefinitionsList.add("test definition 2"); + + final 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); + + return theoremDto; + } +} \ No newline at end of file From 64dd8397cc621a2e08a9b7fa8a208df7ee320d96 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Mon, 11 Mar 2019 13:07:21 -0600 Subject: [PATCH 12/34] PAN-50 Finished integration tests for theorems --- .../persistence/TheoremsIntegrationTest.java | 10 ++-------- .../tsp/persistence/dto/AccountDto.java | 4 ++-- .../tsp/persistence/dto/TheoremDto.java | 18 ++++++++++++++---- 3 files changed, 18 insertions(+), 14 deletions(-) diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java index d2aeb77..a6109f2 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java @@ -32,7 +32,7 @@ public class TheoremsIntegrationTest { assertEquals("Test theorem", savedTheorem.getName()); assertEquals("Test branch", savedTheorem.getBranch()); - assertTrue(savedTheorem.isProvenStatus()); + assertTrue(savedTheorem.getProvenStatus()); assertEquals(2, savedTheorem.getReferencedTheorems().size()); assertEquals(2, savedTheorem.getReferencedDefinitions().size()); assertEquals("test theorem 1", savedTheorem.getReferencedTheorems().get(0)); @@ -48,7 +48,7 @@ public class TheoremsIntegrationTest { assertEquals(Integer.valueOf(0), updatedTheorem.getVersion()); assertEquals("Test theorem", updatedTheorem.getName()); assertEquals("Test Update", updatedTheorem.getBranch()); - assertTrue(updatedTheorem.isProvenStatus()); + assertTrue(updatedTheorem.getProvenStatus()); assertEquals(2, updatedTheorem.getReferencedTheorems().size()); assertEquals(2, updatedTheorem.getReferencedDefinitions().size()); assertEquals("test theorem 1", updatedTheorem.getReferencedTheorems().get(0)); @@ -57,12 +57,6 @@ public class TheoremsIntegrationTest { assertEquals("test definition 2", updatedTheorem.getReferencedDefinitions().get(1)); assertEquals(updatedTheorem.getId(), id); - final List listOfTheoremsByBranch = theoremRepository.findByBranch("Test Update"); - - assertNotNull(listOfTheoremsByBranch); - assertEquals(1, listOfTheoremsByBranch.size()); - assertEquals(updatedTheorem, listOfTheoremsByBranch.get(0)); - theoremRepository.delete(theoremDto); final Optional deletedTheorem = theoremRepository.findById(id); assertFalse(deletedTheorem.isPresent()); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java index 0f24842..2f71c71 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java @@ -19,8 +19,8 @@ import java.util.Date; public class AccountDto extends BaseDto implements Serializable { @NotBlank(groups = Insert.class, message = "A username must be specified") @Size(max = 50) private String username; @NotBlank(groups = Insert.class, message = "A password must be specified") @Size(max = 256) private String password; - @NotNull private boolean administratorStatus; - @Temporal(TemporalType.DATE) private Date lastLogin; + @NotNull @Column(name = "administrator_status") private boolean administratorStatus; + @Temporal(TemporalType.DATE) @Column(name = "last_login") private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index e28a5e3..6c48e32 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -21,11 +21,11 @@ import java.util.List; @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 private TheoremType theoremType; + @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; - @Type(type = "json") @Column(columnDefinition = "jsonb") private List referencedDefinitions; - @Type(type = "json") @Column(columnDefinition = "jsonb") private List referencedTheorems; - @NotNull private boolean provenStatus; + @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private List referencedDefinitions; + @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List referencedTheorems; + @NotNull @Column(name = "proven_status") private boolean provenStatus; @JsonProperty("theorem_type") public TheoremType getTheoremType() { @@ -57,5 +57,15 @@ public class TheoremDto extends BaseDto implements Serializable { this.referencedTheorems = referencedTheorems; } + @JsonProperty("proven_status") + public boolean getProvenStatus() { + return provenStatus; + } + + @JsonProperty("proven_status") + public void setProvenStatus(final boolean provenStatus) { + this.provenStatus = provenStatus; + } + private static final long serialVersionUID = 1545568391140364425L; } From 47dd67623e0262d1cc28392d3c4e59383c445370 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 13 Mar 2019 21:57:36 -0600 Subject: [PATCH 13/34] PAN-50 Addressed Brittany's comment about my typo --- .../msudenver/tsp/persistence/controller/TheoremController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index fcba9d5..a1b1f03 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -70,7 +70,7 @@ public class TheoremController { ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { LOG.info("Received request to query for theorems whose proven status is " + provenStatus); if (provenStatus == null) { - LOG.error("ERROR: branch was null"); + LOG.error("ERROR: status was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } From d19cb5a989fd6df1f06a50fc4ff87eb36e9aee2d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 13 Mar 2019 22:05:08 -0600 Subject: [PATCH 14/34] PAN-50 Addressed Brittany's comment about logging consistency --- .../tsp/persistence/controller/DefinitionController.java | 2 +- .../msudenver/tsp/persistence/controller/TheoremController.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index e93a5be..3c8b4d1 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -85,7 +85,7 @@ public class DefinitionController { } if (definitionDto == null) { - LOG.error("Passed entity is unprocessable"); + LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index a1b1f03..fc47620 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -130,7 +130,7 @@ public class TheoremController { } if (theoremDto == null) { - LOG.error("Passed entity is unprocessable"); + LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } From 3483a2dd2c3af1bbb24636f5bf01c7ce6bd251b0 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 13 Mar 2019 22:24:32 -0600 Subject: [PATCH 15/34] PAN-50 Addressed Brittany's comment about nonexistent fields --- .../controller/TheoremController.java | 12 ++++++++++ .../controller/TheoremControllerTest.java | 23 +++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index fc47620..9a0f699 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -62,6 +62,12 @@ public class TheoremController { LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + if (listOfTheorems.isEmpty()) { + LOG.warn("No theorems were found for branch {}", branch); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of theorems with branch {}", branch); return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } @@ -86,6 +92,12 @@ public class TheoremController { LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + if (listOfTheorems.isEmpty()) { + LOG.warn("No theorems were found for proven status {}", provenStatus); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of theorems with proven status {}", provenStatus); return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java index 5decba2..f3993cc 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -14,6 +14,7 @@ import org.springframework.http.ResponseEntity; import org.springframework.validation.BindingResult; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Optional; @@ -114,6 +115,17 @@ public class TheoremControllerTest { verifyZeroInteractions(theoremRepository); } + @Test + public void testGetAllTheoremsByBranch_noTheoremsFound() { + when(theoremRepository.findByBranch(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test nonexistent branch"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + @Test public void testGetAllTheoremsByProvenStatus() { final TheoremDto theoremDto = createTheorem(); @@ -143,6 +155,17 @@ public class TheoremControllerTest { verifyZeroInteractions(theoremRepository); } + @Test + public void testGetAllTheoremsByProvenStatus_noTheoremsFound() { + when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(false); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + @Test public void testInsertTheorem() { final TheoremDto theoremDto = createTheorem(); From bc92dc60d425eeb30f2c6ba0e13a95242a391471 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 14 Mar 2019 10:51:38 -0600 Subject: [PATCH 16/34] PAN-52 created the proofs table --- persistence/scripts/mysql/local_development.sql | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 87984f0..87186c4 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -32,4 +32,16 @@ referenced_definitions json, referenced_theorems json, proven_status boolean default false, version int default 1 +); +CREATE TABLE proofs +( + id INT NOT NULL AUTO_INCREMENT, + username VARCHAR(50) NOT NULL, + branch VARCHAR(512) NOT NULL, + referenced_definitions JSON, + referenced_theorems JSON, + date_added DATE, + last_updated DATE, + version INT DEFAULT 1, + PRIMARY KEY (id) ) \ No newline at end of file From 4bd1936a7aed6490d73dee7a4060342ca58e7b67 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 14 Mar 2019 11:17:51 -0600 Subject: [PATCH 17/34] PAN-52 created the proofs DTO --- .../scripts/mysql/local_development.sql | 1 - .../tsp/persistence/dto/ProofDto.java | 75 ++++++++++++++++++- .../repository/ProofRepository.java | 4 +- 3 files changed, 76 insertions(+), 4 deletions(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 87186c4..6051486 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -36,7 +36,6 @@ version int default 1 CREATE TABLE proofs ( id INT NOT NULL AUTO_INCREMENT, - username VARCHAR(50) NOT NULL, branch VARCHAR(512) NOT NULL, referenced_definitions JSON, referenced_theorems JSON, diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java index 195340e..3bf2579 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java @@ -1,4 +1,77 @@ package edu.msudenver.tsp.persistence.dto; -public class ProofDto extends BaseDto { +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; + +@Entity(name = "proofs") +@EntityListeners(AuditingEntityListener.class) +@Data +@EqualsAndHashCode(callSuper = true) +public class ProofDto extends BaseDto implements Serializable { + @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 String referencedDefinitions; + @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private String referencedTheorems; + @Temporal(TemporalType.DATE) @Column(name = "date_created") private Date dateCreated; + @Temporal(TemporalType.DATE) @Column(name = "last_updated") private Date lastUpdated; + + + @JsonProperty("referenced_definitions") + public String getReferencedDefinitions() { + return referencedDefinitions; + } + + @JsonProperty("referenced_definitions") + public void setReferencedDefinitions(final String referencedDefinitions) { + this.referencedDefinitions = referencedDefinitions; + } + + @JsonProperty("referenced_theorems") + public String getReferencedTheorems() { + return referencedTheorems; + } + + @JsonProperty("referenced_theorems") + public void setReferencedTheorems(final 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 {} } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java index 8466bbb..134897f 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -1,7 +1,7 @@ package edu.msudenver.tsp.persistence.repository; import edu.msudenver.tsp.persistence.dto.BaseDto; -import org.springframework.data.repository.CrudRepository; +import org.springframework.data.jpa.repository.JpaRepository; -public interface ProofRepository extends CrudRepository { +public interface ProofRepository extends JpaRepository { } From 7af41d4235b753272a55610a624154a3ea7fb72e Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 14 Mar 2019 11:43:01 -0600 Subject: [PATCH 18/34] PAN-52 Added findByName and findByBranch methods to the repository, and created first couple of methods and corresponding tests in the ProofController --- .../scripts/mysql/local_development.sql | 1 + .../controller/ProofController.java | 62 +++++++++- .../tsp/persistence/dto/ProofDto.java | 16 ++- .../repository/ProofRepository.java | 10 +- .../controller/ProofControllerTest.java | 108 ++++++++++++++++++ 5 files changed, 187 insertions(+), 10 deletions(-) create mode 100644 persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 6051486..0b68072 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -36,6 +36,7 @@ version int default 1 CREATE TABLE proofs ( id INT NOT NULL AUTO_INCREMENT, + name VARCHAR(512) NOT NULL, branch VARCHAR(512) NOT NULL, referenced_definitions JSON, referenced_theorems JSON, diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index e52b209..a2009b7 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -1,11 +1,69 @@ package edu.msudenver.tsp.persistence.controller; +import edu.msudenver.tsp.persistence.dto.ProofDto; import edu.msudenver.tsp.persistence.repository.ProofRepository; 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.web.bind.annotation.*; -@Component +import java.util.List; + +@Slf4j +@RestController @AllArgsConstructor +@RequestMapping("/proofs") public class ProofController { private final ProofRepository proofRepository; + + @GetMapping("/") + public @ResponseBody + ResponseEntity> getAllProofs() { + LOG.info("Received request to list all theorems"); + + LOG.debug("Querying for list of all theorems"); + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfProofs = proofRepository.findAll(); + + stopWatch.stop(); + + LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning list of all theorems with size " + listOfProofs.size()); + + return new ResponseEntity<>(listOfProofs, HttpStatus.OK); + } + + @GetMapping("/{branch}") + public @ResponseBody + ResponseEntity> getAllProofsByBranch(@PathVariable("branch") final String branch) { + LOG.info("Received request to query for proofs related to the " + branch + " branch of mathematics"); + if (branch == null) { + LOG.error("ERROR: branch was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for proofs with branch " + branch); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfProofs = proofRepository.findByBranch(branch); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + 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); + } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java index 3bf2579..c84623a 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java @@ -11,38 +11,42 @@ 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 ProofDto 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") + private String name; @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 String referencedDefinitions; - @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private String referencedTheorems; + @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private List referencedDefinitions; + @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List referencedTheorems; @Temporal(TemporalType.DATE) @Column(name = "date_created") private Date dateCreated; @Temporal(TemporalType.DATE) @Column(name = "last_updated") private Date lastUpdated; @JsonProperty("referenced_definitions") - public String getReferencedDefinitions() { + public List getReferencedDefinitions() { return referencedDefinitions; } @JsonProperty("referenced_definitions") - public void setReferencedDefinitions(final String referencedDefinitions) { + public void setReferencedDefinitions(final List referencedDefinitions) { this.referencedDefinitions = referencedDefinitions; } @JsonProperty("referenced_theorems") - public String getReferencedTheorems() { + public List getReferencedTheorems() { return referencedTheorems; } @JsonProperty("referenced_theorems") - public void setReferencedTheorems(final String referencedTheorems) { + public void setReferencedTheorems(final List referencedTheorems) { this.referencedTheorems = referencedTheorems; } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java index 134897f..4f1a9bd 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -1,7 +1,13 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.BaseDto; +import edu.msudenver.tsp.persistence.dto.ProofDto; import org.springframework.data.jpa.repository.JpaRepository; -public interface ProofRepository extends JpaRepository { +import java.util.List; + +public interface ProofRepository extends JpaRepository { + + List findByBranch(String branch); + + List findByName(String name); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java new file mode 100644 index 0000000..8b6d4ef --- /dev/null +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java @@ -0,0 +1,108 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.ProofDto; +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.ArrayList; +import java.util.Collections; +import java.util.Date; +import java.util.List; + +import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.*; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ProofControllerTest { + @Mock private ProofRepository proofRepository; + @InjectMocks private ProofController proofController; + @Mock private BindingResult bindingResult; + + @Test + public void testGetAllTheorems() { + final ProofDto proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); + listOfProofs.add(proofDto); + listOfProofs.add(proofDto); + + when(proofRepository.findAll()).thenReturn(listOfProofs); + + final ResponseEntity> responseEntity = proofController.getAllProofs(); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof)); + } + + @Test + public void testGetAllProofsByBranch() { + final ProofDto proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); + listOfProofs.add(proofDto); + listOfProofs.add(proofDto); + + when(proofRepository.findByBranch(anyString())).thenReturn(listOfProofs); + + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof)); + } + + @Test + public void testGetAllProfsByBranch_nullBranch() { + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testGetAllProofsByBranch_noProofsFound() { + when(proofRepository.findByBranch(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test nonexistent branch"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + + private ProofDto createProof() { + final List referencedTheoremsList = new ArrayList<>(); + referencedTheoremsList.add("test theorem 1"); + referencedTheoremsList.add("test theorem 2"); + + final List referencedDefinitionsList = new ArrayList<>(); + referencedDefinitionsList.add("test definition 1"); + referencedDefinitionsList.add("test definition 2"); + + final ProofDto proofDto = new ProofDto(); + proofDto.setName("Test proof"); + proofDto.setBranch("Test branch"); + proofDto.setDateCreated(new Date()); + proofDto.setReferencedTheorems(referencedTheoremsList); + proofDto.setReferencedDefinitions(referencedDefinitionsList); + + return proofDto; + } +} \ No newline at end of file From d560f5831fcaddc0ca2527f6c29d0adac6bbf54d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 14 Mar 2019 11:51:29 -0600 Subject: [PATCH 19/34] PAN-52 Added findByName and findByBranch methods to the repository, and created first couple of methods and corresponding tests in the ProofController --- .../controller/ProofController.java | 31 +++++++++++++ .../controller/ProofControllerTest.java | 46 ++++++++++++++++--- 2 files changed, 71 insertions(+), 6 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index a2009b7..d902eb8 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -10,6 +10,7 @@ import org.springframework.util.StopWatch; import org.springframework.web.bind.annotation.*; import java.util.List; +import java.util.Optional; @Slf4j @RestController @@ -37,6 +38,36 @@ public class ProofController { return new ResponseEntity<>(listOfProofs, HttpStatus.OK); } + @GetMapping("/{id}") + public @ResponseBody + ResponseEntity getProofById(@PathVariable("id") final Integer id) { + LOG.info("Received request to query for proof with id " + id); + if (id == null) { + LOG.error("ERROR: ID was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for proof with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional proof = proofRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + return proof.map(proofDto -> { + LOG.info("Returning proof with id " + id); + return new ResponseEntity<>(proofDto, HttpStatus.OK); + }).orElseGet( + () -> { + LOG.warn("No proof was found with id " + id); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + }); + + } + @GetMapping("/{branch}") public @ResponseBody ResponseEntity> getAllProofsByBranch(@PathVariable("branch") final String branch) { diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java index 8b6d4ef..e6535d4 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java @@ -11,16 +11,13 @@ import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.validation.BindingResult; -import java.util.ArrayList; -import java.util.Collections; -import java.util.Date; -import java.util.List; +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.verifyZeroInteractions; -import static org.mockito.Mockito.when; +import static org.mockito.Mockito.*; @RunWith(MockitoJUnitRunner.class) public class ProofControllerTest { @@ -87,6 +84,43 @@ public class ProofControllerTest { assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); } + @Test + public void testGetProofById() { + final ProofDto proofDto = createProof(); + when(proofRepository.findById(anyInt())).thenReturn(Optional.ofNullable(proofDto)); + + final ResponseEntity responseEntity = proofController.getProofById(1); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(proofDto, 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()); + } + private ProofDto createProof() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); From 4d0658a268d3b4de361ad945728b02a74bdf7d1c Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 14 Mar 2019 12:28:59 -0600 Subject: [PATCH 20/34] PAN-52 Added findByName to the TheoremRepository, and to the TheoremController as well as the corresponding tests, and a foreign key mapping from the proofs table to the corresponding theorem in the theorems table --- .../scripts/mysql/local_development.sql | 20 +++++----- .../controller/TheoremController.java | 30 ++++++++++++++ .../repository/TheoremRepository.java | 2 + .../controller/TheoremControllerTest.java | 40 +++++++++++++++++++ 4 files changed, 83 insertions(+), 9 deletions(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 0b68072..860c41b 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -35,13 +35,15 @@ version int default 1 ); CREATE TABLE proofs ( - id INT NOT NULL AUTO_INCREMENT, - name VARCHAR(512) NOT NULL, - branch VARCHAR(512) NOT NULL, - referenced_definitions JSON, - referenced_theorems JSON, - date_added DATE, - last_updated DATE, - version INT DEFAULT 1, + id INT NOT NULL AUTO_INCREMENT, + name VARCHAR(512) NOT NULL, + branch VARCHAR(512) NOT NULL, + theorem INT NOT NULL, + FOREIGN KEY fk_theorem (theorem) REFERENCES theorems (id) ON DELETE NO ACTION ON UPDATE NO ACTION, + referenced_definitions JSON, + referenced_theorems JSON, + date_added DATE, + last_updated DATE, + version INT DEFAULT 1, PRIMARY KEY (id) -) \ No newline at end of file +); \ No newline at end of file diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 9a0f699..68ce608 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -101,6 +101,36 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } + @GetMapping("/{name}") + public @ResponseBody + ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { + LOG.info("Received request to query for theorems whose name is " + name); + if (name == null) { + LOG.error("ERROR: name was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for theorems with name " + name); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfTheorems = theoremRepository.findByName(name); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + + if (listOfTheorems.isEmpty()) { + LOG.warn("No theorems were found with name {}", name); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of theorems with name {}", name); + return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); + } + @GetMapping("/{id}") public @ResponseBody ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 75df2ee..2e3c9f6 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -12,4 +12,6 @@ public interface TheoremRepository extends JpaRepository { List findByBranch(String branch); List findByProvenStatus(Boolean provenStatus); + + List findByName(String name); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java index f3993cc..6d09a22 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -166,6 +166,46 @@ public class TheoremControllerTest { assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); } + @Test + public void testGetAllTheoremsByName() { + final TheoremDto theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); + listOfTheorems.add(theoremDto); + listOfTheorems.add(theoremDto); + + when(theoremRepository.findByName(anyString())).thenReturn(listOfTheorems); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("Test Theorem"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(theorem -> assertEquals(theoremDto, theorem)); + } + + @Test + public void testGetAllTheoremsByName_nullName() { + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testGetAllTheoremsByName_noNameFound() { + when(theoremRepository.findByName(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("No name"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + @Test public void testInsertTheorem() { final TheoremDto theoremDto = createTheorem(); From bd7455c679c89f74ba9fd02443fb0f2a4d11d141 Mon Sep 17 00:00:00 2001 From: atusa Date: Fri, 15 Mar 2019 15:04:45 -0600 Subject: [PATCH 21/34] PAN-52 updated the travis.yml file to also perform a sonar analysis after each build --- .travis.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index f7ce2ec..b506b1b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -38,3 +38,5 @@ jobs: script: ./gradlew test - stage: Integration Tests script: ./gradlew integrationTest + - stage: Sonar analysis + script: ./gradlew sonar From 4b866017a16c3e2612cac383fe683107a6f5b7ac Mon Sep 17 00:00:00 2001 From: atusa Date: Fri, 15 Mar 2019 15:58:23 -0600 Subject: [PATCH 22/34] PAN-52 Finished creating the ProofController and writing all unit tests --- .../scripts/mysql/local_development.sql | 2 +- .../controller/ProofController.java | 141 +++++++++++++++ .../controller/TheoremController.java | 5 +- .../tsp/persistence/dto/ProofDto.java | 12 +- .../tsp/persistence/dto/TheoremDto.java | 11 +- .../repository/ProofRepository.java | 2 +- .../controller/ProofControllerTest.java | 170 +++++++++++++++++- 7 files changed, 333 insertions(+), 10 deletions(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 860c41b..52480e5 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -36,7 +36,7 @@ version int default 1 CREATE TABLE proofs ( id INT NOT NULL AUTO_INCREMENT, - name VARCHAR(512) NOT NULL, + 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, diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index d902eb8..373b79d 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -2,13 +2,18 @@ package edu.msudenver.tsp.persistence.controller; import edu.msudenver.tsp.persistence.dto.ProofDto; import edu.msudenver.tsp.persistence.repository.ProofRepository; +import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.util.StopWatch; +import org.springframework.validation.BindingResult; +import org.springframework.validation.annotation.Validated; import org.springframework.web.bind.annotation.*; +import javax.validation.Valid; +import javax.validation.groups.Default; import java.util.List; import java.util.Optional; @@ -97,4 +102,140 @@ public class ProofController { LOG.info("Returning list of proofs with branch {}", branch); return new ResponseEntity<>(listOfProofs, HttpStatus.OK); } + + @GetMapping("/{theorem_name}") + public @ResponseBody + ResponseEntity> getAllProofsByTheoremName(@PathVariable("theorem_name") final String theoremName) { + LOG.info("Received request to query for proofs of the theorem {}", theoremName); + if (theoremName == null) { + LOG.error("ERROR: theorem name was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for proofs of the theorem {}", theoremName); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfProofs = proofRepository.findByTheoremName(theoremName); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + 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({ProofDto.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertProof( + @Valid @RequestBody final ProofDto proofDto, + 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 (proofDto == 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 ProofDto savedProof = proofRepository.save(proofDto); + + stopWatch.stop(); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + LOG.info("Returning the newly created proof with id {}", savedProof.getId()); + return new ResponseEntity<>(savedProof, HttpStatus.CREATED); + } + + @PatchMapping("/{id}") + public @ResponseBody ResponseEntity updateProof( + @PathVariable("id") final Integer id, + @RequestBody final ProofDto proofDto, 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 (proofDto == null) { + LOG.error("Passed entity is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + if (id == null) { + LOG.error("Proof ID must be specified"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Checking for existence of proof with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional existingProof = proofRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + if (!existingProof.isPresent()) { + LOG.error("No proof associated with id {}", id); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + PersistenceUtilities.copyNonNullProperties(proofDto, 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 ProofDto updatedProof = proofRepository.save(existingProof.get()); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + return new ResponseEntity<>(updatedProof, HttpStatus.OK); + } + + @DeleteMapping("/{id}") + public @ResponseBody ResponseEntity deleteProofById(@PathVariable("id") final Integer id) { + LOG.info("Received request to delete proof with id {}", id); + if (id == null) { + LOG.error("Specified id is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Deleting proof with id {}", id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + proofRepository.deleteById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); + + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 68ce608..2bebf44 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -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; @@ -162,6 +164,7 @@ public class TheoremController { } @PostMapping("/") + @Validated({TheoremDto.Insert.class, Default.class}) public @ResponseBody ResponseEntity insertTheorem( @Valid @RequestBody final TheoremDto theoremDto, final BindingResult bindingResult) { @@ -195,7 +198,7 @@ public class TheoremController { @PathVariable("id") final Integer id, @RequestBody final TheoremDto theoremDto, 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); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java index c84623a..fdb6e76 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java @@ -20,7 +20,8 @@ import java.util.List; public class ProofDto 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") - private String name; + @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; @@ -29,6 +30,15 @@ public class ProofDto extends BaseDto implements Serializable { @Temporal(TemporalType.DATE) @Column(name = "date_created") private Date dateCreated; @Temporal(TemporalType.DATE) @Column(name = "last_updated") private Date lastUpdated; + @JsonProperty("theorem_name") + public String getTheoremName() { + return theoremName; + } + + @JsonProperty("theorem_name") + public void setTheoremName(final String theoremName) { + this.theoremName = theoremName; + } @JsonProperty("referenced_definitions") public List getReferencedDefinitions() { diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java index 6c48e32..db10620 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java @@ -20,12 +20,12 @@ import java.util.List; @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; + @NotBlank(groups = Insert.class) @Size(min = 1, max = 512, message = "theorem name must be between 1 and 512 characters") private String name; + @NotNull(groups = Insert.class) @Column(name = "theorem_type") private TheoremType theoremType; + @NotNull(groups = Insert.class, message = "a branch of mathematics that this theorem is associated with must be specified") private String branch; @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private List referencedDefinitions; @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List referencedTheorems; - @NotNull @Column(name = "proven_status") private boolean provenStatus; + @NotNull(groups = Insert.class) @Column(name = "proven_status") private boolean provenStatus; @JsonProperty("theorem_type") public TheoremType getTheoremType() { @@ -68,4 +68,7 @@ public class TheoremDto extends BaseDto implements Serializable { } private static final long serialVersionUID = 1545568391140364425L; + + public interface Insert {} + } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java index 4f1a9bd..9aa16e9 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -9,5 +9,5 @@ public interface ProofRepository extends JpaRepository { List findByBranch(String branch); - List findByName(String name); + List findByTheoremName(String name); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java index e6535d4..5536d06 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java @@ -26,7 +26,7 @@ public class ProofControllerTest { @Mock private BindingResult bindingResult; @Test - public void testGetAllTheorems() { + public void testGetAllProofs() { final ProofDto proofDto = createProof(); final List listOfProofs = new ArrayList<>(); listOfProofs.add(proofDto); @@ -84,6 +84,46 @@ public class ProofControllerTest { assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); } + @Test + public void testGetAllProofsByTheoremName() { + final ProofDto proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); + listOfProofs.add(proofDto); + listOfProofs.add(proofDto); + + when(proofRepository.findByTheoremName(anyString())).thenReturn(listOfProofs); + + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof)); + } + + @Test + public void testGetAllProfsByTheoremName_nullTheoremName() { + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testGetAllProofsByTheoremName_noProofsFound() { + when(proofRepository.findByTheoremName(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test nonexistent branch"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + @Test public void testGetProofById() { final ProofDto proofDto = createProof(); @@ -121,6 +161,132 @@ public class ProofControllerTest { verify(proofRepository).findById(anyInt()); } + @Test + public void testInsertProof() { + final ProofDto proofDto = createProof(); + when(proofRepository.save(any(ProofDto.class))).thenReturn(proofDto); + + final ResponseEntity responseEntity = proofController.insertProof(proofDto, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); + assertEquals(proofDto, responseEntity.getBody()); + verify(proofRepository).save(any(ProofDto.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 ProofDto proofDto = createProof(); + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = proofController.insertProof(proofDto, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof() { + final ProofDto existingProof = createProof(); + existingProof.setId(1); + existingProof.setVersion(1); + final ProofDto proofUpdate = new ProofDto(); + proofUpdate.setTheoremName("Test Update"); + final ProofDto updatedProof = existingProof; + updatedProof.setTheoremName("Test Update"); + when(proofRepository.findById(anyInt())).thenReturn(Optional.of(existingProof)); + when(proofRepository.save(any(ProofDto.class))).thenReturn(updatedProof); + + final ResponseEntity responseEntity = proofController.updateProof(1, proofUpdate, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(updatedProof, responseEntity.getBody()); + verify(proofRepository).findById(anyInt()); + verify(proofRepository).save(any(ProofDto.class)); + } + + @Test + public void testUpdateProof_bindingResultHasErrors() { + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof_proofDtoIsNull() { + final ResponseEntity responseEntity = proofController.updateProof(1, null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof_idIsNull() { + final ResponseEntity responseEntity = proofController.updateProof(null, createProof(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(proofRepository); + } + + @Test + public void testUpdateProof_theoremDoesNotExist() { + when(proofRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verify(proofRepository, times(0)).save(any(ProofDto.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 ProofDto createProof() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); @@ -131,7 +297,7 @@ public class ProofControllerTest { referencedDefinitionsList.add("test definition 2"); final ProofDto proofDto = new ProofDto(); - proofDto.setName("Test proof"); + proofDto.setTheoremName("Test proof"); proofDto.setBranch("Test branch"); proofDto.setDateCreated(new Date()); proofDto.setReferencedTheorems(referencedTheoremsList); From 52a21e72f3d484659a27b9d98333da1a2b65a3b4 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 12:51:48 -0600 Subject: [PATCH 23/34] PAN-52 Updated logging formats --- .../controller/AccountController.java | 44 +++++++------- .../controller/DefinitionController.java | 36 +++++------ .../controller/ProofController.java | 28 ++++----- .../controller/TheoremController.java | 60 +++++++++---------- 4 files changed, 84 insertions(+), 84 deletions(-) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index 2f60c56..e3514c0 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -40,8 +40,8 @@ public class AccountController { 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); } @@ -49,13 +49,13 @@ public class AccountController { @GetMapping("/{id}") public @ResponseBody ResponseEntity getAccountById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for account with id " + 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(); @@ -63,13 +63,13 @@ 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 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); } ); @@ -78,13 +78,13 @@ public class AccountController { @GetMapping("/{username}") public @ResponseBody ResponseEntity getAccountByUsername(@PathVariable("username") final String username) { - LOG.info("Received request to query for account with username " + 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(); @@ -92,13 +92,13 @@ 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 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); } ); @@ -144,7 +144,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()); LOG.info("Returning the newly created account"); return new ResponseEntity<>(savedAccount, HttpStatus.CREATED); } @@ -170,7 +170,7 @@ 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(); @@ -179,18 +179,18 @@ 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()); 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()); 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(); @@ -198,20 +198,20 @@ 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<>(updatedAccount, HttpStatus.OK); } @DeleteMapping("/{id}") public @ResponseBody ResponseEntity deleteAccountById(@PathVariable("id") final Integer id) { - LOG.info("Received request to delete account with id " + id); + LOG.info("Received request to delete account with id {}", id); if (id == null) { LOG.error("Specified Id is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Deleting account with id " + id); + LOG.debug("Deleting account with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -220,7 +220,7 @@ public class AccountController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index 3c8b4d1..cea5119 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -37,8 +37,8 @@ public class DefinitionController { 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); } @@ -46,13 +46,13 @@ public class DefinitionController { @GetMapping("/{id}") public @ResponseBody ResponseEntity getDefinitionById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for definition with id " + 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(); @@ -61,13 +61,13 @@ 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 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); }); @@ -97,9 +97,9 @@ public class DefinitionController { final DefinitionDto savedDefinition = definitionRepository.save(definitionDto); 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); } @@ -124,7 +124,7 @@ 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(); @@ -133,18 +133,18 @@ 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()); 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()); 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(); @@ -152,20 +152,20 @@ 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<>(updatedDefinition, HttpStatus.OK); } @DeleteMapping("/{id}") public @ResponseBody ResponseEntity deleteDefinitionById(@PathVariable("id") final Integer id) { - LOG.info("Received request to delete definition with id " + id); + LOG.info("Received request to delete definition with id {}", id); if (id == null) { LOG.error("Specified id is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Deleting definition with id " + id); + LOG.debug("Deleting definition with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -174,7 +174,7 @@ public class DefinitionController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index 373b79d..a28b345 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -37,8 +37,8 @@ public class ProofController { stopWatch.stop(); - LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all theorems with size " + listOfProofs.size()); + 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); } @@ -46,13 +46,13 @@ public class ProofController { @GetMapping("/{id}") public @ResponseBody ResponseEntity getProofById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for proof with id " + 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); + LOG.debug("Querying for proof with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -61,13 +61,13 @@ public class ProofController { 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 proof.map(proofDto -> { - LOG.info("Returning proof with id " + id); + LOG.info("Returning proof with id {}", id); return new ResponseEntity<>(proofDto, HttpStatus.OK); }).orElseGet( () -> { - LOG.warn("No proof was found with id " + id); + LOG.warn("No proof was found with id {}", id); return new ResponseEntity<>(HttpStatus.NOT_FOUND); }); @@ -76,13 +76,13 @@ public class ProofController { @GetMapping("/{branch}") public @ResponseBody ResponseEntity> getAllProofsByBranch(@PathVariable("branch") final String branch) { - LOG.info("Received request to query for proofs related to the " + branch + " branch of mathematics"); + 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); + LOG.debug("Querying for proofs with branch {}", branch); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -91,8 +91,8 @@ public class ProofController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all proofs with size " + listOfProofs.size()); + 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); @@ -121,8 +121,8 @@ public class ProofController { stopWatch.stop(); - LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); - LOG.info("Returning list of all proofs with size " + listOfProofs.size()); + 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); @@ -184,7 +184,7 @@ public class ProofController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Checking for existence of proof with id " + id); + LOG.debug("Checking for existence of proof with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 2bebf44..55c2fda 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -37,8 +37,8 @@ public class TheoremController { 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); } @@ -46,13 +46,13 @@ public class TheoremController { @GetMapping("/{branch}") public @ResponseBody ResponseEntity> getAllTheoremsByBranch(@PathVariable("branch") final String branch) { - LOG.info("Received request to query for theorems related to the " + branch + " branch of mathematics"); + 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(); @@ -61,8 +61,8 @@ public class TheoremController { 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); @@ -76,13 +76,13 @@ public class TheoremController { @GetMapping("/{proven_status}") public @ResponseBody ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { - LOG.info("Received request to query for theorems whose proven status is " + provenStatus); + 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(); @@ -91,8 +91,8 @@ public class TheoremController { 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); @@ -106,13 +106,13 @@ public class TheoremController { @GetMapping("/{name}") public @ResponseBody ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { - LOG.info("Received request to query for theorems whose name is " + 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); + LOG.debug("Querying for theorems with name {}", name); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -121,8 +121,8 @@ public class TheoremController { 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 with name {}", name); @@ -136,13 +136,13 @@ public class TheoremController { @GetMapping("/{id}") public @ResponseBody ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { - LOG.info("Received request to query for theorem with id " + 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(); @@ -151,13 +151,13 @@ 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 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); }); @@ -187,9 +187,9 @@ public class TheoremController { final TheoremDto savedTheorem = theoremRepository.save(theoremDto); 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); } @@ -214,7 +214,7 @@ 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(); @@ -223,18 +223,18 @@ 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()); 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()); 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(); @@ -242,20 +242,20 @@ 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<>(updatedTheorem, HttpStatus.OK); } @DeleteMapping("/{id}") public @ResponseBody ResponseEntity deleteTheoremById(@PathVariable("id") final Integer id) { - LOG.info("Received request to delete theorem with id " + id); + LOG.info("Received request to delete theorem with id {}", id); if (id == null) { LOG.error("Specified id is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.debug("Deleting theorem with id " + id); + LOG.debug("Deleting theorem with id {}", id); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); @@ -264,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); } From 2c03c7593826efdad68bf48eebfb443fe76acc39 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 13:58:51 -0600 Subject: [PATCH 24/34] PAN-52 Fixed a typo in the parameter arguments --- .travis.yml | 2 +- .../persistence/controller/AccountController.java | 12 ++++++------ .../controller/DefinitionController.java | 4 ++-- .../persistence/controller/ProofController.java | 14 +++++++------- .../persistence/controller/TheoremController.java | 14 +++++++------- 5 files changed, 23 insertions(+), 23 deletions(-) diff --git a/.travis.yml b/.travis.yml index b506b1b..5be1637 100644 --- a/.travis.yml +++ b/.travis.yml @@ -38,5 +38,5 @@ jobs: script: ./gradlew test - stage: Integration Tests script: ./gradlew integrationTest - - stage: Sonar analysis + - stage: Sonar Analysis script: ./gradlew sonar diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index e3514c0..1901141 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -26,7 +26,7 @@ import java.util.Optional; public class AccountController { private final AccountsRepository accountsRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody ResponseEntity> getListOfAccounts() { LOG.info("Received request to list all accounts"); @@ -46,9 +46,9 @@ public class AccountController { return new ResponseEntity<>(listOfAccounts, HttpStatus.OK); } - @GetMapping("/{id}") + @GetMapping("/id") public @ResponseBody - ResponseEntity getAccountById(@PathVariable("id") final Integer id) { + ResponseEntity getAccountById(@RequestParam("id") final Integer id) { LOG.info("Received request to query for account with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -75,9 +75,9 @@ public class AccountController { ); } - @GetMapping("/{username}") + @GetMapping("/username") public @ResponseBody - ResponseEntity getAccountByUsername(@PathVariable("username") final String username) { + ResponseEntity getAccountByUsername(@RequestParam("username") final String username) { LOG.info("Received request to query for account with username {}", username); if (username == null) { LOG.error("ERROR: username was null"); @@ -104,7 +104,7 @@ public class AccountController { ); } - @PostMapping("/") + @PostMapping({"","/"}) @Validated({AccountDto.Insert.class, Default.class}) public @ResponseBody ResponseEntity insertAccount( @Valid @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index cea5119..3bfb879 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -24,7 +24,7 @@ import java.util.Optional; public class DefinitionController { private final DefinitionRepository definitionRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody ResponseEntity> getAllDefinitions() { LOG.info("Received request to list all definitions"); @@ -73,7 +73,7 @@ public class DefinitionController { } - @PostMapping("/") + @PostMapping({"","/"}) @Validated({DefinitionDto.Insert.class, Default.class}) public @ResponseBody ResponseEntity insertDefinition( @Valid @RequestBody final DefinitionDto definitionDto, diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index a28b345..9e64591 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -24,7 +24,7 @@ import java.util.Optional; public class ProofController { private final ProofRepository proofRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody ResponseEntity> getAllProofs() { LOG.info("Received request to list all theorems"); @@ -43,9 +43,9 @@ public class ProofController { return new ResponseEntity<>(listOfProofs, HttpStatus.OK); } - @GetMapping("/{id}") + @GetMapping("/id") public @ResponseBody - ResponseEntity getProofById(@PathVariable("id") final Integer id) { + ResponseEntity getProofById(@RequestParam("id") final Integer id) { LOG.info("Received request to query for proof with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -73,9 +73,9 @@ public class ProofController { } - @GetMapping("/{branch}") + @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllProofsByBranch(@PathVariable("branch") final String branch) { + ResponseEntity> getAllProofsByBranch(@RequestParam("branch") final String branch) { LOG.info("Received request to query for proofs related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); @@ -103,7 +103,7 @@ public class ProofController { return new ResponseEntity<>(listOfProofs, HttpStatus.OK); } - @GetMapping("/{theorem_name}") + @GetMapping("/theorem_name") public @ResponseBody ResponseEntity> getAllProofsByTheoremName(@PathVariable("theorem_name") final String theoremName) { LOG.info("Received request to query for proofs of the theorem {}", theoremName); @@ -133,7 +133,7 @@ public class ProofController { return new ResponseEntity<>(listOfProofs, HttpStatus.OK); } - @PostMapping("/") + @PostMapping({"","/"}) @Validated({ProofDto.Insert.class, Default.class}) public @ResponseBody ResponseEntity insertProof( @Valid @RequestBody final ProofDto proofDto, diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 55c2fda..c0f2b83 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -24,7 +24,7 @@ import java.util.Optional; public class TheoremController { private final TheoremRepository theoremRepository; - @GetMapping("/") + @GetMapping({"","/"}) public @ResponseBody ResponseEntity> getAllTheorems() { LOG.info("Received request to list all theorems"); @@ -43,9 +43,9 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{branch}") + @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllTheoremsByBranch(@PathVariable("branch") final String branch) { + ResponseEntity> getAllTheoremsByBranch(@RequestParam("branch") final String branch) { LOG.info("Received request to query for theorems related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); @@ -73,7 +73,7 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{proven_status}") + @GetMapping("/proven_status") public @ResponseBody ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { LOG.info("Received request to query for theorems whose proven status is {}", provenStatus); @@ -103,7 +103,7 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{name}") + @GetMapping("/name") public @ResponseBody ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { LOG.info("Received request to query for theorems whose name is {}", name); @@ -133,7 +133,7 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } - @GetMapping("/{id}") + @GetMapping("/id") public @ResponseBody ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { LOG.info("Received request to query for theorem with id {}", id); @@ -163,7 +163,7 @@ public class TheoremController { } - @PostMapping("/") + @PostMapping({"","/"}) @Validated({TheoremDto.Insert.class, Default.class}) public @ResponseBody ResponseEntity insertTheorem( @Valid @RequestBody final TheoremDto theoremDto, From 1de1f7a5fccbefad43eee63506d37d255312260f Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 14:26:54 -0600 Subject: [PATCH 25/34] PAN-52 Finished integration tests for the proofs repository --- .../persistence/ProofsIntegrationTest.java | 88 +++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java new file mode 100644 index 0000000..3d2abc8 --- /dev/null +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -0,0 +1,88 @@ +package edu.msudenver.tsp.persistence; + +import edu.msudenver.tsp.persistence.dto.ProofDto; +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 ProofDto proofDto = createProof(); + final ProofDto savedProof = proofRepository.save(proofDto); + + 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(savedProof.getLastUpdated().toString().trim(), savedProof.getDateCreated().toString().trim()); + 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 ProofDto 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(proofDto); + final Optional deletedProof = proofRepository.findById(id); + assertFalse(deletedProof.isPresent()); + } + + private ProofDto createProof() { + final List referencedTheoremsList = new ArrayList<>(); + referencedTheoremsList.add("test theorem 1"); + referencedTheoremsList.add("test theorem 2"); + + final List referencedDefinitionsList = new ArrayList<>(); + referencedDefinitionsList.add("test definition 1"); + referencedDefinitionsList.add("test definition 2"); + + final ProofDto proofDto = new ProofDto(); + proofDto.setTheoremName("Test proof"); + proofDto.setBranch("Test branch"); + proofDto.setDateCreated(new Date()); + proofDto.setReferencedTheorems(referencedTheoremsList); + proofDto.setReferencedDefinitions(referencedDefinitionsList); + + return proofDto; + } +} From a85bf67d08a500614214be024c245ca188cc4712 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 14:36:44 -0600 Subject: [PATCH 26/34] PAN-57 Refactored the Definition DTO --- .../DefinitionsIntegrationTest.java | 20 ++++++------------- .../persistence/ProofsIntegrationTest.java | 1 - .../tsp/persistence/dto/Definition.java | 17 ---------------- .../tsp/persistence/dto/DefinitionDto.java | 5 +++-- .../tsp/persistence/dto/Notation.java | 16 --------------- .../tsp/persistence/dto/NotationDto.java | 4 ---- .../controller/DefinitionControllerTest.java | 12 ++--------- 7 files changed, 11 insertions(+), 64 deletions(-) delete mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java delete mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java delete mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java index 93db37e..2b2a6c1 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java @@ -1,8 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.Definition; import edu.msudenver.tsp.persistence.dto.DefinitionDto; -import edu.msudenver.tsp.persistence.dto.Notation; import edu.msudenver.tsp.persistence.repository.DefinitionRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -35,8 +33,8 @@ public class DefinitionsIntegrationTest { assertNotNull(savedDefinition.getDefinition()); assertNotNull(savedDefinition.getNotation()); - final List definitionsList = savedDefinition.getDefinition().getDefinitions(); - final List notationList = savedDefinition.getNotation().getNotations(); + final List definitionsList = savedDefinition.getDefinition(); + final List notationList = savedDefinition.getNotation(); assertEquals(2, definitionsList.size()); assertEquals(1, notationList.size()); @@ -52,8 +50,8 @@ public class DefinitionsIntegrationTest { assertNotNull(updatedDefinition.getDefinition()); assertNotNull(updatedDefinition.getNotation()); - final List updatedDefinitionsList = updatedDefinition.getDefinition().getDefinitions(); - final List updatedNotationsList = updatedDefinition.getNotation().getNotations(); + final List updatedDefinitionsList = updatedDefinition.getDefinition(); + final List updatedNotationsList = updatedDefinition.getNotation(); assertEquals(2, updatedDefinitionsList.size()); assertEquals(1, updatedNotationsList.size()); @@ -72,19 +70,13 @@ public class DefinitionsIntegrationTest { definitionList.add("Test definition 1"); definitionList.add("Test definition 2"); - final Definition definition = new Definition(); - definition.setDefinitions(definitionList); - final List notationList = new ArrayList<>(); notationList.add("\\testLaTeX"); - final Notation notation = new Notation(); - notation.setNotations(notationList); - final DefinitionDto definitionDto = new DefinitionDto(); definitionDto.setName("Test Name"); - definitionDto.setDefinition(definition); - definitionDto.setNotation(notation); + definitionDto.setDefinition(definitionList); + definitionDto.setNotation(notationList); return definitionDto; } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java index 3d2abc8..410b9ed 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -35,7 +35,6 @@ public class ProofsIntegrationTest { assertEquals("Test branch", savedProof.getBranch()); assertNotNull(savedProof.getDateCreated()); assertNotNull(savedProof.getLastUpdated()); - assertEquals(savedProof.getLastUpdated().toString().trim(), savedProof.getDateCreated().toString().trim()); assertEquals(2, savedProof.getReferencedTheorems().size()); assertEquals(2, savedProof.getReferencedDefinitions().size()); assertEquals("test theorem 1", savedProof.getReferencedTheorems().get(0)); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java deleted file mode 100644 index b2a26cb..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java +++ /dev/null @@ -1,17 +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 Definition implements Serializable { - private List definitions; - - private static final long serialVersionUID = -2208496232532214840L; -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java index 89583ad..1a3b78f 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java @@ -12,6 +12,7 @@ import javax.persistence.Table; import javax.validation.constraints.NotBlank; import javax.validation.constraints.Size; import java.io.Serializable; +import java.util.List; @Entity(name = "definitions") @Table(name = "definitions") @@ -24,9 +25,9 @@ public class DefinitionDto extends BaseDto implements Serializable { 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 List definition; - @Type(type = "json") @Column(columnDefinition = "jsonb") private Notation notation; + @Type(type = "json") @Column(columnDefinition = "jsonb") private List notation; private static final long serialVersionUID = -5314619286352932857L; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java deleted file mode 100644 index 3936174..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java +++ /dev/null @@ -1,16 +0,0 @@ -package edu.msudenver.tsp.persistence.dto; - -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; - -import java.io.Serializable; -import java.util.List; - -@Getter -@Setter -@ToString -public class Notation implements Serializable { - private List notations; - private static final long serialVersionUID = 2301438318932336121L; -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java deleted file mode 100644 index feabde1..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/NotationDto.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dto; - -public class NotationDto extends BaseDto { -} diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java index e28cbb8..5c279ee 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java @@ -1,8 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.Definition; import edu.msudenver.tsp.persistence.dto.DefinitionDto; -import edu.msudenver.tsp.persistence.dto.Notation; import edu.msudenver.tsp.persistence.repository.DefinitionRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -216,19 +214,13 @@ public class DefinitionControllerTest { final List definitionList = new ArrayList<>(); definitionList.add("Test definition 1"); - final Definition definition = new Definition(); - definition.setDefinitions(definitionList); - final List notationList = new ArrayList<>(); notationList.add("\\testLaTeX"); - final Notation notation = new Notation(); - notation.setNotations(notationList); - final DefinitionDto definitionDto = new DefinitionDto(); definitionDto.setName("Test Name"); - definitionDto.setDefinition(definition); - definitionDto.setNotation(notation); + definitionDto.setDefinition(definitionList); + definitionDto.setNotation(notationList); return definitionDto; } From a13ab9715416417b08e0c3b95d20555c239e22e9 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 14:48:43 -0600 Subject: [PATCH 27/34] PAN-57 Refacted superfluous code --- .../persistence/AccountsIntegrationTest.java | 24 ++--- .../DefinitionsIntegrationTest.java | 22 ++-- .../persistence/ProofsIntegrationTest.java | 28 ++--- .../persistence/TheoremsIntegrationTest.java | 30 +++--- .../controller/AccountController.java | 42 ++++---- .../controller/DefinitionController.java | 32 +++--- .../controller/NotationController.java | 11 -- .../controller/ProofController.java | 40 +++---- .../controller/TheoremController.java | 44 ++++---- .../dto/{AccountDto.java => Account.java} | 2 +- .../{DefinitionDto.java => Definition.java} | 2 +- .../dto/{ProofDto.java => Proof.java} | 2 +- .../dto/{TheoremDto.java => Theorem.java} | 2 +- .../repository/AccountsRepository.java | 6 +- .../repository/DefinitionRepository.java | 4 +- .../repository/NotationRepository.java | 7 -- .../repository/ProofRepository.java | 8 +- .../repository/TheoremRepository.java | 10 +- .../controller/AccountControllerTest.java | 86 +++++++-------- .../controller/DefinitionControllerTest.java | 70 ++++++------ .../controller/ProofControllerTest.java | 88 +++++++-------- .../controller/TheoremControllerTest.java | 100 +++++++++--------- .../msudenver/tsp/services/dto/Account.java | 5 +- .../tsp/services/parser/ParserService.java | 27 +---- .../services/parser/ParserServiceTest.java | 10 +- 25 files changed, 331 insertions(+), 371 deletions(-) delete mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java rename persistence/src/main/java/edu/msudenver/tsp/persistence/dto/{AccountDto.java => Account.java} (96%) rename persistence/src/main/java/edu/msudenver/tsp/persistence/dto/{DefinitionDto.java => Definition.java} (94%) rename persistence/src/main/java/edu/msudenver/tsp/persistence/dto/{ProofDto.java => Proof.java} (97%) rename persistence/src/main/java/edu/msudenver/tsp/persistence/dto/{TheoremDto.java => Theorem.java} (97%) delete mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java index d442d01..42cce04 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -19,8 +19,8 @@ public class AccountsIntegrationTest { @Test public void testCRUDFunctionality() { - final AccountDto accountDto = createAccount(); - final AccountDto savedAccount = accountsRepository.save(accountDto); + final Account account = createAccount(); + final Account savedAccount = accountsRepository.save(account); assertNotNull(savedAccount); assertEquals(Integer.valueOf(0), savedAccount.getVersion()); @@ -33,25 +33,25 @@ public class AccountsIntegrationTest { savedAccount.setPassword("Test Update"); - final AccountDto updatedAccount = accountsRepository.save(savedAccount); + final Account updatedAccount = accountsRepository.save(savedAccount); assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); assertTrue(savedAccount.getAdministratorStatus()); assertEquals(updatedAccount.getId(), id); - accountsRepository.delete(accountDto); - final Optional deletedAccount = accountsRepository.findById(id); + accountsRepository.delete(account); + final Optional deletedAccount = accountsRepository.findById(id); assertFalse(deletedAccount.isPresent()); } - private AccountDto createAccount() { - final AccountDto accountDto = new AccountDto(); - accountDto.setUsername("Test username"); - accountDto.setPassword("test password"); - accountDto.setAdministratorStatus(true); + private Account createAccount() { + final Account account = new Account(); + account.setUsername("Test username"); + account.setPassword("test password"); + account.setAdministratorStatus(true); - return accountDto; + return account; } } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java index 2b2a6c1..2c91789 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Definition; import edu.msudenver.tsp.persistence.repository.DefinitionRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -21,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()); @@ -44,7 +44,7 @@ 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()); @@ -61,11 +61,11 @@ public class DefinitionsIntegrationTest { assertEquals(id, updatedDefinition.getId()); definitionRepository.delete(updatedDefinition); - final Optional deletedDefinition = definitionRepository.findById(id); + final Optional deletedDefinition = definitionRepository.findById(id); assertFalse(deletedDefinition.isPresent()); } - private DefinitionDto createDefinition() { + private Definition createDefinition() { final List definitionList = new ArrayList<>(); definitionList.add("Test definition 1"); definitionList.add("Test definition 2"); @@ -73,11 +73,11 @@ public class DefinitionsIntegrationTest { final List notationList = new ArrayList<>(); notationList.add("\\testLaTeX"); - final DefinitionDto definitionDto = new DefinitionDto(); - definitionDto.setName("Test Name"); - definitionDto.setDefinition(definitionList); - definitionDto.setNotation(notationList); + final Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); - return definitionDto; + return definition; } } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java index 410b9ed..4af0f76 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.ProofDto; +import edu.msudenver.tsp.persistence.dto.Proof; import edu.msudenver.tsp.persistence.repository.ProofRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -23,8 +23,8 @@ public class ProofsIntegrationTest { @Test public void testCRUDFunctionality() { - final ProofDto proofDto = createProof(); - final ProofDto savedProof = proofRepository.save(proofDto); + final Proof proof = createProof(); + final Proof savedProof = proofRepository.save(proof); assertNotNull(savedProof); assertEquals(Integer.valueOf(0), savedProof.getVersion()); @@ -44,7 +44,7 @@ public class ProofsIntegrationTest { savedProof.setBranch("Test Update"); - final ProofDto updatedProof = proofRepository.save(savedProof); + final Proof updatedProof = proofRepository.save(savedProof); assertNotNull(updatedProof); assertEquals(Integer.valueOf(0), updatedProof.getVersion()); @@ -61,12 +61,12 @@ public class ProofsIntegrationTest { assertEquals("test definition 2", updatedProof.getReferencedDefinitions().get(1)); assertEquals(updatedProof.getId(), id); - proofRepository.delete(proofDto); - final Optional deletedProof = proofRepository.findById(id); + proofRepository.delete(proof); + final Optional deletedProof = proofRepository.findById(id); assertFalse(deletedProof.isPresent()); } - private ProofDto createProof() { + private Proof createProof() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); referencedTheoremsList.add("test theorem 2"); @@ -75,13 +75,13 @@ public class ProofsIntegrationTest { referencedDefinitionsList.add("test definition 1"); referencedDefinitionsList.add("test definition 2"); - final ProofDto proofDto = new ProofDto(); - proofDto.setTheoremName("Test proof"); - proofDto.setBranch("Test branch"); - proofDto.setDateCreated(new Date()); - proofDto.setReferencedTheorems(referencedTheoremsList); - proofDto.setReferencedDefinitions(referencedDefinitionsList); + final Proof proof = new Proof(); + proof.setTheoremName("Test proof"); + proof.setBranch("Test branch"); + proof.setDateCreated(new Date()); + proof.setReferencedTheorems(referencedTheoremsList); + proof.setReferencedDefinitions(referencedDefinitionsList); - return proofDto; + return proof; } } diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java index a6109f2..d5c22c3 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import edu.msudenver.tsp.persistence.dto.TheoremType; import edu.msudenver.tsp.persistence.repository.TheoremRepository; import org.junit.Test; @@ -22,8 +22,8 @@ public class TheoremsIntegrationTest { @Test public void testCRUDFunctionality() { - final TheoremDto theoremDto = createTheorem(); - final TheoremDto savedTheorem = theoremRepository.save(theoremDto); + final Theorem theorem = createTheorem(); + final Theorem savedTheorem = theoremRepository.save(theorem); assertNotNull(savedTheorem); assertEquals(Integer.valueOf(0), savedTheorem.getVersion()); @@ -42,7 +42,7 @@ public class TheoremsIntegrationTest { savedTheorem.setBranch("Test Update"); - final TheoremDto updatedTheorem = theoremRepository.save(savedTheorem); + final Theorem updatedTheorem = theoremRepository.save(savedTheorem); assertNotNull(updatedTheorem); assertEquals(Integer.valueOf(0), updatedTheorem.getVersion()); @@ -57,12 +57,12 @@ public class TheoremsIntegrationTest { assertEquals("test definition 2", updatedTheorem.getReferencedDefinitions().get(1)); assertEquals(updatedTheorem.getId(), id); - theoremRepository.delete(theoremDto); - final Optional deletedTheorem = theoremRepository.findById(id); + theoremRepository.delete(theorem); + final Optional deletedTheorem = theoremRepository.findById(id); assertFalse(deletedTheorem.isPresent()); } - private TheoremDto createTheorem() { + private Theorem createTheorem() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); referencedTheoremsList.add("test theorem 2"); @@ -71,14 +71,14 @@ public class TheoremsIntegrationTest { referencedDefinitionsList.add("test definition 1"); referencedDefinitionsList.add("test definition 2"); - final TheoremDto theoremDto = new TheoremDto(); - theoremDto.setName("Test theorem"); - theoremDto.setBranch("Test branch"); - theoremDto.setProvenStatus(true); - theoremDto.setTheoremType(TheoremType.THEOREM); - theoremDto.setReferencedTheorems(referencedTheoremsList); - theoremDto.setReferencedDefinitions(referencedDefinitionsList); + final Theorem theorem = new Theorem(); + theorem.setName("Test theorem"); + theorem.setBranch("Test branch"); + theorem.setProvenStatus(true); + theorem.setTheoremType(TheoremType.THEOREM); + theorem.setReferencedTheorems(referencedTheoremsList); + theorem.setReferencedDefinitions(referencedDefinitionsList); - return theoremDto; + return theorem; } } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java index 1901141..3301f65 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -28,7 +28,7 @@ public class AccountController { @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getListOfAccounts() { + ResponseEntity> getListOfAccounts() { LOG.info("Received request to list all accounts"); LOG.debug("Querying for list of accounts"); @@ -36,7 +36,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfAccounts = (List) accountsRepository.findAll(); + final List listOfAccounts = (List) accountsRepository.findAll(); stopWatch.stop(); @@ -48,7 +48,7 @@ public class AccountController { @GetMapping("/id") public @ResponseBody - ResponseEntity getAccountById(@RequestParam("id") final Integer id) { + ResponseEntity getAccountById(@RequestParam("id") final Integer id) { LOG.info("Received request to query for account with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -59,7 +59,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional account = accountsRepository.findById(id); + final Optional account = accountsRepository.findById(id); stopWatch.stop(); @@ -77,7 +77,7 @@ public class AccountController { @GetMapping("/username") public @ResponseBody - ResponseEntity getAccountByUsername(@RequestParam("username") final String username) { + ResponseEntity getAccountByUsername(@RequestParam("username") final String username) { LOG.info("Received request to query for account with username {}", username); if (username == null) { LOG.error("ERROR: username was null"); @@ -88,7 +88,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional account = accountsRepository.findByUsername(username); + final Optional account = accountsRepository.findByUsername(username); stopWatch.stop(); @@ -105,9 +105,9 @@ public class AccountController { } @PostMapping({"","/"}) - @Validated({AccountDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertAccount( - @Valid @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { + @Validated({Account.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertAccount( + @Valid @RequestBody final Account account, final BindingResult bindingResult) { LOG.info("Received request to insert a new account"); if (bindingResult.hasErrors()) { @@ -115,23 +115,23 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (accountDto == null) { + if (account == null) { LOG.error("Passed account is unprocessable"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - LOG.info("Checking for any existing users with username {}", accountDto.getUsername()); + LOG.info("Checking for any existing users with username {}", account.getUsername()); final Instant start = Instant.now(); LOG.debug("Querying for existing accounts"); - final Optional existingAccount = accountsRepository.findByUsername(accountDto.getUsername()); + final Optional existingAccount = accountsRepository.findByUsername(account.getUsername()); LOG.debug("Received response from the server: query took {} ms", Duration.between(start, Instant.now()).toMillis()); if (existingAccount.isPresent()) { - LOG.warn("An account already exists with username {}", accountDto.getUsername()); + LOG.warn("An account already exists with username {}", account.getUsername()); return new ResponseEntity<>(HttpStatus.CONFLICT); } @@ -140,7 +140,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final AccountDto savedAccount = accountsRepository.save(accountDto); + final Account savedAccount = accountsRepository.save(account); stopWatch.stop(); @@ -150,9 +150,9 @@ public class AccountController { } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateAccount( + public @ResponseBody ResponseEntity updateAccount( @PathVariable("id") final Integer id, - @RequestBody final AccountDto accountDto, final BindingResult bindingResult) { + @RequestBody final Account account, final BindingResult bindingResult) { LOG.info("Received request to update an account"); if (bindingResult.hasErrors()) { @@ -160,7 +160,7 @@ public class AccountController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (accountDto == null) { + if (account == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -175,7 +175,7 @@ public class AccountController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingAccount = accountsRepository.findById(id); + final Optional existingAccount = accountsRepository.findById(id); stopWatch.stop(); @@ -186,7 +186,7 @@ public class AccountController { 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); @@ -194,7 +194,7 @@ public class AccountController { stopWatch.start(); - final AccountDto updatedAccount = accountsRepository.save(existingAccount.get()); + final Account updatedAccount = accountsRepository.save(existingAccount.get()); stopWatch.stop(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java index 3bfb879..720e5df 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Definition; import edu.msudenver.tsp.persistence.repository.DefinitionRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -26,14 +26,14 @@ public class DefinitionController { @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getAllDefinitions() { + ResponseEntity> getAllDefinitions() { LOG.info("Received request to list all definitions"); LOG.debug("Querying for list of all definitions"); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfDefinitions = definitionRepository.findAll(); + final List listOfDefinitions = definitionRepository.findAll(); stopWatch.stop(); @@ -45,7 +45,7 @@ public class DefinitionController { @GetMapping("/{id}") public @ResponseBody - ResponseEntity getDefinitionById(@PathVariable("id") final Integer id) { + ResponseEntity getDefinitionById(@PathVariable("id") final Integer id) { LOG.info("Received request to query for definition with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -57,7 +57,7 @@ public class DefinitionController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional definition = definitionRepository.findById(id); + final Optional definition = definitionRepository.findById(id); stopWatch.stop(); @@ -74,9 +74,9 @@ public class DefinitionController { } @PostMapping({"","/"}) - @Validated({DefinitionDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertDefinition( - @Valid @RequestBody final DefinitionDto definitionDto, + @Validated({Definition.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertDefinition( + @Valid @RequestBody final Definition definition, final BindingResult bindingResult) { LOG.info("Received request to insert a new definition"); if (bindingResult.hasErrors()) { @@ -84,7 +84,7 @@ public class DefinitionController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (definitionDto == null) { + if (definition == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -94,7 +94,7 @@ 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 {}ms to complete", stopWatch.getTotalTimeMillis()); @@ -104,9 +104,9 @@ public class DefinitionController { } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateDefinition( + public @ResponseBody ResponseEntity updateDefinition( @PathVariable("id") final Integer id, - @RequestBody final DefinitionDto definitionDto, final BindingResult bindingResult) { + @RequestBody final Definition definition, final BindingResult bindingResult) { LOG.info("Received request to update an account"); if (bindingResult.hasErrors()) { @@ -114,7 +114,7 @@ public class DefinitionController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (definitionDto == null) { + if (definition == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -129,7 +129,7 @@ public class DefinitionController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingDefinition = definitionRepository.findById(id); + final Optional existingDefinition = definitionRepository.findById(id); stopWatch.stop(); @@ -140,7 +140,7 @@ public class DefinitionController { 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); @@ -148,7 +148,7 @@ public class DefinitionController { stopWatch.start(); - final DefinitionDto updatedDefinition = definitionRepository.save(existingDefinition.get()); + final Definition updatedDefinition = definitionRepository.save(existingDefinition.get()); stopWatch.stop(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java deleted file mode 100644 index b68bad1..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.persistence.controller; - -import edu.msudenver.tsp.persistence.repository.NotationRepository; -import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; - -@Component -@AllArgsConstructor -public class NotationController { - private final NotationRepository notationRepository; -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java index 9e64591..e60659a 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.ProofDto; +import edu.msudenver.tsp.persistence.dto.Proof; import edu.msudenver.tsp.persistence.repository.ProofRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -26,14 +26,14 @@ public class ProofController { @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getAllProofs() { + ResponseEntity> getAllProofs() { LOG.info("Received request to list all theorems"); LOG.debug("Querying for list of all theorems"); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfProofs = proofRepository.findAll(); + final List listOfProofs = proofRepository.findAll(); stopWatch.stop(); @@ -45,7 +45,7 @@ public class ProofController { @GetMapping("/id") public @ResponseBody - ResponseEntity getProofById(@RequestParam("id") final Integer id) { + ResponseEntity getProofById(@RequestParam("id") final Integer id) { LOG.info("Received request to query for proof with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -57,7 +57,7 @@ public class ProofController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional proof = proofRepository.findById(id); + final Optional proof = proofRepository.findById(id); stopWatch.stop(); @@ -75,7 +75,7 @@ public class ProofController { @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllProofsByBranch(@RequestParam("branch") final String branch) { + ResponseEntity> getAllProofsByBranch(@RequestParam("branch") final String branch) { LOG.info("Received request to query for proofs related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); @@ -87,7 +87,7 @@ public class ProofController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfProofs = proofRepository.findByBranch(branch); + final List listOfProofs = proofRepository.findByBranch(branch); stopWatch.stop(); @@ -105,7 +105,7 @@ public class ProofController { @GetMapping("/theorem_name") public @ResponseBody - ResponseEntity> getAllProofsByTheoremName(@PathVariable("theorem_name") final String theoremName) { + ResponseEntity> getAllProofsByTheoremName(@PathVariable("theorem_name") final String theoremName) { LOG.info("Received request to query for proofs of the theorem {}", theoremName); if (theoremName == null) { LOG.error("ERROR: theorem name was null"); @@ -117,7 +117,7 @@ public class ProofController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfProofs = proofRepository.findByTheoremName(theoremName); + final List listOfProofs = proofRepository.findByTheoremName(theoremName); stopWatch.stop(); @@ -134,9 +134,9 @@ public class ProofController { } @PostMapping({"","/"}) - @Validated({ProofDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertProof( - @Valid @RequestBody final ProofDto proofDto, + @Validated({Proof.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertProof( + @Valid @RequestBody final Proof proof, final BindingResult bindingResult) { LOG.info("Received request to insert a new proof"); if (bindingResult.hasErrors()) { @@ -144,7 +144,7 @@ public class ProofController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (proofDto == null) { + if (proof == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -154,7 +154,7 @@ public class ProofController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final ProofDto savedProof = proofRepository.save(proofDto); + final Proof savedProof = proofRepository.save(proof); stopWatch.stop(); LOG.debug("Received response from server: query took {}ms to complete", stopWatch.getTotalTimeMillis()); @@ -164,9 +164,9 @@ public class ProofController { } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateProof( + public @ResponseBody ResponseEntity updateProof( @PathVariable("id") final Integer id, - @RequestBody final ProofDto proofDto, final BindingResult bindingResult) { + @RequestBody final Proof proof, final BindingResult bindingResult) { LOG.info("Received request to update a proof"); if (bindingResult.hasErrors()) { @@ -174,7 +174,7 @@ public class ProofController { return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); } - if (proofDto == null) { + if (proof == null) { LOG.error("Passed entity is null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } @@ -189,7 +189,7 @@ public class ProofController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingProof = proofRepository.findById(id); + final Optional existingProof = proofRepository.findById(id); stopWatch.stop(); @@ -200,7 +200,7 @@ public class ProofController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - PersistenceUtilities.copyNonNullProperties(proofDto, existingProof.get()); + PersistenceUtilities.copyNonNullProperties(proof, existingProof.get()); existingProof.get().setVersion(existingProof.get().getVersion()+ 1); LOG.info("Updating proof with id {}", id); @@ -208,7 +208,7 @@ public class ProofController { stopWatch.start(); - final ProofDto updatedProof = proofRepository.save(existingProof.get()); + final Proof updatedProof = proofRepository.save(existingProof.get()); stopWatch.stop(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index c0f2b83..ef0e760 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import edu.msudenver.tsp.persistence.repository.TheoremRepository; import edu.msudenver.tsp.utilities.PersistenceUtilities; import lombok.AllArgsConstructor; @@ -26,14 +26,14 @@ public class TheoremController { @GetMapping({"","/"}) public @ResponseBody - ResponseEntity> getAllTheorems() { + ResponseEntity> getAllTheorems() { LOG.info("Received request to list all theorems"); LOG.debug("Querying for list of all theorems"); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findAll(); + final List listOfTheorems = theoremRepository.findAll(); stopWatch.stop(); @@ -45,7 +45,7 @@ public class TheoremController { @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllTheoremsByBranch(@RequestParam("branch") final String branch) { + ResponseEntity> getAllTheoremsByBranch(@RequestParam("branch") final String branch) { LOG.info("Received request to query for theorems related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); @@ -57,7 +57,7 @@ public class TheoremController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByBranch(branch); + final List listOfTheorems = theoremRepository.findByBranch(branch); stopWatch.stop(); @@ -75,7 +75,7 @@ public class TheoremController { @GetMapping("/proven_status") public @ResponseBody - ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { + ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { LOG.info("Received request to query for theorems whose proven status is {}", provenStatus); if (provenStatus == null) { LOG.error("ERROR: status was null"); @@ -87,7 +87,7 @@ public class TheoremController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByProvenStatus(provenStatus); + final List listOfTheorems = theoremRepository.findByProvenStatus(provenStatus); stopWatch.stop(); @@ -105,7 +105,7 @@ public class TheoremController { @GetMapping("/name") public @ResponseBody - ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { + ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { LOG.info("Received request to query for theorems whose name is {}", name); if (name == null) { LOG.error("ERROR: name was null"); @@ -117,7 +117,7 @@ public class TheoremController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByName(name); + final List listOfTheorems = theoremRepository.findByName(name); stopWatch.stop(); @@ -135,7 +135,7 @@ public class TheoremController { @GetMapping("/id") public @ResponseBody - ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { + ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { LOG.info("Received request to query for theorem with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); @@ -147,7 +147,7 @@ public class TheoremController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional theorem = theoremRepository.findById(id); + final Optional theorem = theoremRepository.findById(id); stopWatch.stop(); @@ -164,9 +164,9 @@ public class TheoremController { } @PostMapping({"","/"}) - @Validated({TheoremDto.Insert.class, Default.class}) - public @ResponseBody ResponseEntity insertTheorem( - @Valid @RequestBody final TheoremDto theoremDto, + @Validated({Theorem.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertTheorem( + @Valid @RequestBody final Theorem theorem, final BindingResult bindingResult) { LOG.info("Received request to insert a new theorem"); if (bindingResult.hasErrors()) { @@ -174,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); } @@ -184,7 +184,7 @@ 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 {}ms to complete", stopWatch.getTotalTimeMillis()); @@ -194,9 +194,9 @@ public class TheoremController { } @PatchMapping("/{id}") - public @ResponseBody ResponseEntity updateTheorem( + public @ResponseBody ResponseEntity updateTheorem( @PathVariable("id") final Integer id, - @RequestBody final TheoremDto theoremDto, final BindingResult bindingResult) { + @RequestBody final Theorem theorem, final BindingResult bindingResult) { LOG.info("Received request to update a theorem"); if (bindingResult.hasErrors()) { @@ -204,7 +204,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); } @@ -219,7 +219,7 @@ public class TheoremController { final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final Optional existingTheorem = theoremRepository.findById(id); + final Optional existingTheorem = theoremRepository.findById(id); stopWatch.stop(); @@ -230,7 +230,7 @@ public class TheoremController { 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); @@ -238,7 +238,7 @@ public class TheoremController { stopWatch.start(); - final TheoremDto updatedTheorem = theoremRepository.save(existingTheorem.get()); + final Theorem updatedTheorem = theoremRepository.save(existingTheorem.get()); stopWatch.stop(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java similarity index 96% rename from persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java rename to persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java index 2f71c71..a8fa430 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java @@ -16,7 +16,7 @@ import java.util.Date; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class AccountDto extends BaseDto implements Serializable { +public class Account extends BaseDto implements Serializable { @NotBlank(groups = Insert.class, message = "A username must be specified") @Size(max = 50) private String username; @NotBlank(groups = Insert.class, message = "A password must be specified") @Size(max = 256) private String password; @NotNull @Column(name = "administrator_status") private boolean administratorStatus; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java similarity index 94% rename from persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java rename to persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java index 1a3b78f..b18d743 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java @@ -19,7 +19,7 @@ import java.util.List; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class DefinitionDto extends BaseDto implements Serializable { +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; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java similarity index 97% rename from persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java rename to persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java index fdb6e76..683039b 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java @@ -17,7 +17,7 @@ import java.util.List; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class ProofDto extends BaseDto implements Serializable { +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") diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java similarity index 97% rename from persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java rename to persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java index db10620..14e1da1 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremDto.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java @@ -19,7 +19,7 @@ import java.util.List; @EntityListeners(AuditingEntityListener.class) @Data @EqualsAndHashCode(callSuper = true) -public class TheoremDto extends BaseDto implements Serializable { +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; diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java index add1182..cfb0729 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java @@ -1,12 +1,12 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; import java.util.Optional; @Repository -public interface AccountsRepository extends CrudRepository { - Optional findByUsername(String username); +public interface AccountsRepository extends CrudRepository { + Optional findByUsername(String username); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java index 1cda40a..1b90a38 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java @@ -1,11 +1,11 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Definition; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository -public interface DefinitionRepository extends JpaRepository { +public interface DefinitionRepository extends JpaRepository { } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java deleted file mode 100644 index 47f0904..0000000 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java +++ /dev/null @@ -1,7 +0,0 @@ -package edu.msudenver.tsp.persistence.repository; - -import edu.msudenver.tsp.persistence.dto.BaseDto; -import org.springframework.data.repository.CrudRepository; - -public interface NotationRepository extends CrudRepository { -} diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java index 9aa16e9..8988aeb 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -1,13 +1,13 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.ProofDto; +import edu.msudenver.tsp.persistence.dto.Proof; import org.springframework.data.jpa.repository.JpaRepository; import java.util.List; -public interface ProofRepository extends JpaRepository { +public interface ProofRepository extends JpaRepository { - List findByBranch(String branch); + List findByBranch(String branch); - List findByTheoremName(String name); + List findByTheoremName(String name); } diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 2e3c9f6..03a17db 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -1,17 +1,17 @@ package edu.msudenver.tsp.persistence.repository; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; import java.util.List; @Repository -public interface TheoremRepository extends JpaRepository { +public interface TheoremRepository extends JpaRepository { - List findByBranch(String branch); + List findByBranch(String branch); - List findByProvenStatus(Boolean provenStatus); + List findByProvenStatus(Boolean provenStatus); - List findByName(String name); + List findByName(String name); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java index 05a6ba9..503e2f6 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/AccountControllerTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import edu.msudenver.tsp.persistence.dto.Account; import edu.msudenver.tsp.persistence.repository.AccountsRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -33,14 +33,14 @@ public class AccountControllerTest { @Test public void testGetAllAccounts() { - final AccountDto accountDto = createAccount(); - final List accountDtoList = new ArrayList<>(); - accountDtoList.add(accountDto); - accountDtoList.add(accountDto); + final Account accountDto = createAccount(); + final List accountList = new ArrayList<>(); + accountList.add(accountDto); + accountList.add(accountDto); - when(accountsRepository.findAll()).thenReturn(accountDtoList); + when(accountsRepository.findAll()).thenReturn(accountList); - final ResponseEntity> responseEntity = accountController.getListOfAccounts(); + final ResponseEntity> responseEntity = accountController.getListOfAccounts(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -52,16 +52,16 @@ public class AccountControllerTest { @Test public void testGetAccountById() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(accountDto)); + final Account account = createAccount(); + when(accountsRepository.findById(anyInt())).thenReturn(Optional.ofNullable(account)); - final ResponseEntity responseEntity = accountController.getAccountById(1); + final ResponseEntity responseEntity = accountController.getAccountById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(accountDto, responseEntity.getBody()); + assertEquals(account, responseEntity.getBody()); verify(accountsRepository).findById(anyInt()); } @@ -89,16 +89,16 @@ public class AccountControllerTest { @Test public void testGetAccountByUsername() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.ofNullable(accountDto)); + final Account account = createAccount(); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.ofNullable(account)); - final ResponseEntity responseEntity = accountController.getAccountByUsername("Test username"); + final ResponseEntity responseEntity = accountController.getAccountByUsername("Test username"); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(accountDto, responseEntity.getBody()); + assertEquals(account, responseEntity.getBody()); verify(accountsRepository).findByUsername(anyString()); } @@ -126,32 +126,32 @@ public class AccountControllerTest { @Test public void testInsertAccount() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.save(any(AccountDto.class))).thenReturn(accountDto); + final Account account = createAccount(); + when(accountsRepository.save(any(Account.class))).thenReturn(account); when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(account, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(accountDto, responseEntity.getBody()); - verify(accountsRepository).save(any(AccountDto.class)); + assertEquals(account, responseEntity.getBody()); + verify(accountsRepository).save(any(Account.class)); } @Test public void testInsertAccount_usernameAlreadyExists() { - final AccountDto accountDto = createAccount(); - when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.of(accountDto)); + final Account account = createAccount(); + when(accountsRepository.findByUsername(anyString())).thenReturn(Optional.of(account)); - final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(account, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.CONFLICT, responseEntity.getStatusCode()); verify(accountsRepository).findByUsername(anyString()); - verify(accountsRepository, times(0)).save(any(AccountDto.class)); + verify(accountsRepository, times(0)).save(any(Account.class)); } @Test @@ -166,10 +166,10 @@ public class AccountControllerTest { @Test public void testInsertAccount_bindingResultHasErrors() { - final AccountDto accountDto = createAccount(); + final Account account = createAccount(); when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = accountController.insertAccount(accountDto, bindingResult); + final ResponseEntity responseEntity = accountController.insertAccount(account, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -179,31 +179,31 @@ public class AccountControllerTest { @Test public void testUpdateAccount() { - final AccountDto existingAccount = createAccount(); + final Account existingAccount = createAccount(); existingAccount.setId(1); existingAccount.setVersion(1); - final AccountDto accountUpdate = new AccountDto(); + final Account accountUpdate = new Account(); accountUpdate.setUsername("Test Update"); - final AccountDto updatedAccount = existingAccount; + final Account updatedAccount = existingAccount; updatedAccount.setUsername("Test Update"); when(accountsRepository.findById(anyInt())).thenReturn(Optional.of(existingAccount)); - when(accountsRepository.save(any(AccountDto.class))).thenReturn(updatedAccount); + when(accountsRepository.save(any(Account.class))).thenReturn(updatedAccount); - final ResponseEntity responseEntity = accountController.updateAccount(1, accountUpdate, bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, accountUpdate, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertEquals(updatedAccount, responseEntity.getBody()); verify(accountsRepository).findById(anyInt()); - verify(accountsRepository).save(any(AccountDto.class)); + verify(accountsRepository).save(any(Account.class)); } @Test public void testUpdateAccount_bindingResultHasErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -213,7 +213,7 @@ public class AccountControllerTest { @Test public void testUpdateAccount_accountsDtoIsNull() { - final ResponseEntity responseEntity = accountController.updateAccount(1, null, bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -223,7 +223,7 @@ public class AccountControllerTest { @Test public void testUpdateAccount_idIsNull() { - final ResponseEntity responseEntity = accountController.updateAccount(null, createAccount(), bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(null, createAccount(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -235,12 +235,12 @@ public class AccountControllerTest { public void testUpdateAccount_accountDoesNotExist() { when(accountsRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); + final ResponseEntity responseEntity = accountController.updateAccount(1, createAccount(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); - verify(accountsRepository, times(0)).save(any(AccountDto.class)); + verify(accountsRepository, times(0)).save(any(Account.class)); } @Test @@ -265,12 +265,12 @@ public class AccountControllerTest { verifyZeroInteractions(accountsRepository); } - private AccountDto createAccount() { - final AccountDto accountDto = new AccountDto(); - accountDto.setUsername("Test username"); - accountDto.setPassword("test password"); - accountDto.setAdministratorStatus(true); + private Account createAccount() { + final Account account = new Account(); + account.setUsername("Test username"); + account.setPassword("test password"); + account.setAdministratorStatus(true); - return accountDto; + return account; } } \ No newline at end of file diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java index 5c279ee..4b7fa77 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java @@ -1,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 org.junit.Test; import org.junit.runner.RunWith; @@ -30,14 +30,14 @@ public class DefinitionControllerTest { @Test public void testGetAllDefinitions() { - final DefinitionDto definitionDto = createDefinition(); - final List definitionDtoList = new ArrayList<>(); - definitionDtoList.add(definitionDto); - definitionDtoList.add(definitionDto); + final Definition definitionDto = createDefinition(); + final List definitionList = new ArrayList<>(); + definitionList.add(definitionDto); + definitionList.add(definitionDto); - when(definitionRepository.findAll()).thenReturn(definitionDtoList); + when(definitionRepository.findAll()).thenReturn(definitionList); - final ResponseEntity> responseEntity = definitionController.getAllDefinitions(); + final ResponseEntity> responseEntity = definitionController.getAllDefinitions(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -49,16 +49,16 @@ public class DefinitionControllerTest { @Test public void testGetDefinitionsById() { - final DefinitionDto definitionDto = createDefinition(); - when(definitionRepository.findById(anyInt())).thenReturn(Optional.ofNullable(definitionDto)); + final Definition definition = createDefinition(); + when(definitionRepository.findById(anyInt())).thenReturn(Optional.ofNullable(definition)); - final ResponseEntity responseEntity = definitionController.getDefinitionById(1); + final ResponseEntity responseEntity = definitionController.getDefinitionById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(definitionDto, responseEntity.getBody()); + assertEquals(definition, responseEntity.getBody()); verify(definitionRepository).findById(anyInt()); } @@ -86,17 +86,17 @@ public class DefinitionControllerTest { @Test public void testInsertDefinition() { - final DefinitionDto definitionDto = createDefinition(); - when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(definitionDto); + final Definition definition = createDefinition(); + when(definitionRepository.save(any(Definition.class))).thenReturn(definition); - final ResponseEntity responseEntity = definitionController.insertDefinition(definitionDto, bindingResult); + final ResponseEntity responseEntity = definitionController.insertDefinition(definition, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(definitionDto, responseEntity.getBody()); - verify(definitionRepository).save(any(DefinitionDto.class)); + assertEquals(definition, responseEntity.getBody()); + verify(definitionRepository).save(any(Definition.class)); } @Test @@ -111,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()); @@ -124,31 +124,31 @@ public class DefinitionControllerTest { @Test public void testUpdateDefinition() { - final DefinitionDto existingDefinition = createDefinition(); + final Definition existingDefinition = createDefinition(); existingDefinition.setId(1); existingDefinition.setVersion(1); - final DefinitionDto definitionUpdate = new DefinitionDto(); + final Definition definitionUpdate = new Definition(); definitionUpdate.setName("Test Update"); - final DefinitionDto updatedDefinition = existingDefinition; + final Definition updatedDefinition = existingDefinition; updatedDefinition.setName("Test Update"); when(definitionRepository.findById(anyInt())).thenReturn(Optional.of(existingDefinition)); - when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(updatedDefinition); + when(definitionRepository.save(any(Definition.class))).thenReturn(updatedDefinition); - final ResponseEntity responseEntity = definitionController.updateDefinition(1, definitionUpdate, bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(1, definitionUpdate, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertEquals(updatedDefinition, responseEntity.getBody()); verify(definitionRepository).findById(anyInt()); - verify(definitionRepository).save(any(DefinitionDto.class)); + verify(definitionRepository).save(any(Definition.class)); } @Test public void testUpdateDefinition_bindingResultErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -158,7 +158,7 @@ public class DefinitionControllerTest { @Test public void testUpdateDefinition_definitionDtoIsNull() { - final ResponseEntity responseEntity = definitionController.updateDefinition(1, null, bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -168,7 +168,7 @@ public class DefinitionControllerTest { @Test public void testUpdateDefinition_idIsNull() { - final ResponseEntity responseEntity = definitionController.updateDefinition(null, createDefinition(), bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(null, createDefinition(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -180,12 +180,12 @@ public class DefinitionControllerTest { public void testUpdateDefinition_definitionDoesntExist() { when(definitionRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); + final ResponseEntity responseEntity = definitionController.updateDefinition(1, createDefinition(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); - verify(definitionRepository, times(0)).save(any(DefinitionDto.class)); + verify(definitionRepository, times(0)).save(any(Definition.class)); } @Test @@ -210,18 +210,18 @@ public class DefinitionControllerTest { verifyZeroInteractions(definitionRepository); } - private DefinitionDto createDefinition() { + private Definition createDefinition() { final List definitionList = new ArrayList<>(); definitionList.add("Test definition 1"); final List notationList = new ArrayList<>(); notationList.add("\\testLaTeX"); - final DefinitionDto definitionDto = new DefinitionDto(); - definitionDto.setName("Test Name"); - definitionDto.setDefinition(definitionList); - definitionDto.setNotation(notationList); + final Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); - return definitionDto; + return definition; } } \ No newline at end of file diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java index 5536d06..6e77bb3 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.ProofDto; +import edu.msudenver.tsp.persistence.dto.Proof; import edu.msudenver.tsp.persistence.repository.ProofRepository; import org.junit.Test; import org.junit.runner.RunWith; @@ -27,14 +27,14 @@ public class ProofControllerTest { @Test public void testGetAllProofs() { - final ProofDto proofDto = createProof(); - final List listOfProofs = new ArrayList<>(); + final Proof proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); listOfProofs.add(proofDto); listOfProofs.add(proofDto); when(proofRepository.findAll()).thenReturn(listOfProofs); - final ResponseEntity> responseEntity = proofController.getAllProofs(); + final ResponseEntity> responseEntity = proofController.getAllProofs(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -46,14 +46,14 @@ public class ProofControllerTest { @Test public void testGetAllProofsByBranch() { - final ProofDto proofDto = createProof(); - final List listOfProofs = new ArrayList<>(); + final Proof proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); listOfProofs.add(proofDto); listOfProofs.add(proofDto); when(proofRepository.findByBranch(anyString())).thenReturn(listOfProofs); - final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test"); + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -65,7 +65,7 @@ public class ProofControllerTest { @Test public void testGetAllProfsByBranch_nullBranch() { - final ResponseEntity> responseEntity = proofController.getAllProofsByBranch(null); + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -77,7 +77,7 @@ public class ProofControllerTest { public void testGetAllProofsByBranch_noProofsFound() { when(proofRepository.findByBranch(anyString())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test nonexistent branch"); + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test nonexistent branch"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -86,14 +86,14 @@ public class ProofControllerTest { @Test public void testGetAllProofsByTheoremName() { - final ProofDto proofDto = createProof(); - final List listOfProofs = new ArrayList<>(); + final Proof proofDto = createProof(); + final List listOfProofs = new ArrayList<>(); listOfProofs.add(proofDto); listOfProofs.add(proofDto); when(proofRepository.findByTheoremName(anyString())).thenReturn(listOfProofs); - final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test"); + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -105,7 +105,7 @@ public class ProofControllerTest { @Test public void testGetAllProfsByTheoremName_nullTheoremName() { - final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName(null); + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -117,7 +117,7 @@ public class ProofControllerTest { public void testGetAllProofsByTheoremName_noProofsFound() { when(proofRepository.findByTheoremName(anyString())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test nonexistent branch"); + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test nonexistent branch"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -126,16 +126,16 @@ public class ProofControllerTest { @Test public void testGetProofById() { - final ProofDto proofDto = createProof(); - when(proofRepository.findById(anyInt())).thenReturn(Optional.ofNullable(proofDto)); + final Proof proof = createProof(); + when(proofRepository.findById(anyInt())).thenReturn(Optional.ofNullable(proof)); - final ResponseEntity responseEntity = proofController.getProofById(1); + final ResponseEntity responseEntity = proofController.getProofById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(proofDto, responseEntity.getBody()); + assertEquals(proof, responseEntity.getBody()); verify(proofRepository).findById(anyInt()); } @@ -163,17 +163,17 @@ public class ProofControllerTest { @Test public void testInsertProof() { - final ProofDto proofDto = createProof(); - when(proofRepository.save(any(ProofDto.class))).thenReturn(proofDto); + final Proof proof = createProof(); + when(proofRepository.save(any(Proof.class))).thenReturn(proof); - final ResponseEntity responseEntity = proofController.insertProof(proofDto, bindingResult); + final ResponseEntity responseEntity = proofController.insertProof(proof, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(proofDto, responseEntity.getBody()); - verify(proofRepository).save(any(ProofDto.class)); + assertEquals(proof, responseEntity.getBody()); + verify(proofRepository).save(any(Proof.class)); } @Test @@ -188,10 +188,10 @@ public class ProofControllerTest { @Test public void testInsertProof_bindingResultHasErrors() { - final ProofDto proofDto = createProof(); + final Proof proof = createProof(); when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = proofController.insertProof(proofDto, bindingResult); + final ResponseEntity responseEntity = proofController.insertProof(proof, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -201,31 +201,31 @@ public class ProofControllerTest { @Test public void testUpdateProof() { - final ProofDto existingProof = createProof(); + final Proof existingProof = createProof(); existingProof.setId(1); existingProof.setVersion(1); - final ProofDto proofUpdate = new ProofDto(); + final Proof proofUpdate = new Proof(); proofUpdate.setTheoremName("Test Update"); - final ProofDto updatedProof = existingProof; + final Proof updatedProof = existingProof; updatedProof.setTheoremName("Test Update"); when(proofRepository.findById(anyInt())).thenReturn(Optional.of(existingProof)); - when(proofRepository.save(any(ProofDto.class))).thenReturn(updatedProof); + when(proofRepository.save(any(Proof.class))).thenReturn(updatedProof); - final ResponseEntity responseEntity = proofController.updateProof(1, proofUpdate, bindingResult); + final ResponseEntity responseEntity = proofController.updateProof(1, proofUpdate, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertEquals(updatedProof, responseEntity.getBody()); verify(proofRepository).findById(anyInt()); - verify(proofRepository).save(any(ProofDto.class)); + verify(proofRepository).save(any(Proof.class)); } @Test public void testUpdateProof_bindingResultHasErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); + final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -235,7 +235,7 @@ public class ProofControllerTest { @Test public void testUpdateProof_proofDtoIsNull() { - final ResponseEntity responseEntity = proofController.updateProof(1, null, bindingResult); + final ResponseEntity responseEntity = proofController.updateProof(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -245,7 +245,7 @@ public class ProofControllerTest { @Test public void testUpdateProof_idIsNull() { - final ResponseEntity responseEntity = proofController.updateProof(null, createProof(), bindingResult); + final ResponseEntity responseEntity = proofController.updateProof(null, createProof(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -257,12 +257,12 @@ public class ProofControllerTest { public void testUpdateProof_theoremDoesNotExist() { when(proofRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); + final ResponseEntity responseEntity = proofController.updateProof(1, createProof(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); - verify(proofRepository, times(0)).save(any(ProofDto.class)); + verify(proofRepository, times(0)).save(any(Proof.class)); } @Test @@ -287,7 +287,7 @@ public class ProofControllerTest { verifyZeroInteractions(proofRepository); } - private ProofDto createProof() { + private Proof createProof() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); referencedTheoremsList.add("test theorem 2"); @@ -296,13 +296,13 @@ public class ProofControllerTest { referencedDefinitionsList.add("test definition 1"); referencedDefinitionsList.add("test definition 2"); - final ProofDto proofDto = new ProofDto(); - proofDto.setTheoremName("Test proof"); - proofDto.setBranch("Test branch"); - proofDto.setDateCreated(new Date()); - proofDto.setReferencedTheorems(referencedTheoremsList); - proofDto.setReferencedDefinitions(referencedDefinitionsList); + final Proof proof = new Proof(); + proof.setTheoremName("Test proof"); + proof.setBranch("Test branch"); + proof.setDateCreated(new Date()); + proof.setReferencedTheorems(referencedTheoremsList); + proof.setReferencedDefinitions(referencedDefinitionsList); - return proofDto; + return proof; } } \ No newline at end of file diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java index 6d09a22..ffc0913 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -1,6 +1,6 @@ package edu.msudenver.tsp.persistence.controller; -import edu.msudenver.tsp.persistence.dto.TheoremDto; +import edu.msudenver.tsp.persistence.dto.Theorem; import edu.msudenver.tsp.persistence.dto.TheoremType; import edu.msudenver.tsp.persistence.repository.TheoremRepository; import org.junit.Test; @@ -32,14 +32,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheorems() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findAll()).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheorems(); + final ResponseEntity> responseEntity = theoremController.getAllTheorems(); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -51,16 +51,16 @@ public class TheoremControllerTest { @Test public void testGetTheoremById() { - final TheoremDto theoremDto = createTheorem(); - when(theoremRepository.findById(anyInt())).thenReturn(Optional.ofNullable(theoremDto)); + final Theorem theorem = createTheorem(); + when(theoremRepository.findById(anyInt())).thenReturn(Optional.ofNullable(theorem)); - final ResponseEntity responseEntity = theoremController.getTheoremById(1); + final ResponseEntity responseEntity = theoremController.getTheoremById(1); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); - assertEquals(theoremDto, responseEntity.getBody()); + assertEquals(theorem, responseEntity.getBody()); verify(theoremRepository).findById(anyInt()); } @@ -88,14 +88,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByBranch() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findByBranch(anyString())).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -107,7 +107,7 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByBranch_nullBranch() { - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch(null); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -119,7 +119,7 @@ public class TheoremControllerTest { public void testGetAllTheoremsByBranch_noTheoremsFound() { when(theoremRepository.findByBranch(anyString())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test nonexistent branch"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test nonexistent branch"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -128,14 +128,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByProvenStatus() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(true); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(true); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -147,7 +147,7 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByProvenStatus_nullProvenStatus() { - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(null); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -159,7 +159,7 @@ public class TheoremControllerTest { public void testGetAllTheoremsByProvenStatus_noTheoremsFound() { when(theoremRepository.findByProvenStatus(anyBoolean())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(false); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus(false); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -168,14 +168,14 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByName() { - final TheoremDto theoremDto = createTheorem(); - final List listOfTheorems = new ArrayList<>(); + final Theorem theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); listOfTheorems.add(theoremDto); listOfTheorems.add(theoremDto); when(theoremRepository.findByName(anyString())).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("Test Theorem"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("Test Theorem"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -187,7 +187,7 @@ public class TheoremControllerTest { @Test public void testGetAllTheoremsByName_nullName() { - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName(null); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName(null); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -199,7 +199,7 @@ public class TheoremControllerTest { public void testGetAllTheoremsByName_noNameFound() { when(theoremRepository.findByName(anyString())).thenReturn(Collections.emptyList()); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("No name"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("No name"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -208,17 +208,17 @@ public class TheoremControllerTest { @Test public void testInsertTheorem() { - final TheoremDto theoremDto = createTheorem(); - when(theoremRepository.save(any(TheoremDto.class))).thenReturn(theoremDto); + final Theorem theorem = createTheorem(); + when(theoremRepository.save(any(Theorem.class))).thenReturn(theorem); - final ResponseEntity responseEntity = theoremController.insertTheorem(theoremDto, bindingResult); + final ResponseEntity responseEntity = theoremController.insertTheorem(theorem, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertNotNull(responseEntity.getBody()); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); - assertEquals(theoremDto, responseEntity.getBody()); - verify(theoremRepository).save(any(TheoremDto.class)); + assertEquals(theorem, responseEntity.getBody()); + verify(theoremRepository).save(any(Theorem.class)); } @Test @@ -233,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()); @@ -246,31 +246,31 @@ public class TheoremControllerTest { @Test public void testUpdateTheorem() { - final TheoremDto existingTheorem = createTheorem(); + final Theorem existingTheorem = createTheorem(); existingTheorem.setId(1); existingTheorem.setVersion(1); - final TheoremDto theoremUpdate = new TheoremDto(); + final Theorem theoremUpdate = new Theorem(); theoremUpdate.setName("Test Update"); - final TheoremDto updatedTheorem = existingTheorem; + final Theorem updatedTheorem = existingTheorem; updatedTheorem.setName("Test Update"); when(theoremRepository.findById(anyInt())).thenReturn(Optional.of(existingTheorem)); - when(theoremRepository.save(any(TheoremDto.class))).thenReturn(updatedTheorem); + when(theoremRepository.save(any(Theorem.class))).thenReturn(updatedTheorem); - final ResponseEntity responseEntity = theoremController.updateTheorem(1, theoremUpdate, bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, theoremUpdate, bindingResult); assertNotNull(responseEntity); assertTrue(responseEntity.hasBody()); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); assertEquals(updatedTheorem, responseEntity.getBody()); verify(theoremRepository).findById(anyInt()); - verify(theoremRepository).save(any(TheoremDto.class)); + verify(theoremRepository).save(any(Theorem.class)); } @Test public void testUpdateTheorem_bindingResultHasErrors() { when(bindingResult.hasErrors()).thenReturn(true); - final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -280,7 +280,7 @@ public class TheoremControllerTest { @Test public void testUpdateTheorem_theoremDtoIsNull() { - final ResponseEntity responseEntity = theoremController.updateTheorem(1, null, bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, null, bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -290,7 +290,7 @@ public class TheoremControllerTest { @Test public void testUpdateTheorem_idIsNull() { - final ResponseEntity responseEntity = theoremController.updateTheorem(null, createTheorem(), bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(null, createTheorem(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -302,12 +302,12 @@ public class TheoremControllerTest { public void testUpdateTheorem_theoremDoesNotExist() { when(theoremRepository.findById(anyInt())).thenReturn(Optional.empty()); - final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); + final ResponseEntity responseEntity = theoremController.updateTheorem(1, createTheorem(), bindingResult); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); - verify(theoremRepository, times(0)).save(any(TheoremDto.class)); + verify(theoremRepository, times(0)).save(any(Theorem.class)); } @Test @@ -332,7 +332,7 @@ public class TheoremControllerTest { verifyZeroInteractions(theoremRepository); } - private TheoremDto createTheorem() { + private Theorem createTheorem() { final List referencedTheoremsList = new ArrayList<>(); referencedTheoremsList.add("test theorem 1"); referencedTheoremsList.add("test theorem 2"); @@ -341,14 +341,14 @@ public class TheoremControllerTest { referencedDefinitionsList.add("test definition 1"); referencedDefinitionsList.add("test definition 2"); - final TheoremDto theoremDto = new TheoremDto(); - theoremDto.setName("Test theorem"); - theoremDto.setBranch("Test branch"); - theoremDto.setProvenStatus(true); - theoremDto.setTheoremType(TheoremType.THEOREM); - theoremDto.setReferencedTheorems(referencedTheoremsList); - theoremDto.setReferencedDefinitions(referencedDefinitionsList); + final Theorem theorem = new Theorem(); + theorem.setName("Test theorem"); + theorem.setBranch("Test branch"); + theorem.setProvenStatus(true); + theorem.setTheoremType(TheoremType.THEOREM); + theorem.setReferencedTheorems(referencedTheoremsList); + theorem.setReferencedDefinitions(referencedDefinitionsList); - return theoremDto; + return theorem; } } \ No newline at end of file diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java index c82731a..cad5b69 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java @@ -1,7 +1,6 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; -import edu.msudenver.tsp.persistence.dto.AccountDto; import javax.persistence.Temporal; import javax.persistence.TemporalType; @@ -12,8 +11,8 @@ import java.io.Serializable; import java.util.Date; public class Account extends BaseDto implements Serializable { - @NotBlank(groups = AccountDto.Insert.class, message = "A username must be specified") @Size(max = 50) private String username; - @NotBlank(groups = AccountDto.Insert.class, message = "A password must be specified") @Size(max = 256) private String password; + @NotBlank(groups = edu.msudenver.tsp.persistence.dto.Account.Insert.class, message = "A username must be specified") @Size(max = 50) private String username; + @NotBlank(groups = edu.msudenver.tsp.persistence.dto.Account.Insert.class, message = "A password must be specified") @Size(max = 256) private String password; @NotNull @SerializedName("administrator_status") private boolean administratorStatus; @Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin; diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java b/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java index 0106b8b..c3f37e1 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java @@ -1,41 +1,24 @@ package edu.msudenver.tsp.services.parser; -import edu.msudenver.tsp.persistence.controller.DefinitionController; -import edu.msudenver.tsp.persistence.controller.NotationController; -import edu.msudenver.tsp.persistence.controller.ProofController; -import edu.msudenver.tsp.persistence.controller.TheoremController; -import org.springframework.beans.factory.annotation.Autowired; +import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import java.util.ArrayList; import java.util.List; +@Slf4j @Service class ParserService { - private final DefinitionController definitionController; - private final TheoremController theoremController; - private final NotationController notationController; - private final ProofController proofController; - private Node root; - - @Autowired - public ParserService(final DefinitionController definitionController, final TheoremController theoremController, - final NotationController notationController, final ProofController proofController) { - this.definitionController = definitionController; - this.theoremController = theoremController; - this.notationController = notationController; - this.proofController = proofController; - } public boolean parseUserInput(final String userInput) { try { final Node tree = parseRawInput(userInput); - final List statements = retrieveStatements(tree); + retrieveStatements(tree); return true; } catch(final Exception e) { - e.printStackTrace(); + LOG.error(e.getMessage()); } return false; } @@ -44,7 +27,7 @@ class ParserService { { input = input.toLowerCase(); - root = new Node(input, null); + final Node root = new Node(input, null); if(input.equals("")) { diff --git a/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java index 829a02a..fdfecf0 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java @@ -1,9 +1,9 @@ package edu.msudenver.tsp.services.parser; -import edu.msudenver.tsp.persistence.controller.DefinitionController; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; import java.util.ArrayList; @@ -12,18 +12,14 @@ import java.util.List; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ParserServiceTest { - private final DefinitionController definitionControllerMock = mock(DefinitionController.class); - private final ParserService mockParserService = mock(ParserService.class); + @Mock private ParserService mockParserService; - @InjectMocks - private final ParserService parserService = new ParserService(definitionControllerMock, null, - null, null); + @InjectMocks private ParserService parserService; @Test public void testEmptyStringEqualsEmptyString() { From c90f5b6e0988278d009c565962decb6207a88131 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 14:52:41 -0600 Subject: [PATCH 28/34] PAN-57 Added patch method to RestService per request --- .../main/java/edu/msudenver/tsp/services/RestService.java | 5 +++++ .../edu/msudenver/tsp/services/factory/RequestFactory.java | 4 ++++ 2 files changed, 9 insertions(+) diff --git a/services/src/main/java/edu/msudenver/tsp/services/RestService.java b/services/src/main/java/edu/msudenver/tsp/services/RestService.java index 78f0cb9..67d2ef0 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/RestService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/RestService.java @@ -53,6 +53,11 @@ public class RestService { return send(requestFactory.put(uri, requestJson), auth, connectionTimeout, socketTimeout, type); } + Optional patch(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout) { + LOG.info("Sending PATCH {} with body: {}", uri, requestJson); + return send(requestFactory.patch(uri, requestJson), null, connectionTimeout, socketTimeout, type); + } + private Optional send(final Request request, final String auth, final Integer connectionTimeout, final Integer socketTimeout, final TypeToken type) { try { final Optional optionalHttpResponse = send(request, auth, connectionTimeout, socketTimeout); diff --git a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java index 726b9a8..eb4933d 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java +++ b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java @@ -22,4 +22,8 @@ public class RequestFactory { public Request put(final String uri, final String requestJson) { return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Put(uri); } + + public Request patch(final String uri, final String requestJson) { + return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Patch(uri); + } } \ No newline at end of file From 6009720d806b8e6a242137123b5cf46a5e6efcf5 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 15:07:23 -0600 Subject: [PATCH 29/34] PAN-52 Created RequestFactory unit tests --- .../services/factory/RequestFactoryTest.java | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java diff --git a/services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java b/services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java new file mode 100644 index 0000000..1f21b28 --- /dev/null +++ b/services/src/test/java/edu/msudenver/tsp/services/factory/RequestFactoryTest.java @@ -0,0 +1,66 @@ +package edu.msudenver.tsp.services.factory; + +import org.apache.http.client.fluent.Request; +import org.junit.Test; + +import static org.junit.Assert.assertNotNull; + +public class RequestFactoryTest { + private final RequestFactory requestFactory = new RequestFactory(); + + @Test + public void testDelete() { + final Request testRequest = requestFactory.delete("testUri"); + + assertNotNull(testRequest); + } + + @Test + public void testGet() { + final Request testRequest = requestFactory.get("testUri"); + + assertNotNull(testRequest); + } + + @Test + public void testPost() { + final Request testRequest = requestFactory.post("testUri", "testJson"); + + assertNotNull(testRequest); + } + + @Test + public void testPost_blankRequestJson() { + final Request testRequest = requestFactory.post("testUri", null); + + assertNotNull(testRequest); + } + + @Test + public void testPut() { + final Request testRequest = requestFactory.put("testUri", "testJson"); + + assertNotNull(testRequest); + } + + @Test + public void testPut_blankRequestJson() { + final Request testRequest = requestFactory.put("testUri", null); + + assertNotNull(testRequest); + } + + @Test + public void testPatch() { + final Request testRequest = requestFactory.patch("testUri", "testJson"); + + assertNotNull(testRequest); + } + + @Test + public void testPatch_blankRequestJson() { + final Request testRequest = requestFactory.patch("testUri", null); + + assertNotNull(testRequest); + } +} \ No newline at end of file From 6197beb309a53b340aa38fc735261bffd1a957c7 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 15:37:04 -0600 Subject: [PATCH 30/34] PAN-52 Updated the build.gradle files --- build.gradle | 7 ------- services/build.gradle | 3 ++- .../main/java/edu/msudenver/tsp/services/dto/Account.java | 4 ++++ 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/build.gradle b/build.gradle index 6690226..cc21aa1 100644 --- a/build.gradle +++ b/build.gradle @@ -136,13 +136,6 @@ testSets { integrationTest } -compileKotlin { - kotlinOptions.jvmTarget = "1.8" -} -compileTestKotlin { - kotlinOptions.jvmTarget = "1.8" -} - wrapper { gradleVersion = '5.2.1' distributionType = Wrapper.DistributionType.ALL diff --git a/services/build.gradle b/services/build.gradle index 05efbeb..551f2b2 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -23,6 +23,7 @@ dependencies { compile group: 'org.apache.httpcomponents', name: 'fluent-hc', version: '4.5.7' compile group: 'com.google.code.gson', name: 'gson', version: '2.7' compile fileTree(dir: 'lib', include: '**/*.jar') - + + testCompile "org.springframework:spring-test:5.0.9.RELEASE" testCompile group: 'junit', name: 'junit', version: '4.12' } diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java index cad5b69..5834018 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java @@ -1,6 +1,8 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; +import lombok.Getter; +import lombok.Setter; import javax.persistence.Temporal; import javax.persistence.TemporalType; @@ -10,6 +12,8 @@ import javax.validation.constraints.Size; import java.io.Serializable; import java.util.Date; +@Getter +@Setter public class Account extends BaseDto implements Serializable { @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; From 7548ca64d0f307123c9d2bbc6034e64ec8321c7c Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 16:01:12 -0600 Subject: [PATCH 31/34] PAN-52 Updated the build.gradle files and the .travis.yml --- .travis.yml | 18 ++++++++++++------ persistence/build.gradle | 8 ++++++++ 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5be1637..658d4f9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,13 +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: Sonar Analysis + - stage: "Integration Tests" + script: + - | + ./gradlew :persistence:startPersistenceApi & + APP_PID=$! + - | + ./gradlew integrationTest + - kill $APP_PID + - stage: "Sonar Analysis" script: ./gradlew sonar diff --git a/persistence/build.gradle b/persistence/build.gradle index b832e7e..811725d 100644 --- a/persistence/build.gradle +++ b/persistence/build.gradle @@ -50,3 +50,11 @@ task loadDb(type: Exec, group: 'Verification', description: 'Reloads the local d commandLine=['cmd','/c','loaddb.bat'] } } + +task startPersistenceApi(type: JavaExec, description: 'Starts the Persistence API') { + dependsOn 'loadDb' + dependsOn 'build' + classpath = files('build/libs/persistence-1.0.jar') + classpath += sourceSets.main.runtimeClasspath + main = 'edu.msudenver.tsp.persistence.PersistenceApi' +} From 9700eb55ab2f1e40d39fc9a66105de98a3d2c956 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 16:21:32 -0600 Subject: [PATCH 32/34] PAN-52 Removed useless classes --- .../edu/msudenver/tsp/services/dto/Account.java | 8 ++++---- .../tsp/services/scoring/ScoringConfig.java | 1 - .../scoring/TheoremScoringServiceTest.java | 16 ---------------- 3 files changed, 4 insertions(+), 21 deletions(-) delete mode 100644 services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java index 5834018..139cd41 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java @@ -1,8 +1,8 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; -import lombok.Getter; -import lombok.Setter; +import lombok.Data; +import lombok.EqualsAndHashCode; import javax.persistence.Temporal; import javax.persistence.TemporalType; @@ -12,8 +12,8 @@ import javax.validation.constraints.Size; import java.io.Serializable; import java.util.Date; -@Getter -@Setter +@Data +@EqualsAndHashCode(callSuper = true) public class Account extends BaseDto implements Serializable { @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; diff --git a/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java b/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java index 3a4aa63..b3a6f07 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java +++ b/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java @@ -6,7 +6,6 @@ import org.springframework.context.annotation.Configuration; @Configuration @ComponentScan -//@PropertySource("classpath:development.properties") public class ScoringConfig { @Bean diff --git a/services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java deleted file mode 100644 index f116fb6..0000000 --- a/services/src/test/java/edu/msudenver/tsp/services/scoring/TheoremScoringServiceTest.java +++ /dev/null @@ -1,16 +0,0 @@ -package edu.msudenver.tsp.services.scoring; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.runners.MockitoJUnitRunner; - -import static org.junit.Assert.assertEquals; - -@RunWith(MockitoJUnitRunner.class) -public class TheoremScoringServiceTest { - - @Test - public void test() { - assertEquals(3,3); - } -} \ No newline at end of file From a84e6c6ab738de13b4031a59871854680e06eb87 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 16:22:23 -0600 Subject: [PATCH 33/34] PAN-52 Removed useless classes --- .../tsp/services/scoring/ScoringConfig.java | 15 --------------- .../services/scoring/TheoremScoringService.java | 8 -------- 2 files changed, 23 deletions(-) delete mode 100644 services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java delete mode 100644 services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java diff --git a/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java b/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java deleted file mode 100644 index b3a6f07..0000000 --- a/services/src/main/java/edu/msudenver/tsp/services/scoring/ScoringConfig.java +++ /dev/null @@ -1,15 +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 -public class ScoringConfig { - - @Bean - public TheoremScoringService theoremScoringService() { - return new TheoremScoringService(); - } -} diff --git a/services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java b/services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java deleted file mode 100644 index 6dad106..0000000 --- a/services/src/main/java/edu/msudenver/tsp/services/scoring/TheoremScoringService.java +++ /dev/null @@ -1,8 +0,0 @@ -package edu.msudenver.tsp.services.scoring; - -import org.springframework.stereotype.Service; - -@Service -class TheoremScoringService { - -} From 7b2d5c45a6e883a3443c3a0620e55c47378026b4 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 22:59:18 -0600 Subject: [PATCH 34/34] PAN-52 Forgot to add the @Repository annotation to the ProofRepository --- .../msudenver/tsp/persistence/repository/ProofRepository.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java index 8988aeb..040f740 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -2,9 +2,11 @@ package edu.msudenver.tsp.persistence.repository; import edu.msudenver.tsp.persistence.dto.Proof; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; import java.util.List; +@Repository public interface ProofRepository extends JpaRepository { List findByBranch(String branch);