From d8422f67d72fe424dd0683e8cc6087dc4b40957b Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 16:25:49 -0700 Subject: [PATCH 01/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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/15] 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();