From d8422f67d72fe424dd0683e8cc6087dc4b40957b Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 16:25:49 -0700 Subject: [PATCH 01/76] 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 4b76f2eb69fa74a004addd5b6dfc287011af3f9b Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Sun, 3 Mar 2019 17:32:52 -0700 Subject: [PATCH 02/76] PAN-10 code & test corrections. Node class extracted from ParserService class. --- .../msudenver/tsp/services/parser/Node.java | 34 ++++++ .../tsp/services/parser/ParserService.java | 108 ++++++++++++++++++ .../services/parser/ParserServiceTest.java | 70 +++++++++++- 3 files changed, 210 insertions(+), 2 deletions(-) create mode 100644 services/src/main/java/edu/msudenver/tsp/services/parser/Node.java diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java b/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java new file mode 100644 index 0000000..8f9893f --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java @@ -0,0 +1,34 @@ +package edu.msudenver.tsp.services.parser; + +public class Node +{ + String statement; + Node left; + Node right; + Node center; + Node parent; + int depth; + + public Node(final String s, final Node p) + { + statement = s + "\n"; + left = null; + right = null; + center = null; + parent = p; + if(p != null) depth = p.depth + 1; + else depth = 0; + } + + @Override + public String toString() + { + String returnVal = this.depth + ": " + this.statement; + + if(this.left != null) returnVal += "... " + this.left.toString(); + if(this.center != null) returnVal += "... " + this.center.toString(); + if(this.right != null) returnVal += "... " + this.right.toString(); + + return returnVal; + } +} \ No newline at end of file diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java b/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java index 747521d..ca24a9b 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 @@ -7,12 +7,15 @@ import edu.msudenver.tsp.persistence.controller.TheoremController; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import java.util.ArrayList; + @Service class ParserService { private final DefinitionController definitionController; private final TheoremController theoremController; private final NotationController notationController; private final ProofController proofController; + Node root; @Autowired public ParserService(final DefinitionController definitionController, final TheoremController theoremController, @@ -23,4 +26,109 @@ class ParserService { this.proofController = proofController; } + public void driveParsingProcess(final String userInput) + { + final Node tree; + ArrayList statements = new ArrayList<>(); + + tree = parseRawInput(userInput); + statements = retrieveStatements(tree); + retrieveDefinitions(statements); + } + + public Node parseRawInput(String input) + { + // convert to the same case for easier processing + input = input.toLowerCase(); + + root = new Node(input, null); + + // special case: nothing is submitted + if(input.equals("")) + { + return root; + } + + // eliminate periods at the end of the input + if(input.charAt(input.length()-1) == '.') + { + input = input.substring(0, input.length()-1); + } + + recurse(root); + + return root; + } + + private void recurse(final Node current) + { + int iContain; + + if(current.statement.contains("let")) + { + current.left = new Node("let", + current); + iContain = (current.statement.contains("if") ? current.statement.indexOf("if") : current.statement.length()); + + current.left.center = new Node(current.statement.substring(current.statement.indexOf("let")+3, + iContain), + current.left); + recurse(current.left.center); + } + + + if(current.statement.contains("if")) + { + current.center = new Node("if", + current); + iContain = (current.statement.contains("then") ? current.statement.indexOf("then") : current.statement.length()); + + current.center.center = new Node(current.statement.substring(current.statement.indexOf("if")+2, + iContain), + current.center); + recurse(current.center.center); + } + + + if(current.statement.contains("then")) + { + current.right = new Node("then", + current); + current.right.center = new Node(current.statement.substring(current.statement.indexOf("then")+4), + current.right); + recurse(current.right.center); + } + } + + public ArrayList retrieveStatements(final Node parsedTree) + { + ArrayList statementList = new ArrayList<>(); + + statementList = traverse(parsedTree, statementList); + + return statementList; + } + + private ArrayList traverse(final Node node, final ArrayList statementList) + { + if(node == null) return statementList; + + if(!(node.statement.contains("let") || node.statement.contains("if") || node.statement.contains("then"))) + { + statementList.add(node.statement.trim()); + } + + traverse(node.left, statementList); + + traverse(node.center, statementList); + + traverse(node.right, statementList); + + return statementList; + } + + public void retrieveDefinitions(final ArrayList list) + { + // stub + } } 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 1ae6e5e..0d007c8 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,17 +1,83 @@ 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.Mock; import org.mockito.runners.MockitoJUnitRunner; +import java.util.ArrayList; + import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ParserServiceTest { + @Mock + DefinitionController definitionControllerMock = mock(DefinitionController.class); + + @Mock + ParserService mps = mock(ParserService.class); + + ParserService ps = new ParserService(definitionControllerMock, null, + null, null); + @Test - public void test() { - assertEquals(3,3); + public void testEmptyStringEqualsEmptyString() { + assertEquals("0: \n", ps.parseRawInput("").toString()); } + @Test + public void testUselessStringEqualsUselessString() { + assertEquals("0: cat\n", ps.parseRawInput("cat").toString()); + } + + @Test + public void testSingleIfReturnsIfPlusEmptyString() { + assertEquals("0: if\n... 1: if\n... 2: \n\n", ps.parseRawInput("if").toString()); + } + + @Test + public void testBaseCaseIfXIsEvenThenXSquaredIsEven() { + final String expected = "0: if x is even then x^2 is even\n" + + "... 1: if\n" + + "... 2: x is even \n" + + "... 1: then\n" + + "... 2: x^2 is even\n\n"; + + final String testCase = "if x is even then x^2 is even"; + + assertEquals(expected, ps.parseRawInput(testCase).toString()); + } + + @Test + public void testEmptyStringReturnsEmptyList() { + final ArrayList expectedList = new ArrayList<>(); + expectedList.add(""); + + + + when(mps.parseRawInput(anyString())).thenReturn(new Node("", null)); + + assertEquals(expectedList, ps.retrieveStatements(mps.parseRawInput(""))); + } + + @Test + public void testBaseCaseReturnsXIsEven() { + final ArrayList expectation = new ArrayList<>(); + expectation.add("x is even"); + expectation.add("x^2 is even"); + + ps.root = new Node("if x is even then x^2 is even", null); + ps.root.center = new Node("if", ps.root); + ps.root.center.center = new Node(" x is even ", ps.root.center); + ps.root.right = new Node("then", ps.root); + ps.root.right.center = new Node(" x^2 is even", ps.root.right); + when(mps.parseRawInput(anyString())).thenReturn(ps.root); + + assertEquals(expectation, ps.retrieveStatements(mps.parseRawInput("baseCase"))); + } } \ No newline at end of file From f6de79a3d40ff249e304c293e4fbe081ee072906 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 18:25:46 -0700 Subject: [PATCH 03/76] 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 04/76] 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 05/76] 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 06/76] 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 e47f2556f6514f08ae2397b2dc64d3a60882e023 Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Sun, 3 Mar 2019 18:51:11 -0700 Subject: [PATCH 07/76] PAN-10 code & tests. 100% coverage. Node class extracted from ParserService class. ParserConfig deleted because it wasn't being used. --- .../tsp/services/parser/ParserConfig.java | 11 ---- .../tsp/services/parser/ParserService.java | 27 ++++++---- .../services/parser/ParserServiceTest.java | 51 ++++++++++++++++++- 3 files changed, 66 insertions(+), 23 deletions(-) delete mode 100644 services/src/main/java/edu/msudenver/tsp/services/parser/ParserConfig.java diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserConfig.java b/services/src/main/java/edu/msudenver/tsp/services/parser/ParserConfig.java deleted file mode 100644 index eb1c4f2..0000000 --- a/services/src/main/java/edu/msudenver/tsp/services/parser/ParserConfig.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.services.parser; - -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.Configuration; - -@Configuration -@ComponentScan -//@PropertySource("classpath:development.properties") -public class ParserConfig { - -} 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 ca24a9b..4bf6e49 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 @@ -29,7 +29,7 @@ class ParserService { public void driveParsingProcess(final String userInput) { final Node tree; - ArrayList statements = new ArrayList<>(); + final ArrayList statements; tree = parseRawInput(userInput); statements = retrieveStatements(tree); @@ -41,6 +41,12 @@ class ParserService { // convert to the same case for easier processing input = input.toLowerCase(); + // eliminate periods at the end of the input + /*if(input.charAt(input.length()-1) == '.') + { + input.substring(0, input.length()-1); + }*/ + root = new Node(input, null); // special case: nothing is submitted @@ -49,12 +55,6 @@ class ParserService { return root; } - // eliminate periods at the end of the input - if(input.charAt(input.length()-1) == '.') - { - input = input.substring(0, input.length()-1); - } - recurse(root); return root; @@ -68,7 +68,14 @@ class ParserService { { current.left = new Node("let", current); - iContain = (current.statement.contains("if") ? current.statement.indexOf("if") : current.statement.length()); + + if(current.statement.contains("if")){ + iContain = current.statement.indexOf("if"); + } else if(current.statement.contains("then")){ + iContain = current.statement.indexOf("then"); + } else { + iContain = current.statement.length(); + } current.left.center = new Node(current.statement.substring(current.statement.indexOf("let")+3, iContain), @@ -102,9 +109,9 @@ class ParserService { public ArrayList retrieveStatements(final Node parsedTree) { - ArrayList statementList = new ArrayList<>(); + final ArrayList statementList = new ArrayList<>(); - statementList = traverse(parsedTree, statementList); + traverse(parsedTree, statementList); return statementList; } 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 0d007c8..e2d32ed 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 @@ -53,13 +53,50 @@ public class ParserServiceTest { assertEquals(expected, ps.parseRawInput(testCase).toString()); } + @Test + public void testLetXBeEvenThenXSquaredIsEven() { + final String expected = "0: let x be even. then x^2 is even.\n" + + "... 1: let\n" + + "... 2: x be even. \n" + + "... 1: then\n" + + "... 2: x^2 is even.\n\n"; + + final String testCase = "Let x be even. Then x^2 is even."; + + assertEquals(expected, ps.parseRawInput(testCase).toString()); + } + + @Test + public void testLetIfThen() { + final String expected = "0: let a. if b, then c.\n" + + "... 1: let\n" + + "... 2: a. \n" + + "... 1: if\n" + + "... 2: b, \n" + + "... 1: then\n" + + "... 2: c.\n\n"; + + final String testCase = "Let a. If b, then c."; + + assertEquals(expected, ps.parseRawInput(testCase).toString()); + } + + @Test + public void testLetAlone() { + final String expected = "0: let a be equal to b.\n" + + "... 1: let\n" + + "... 2: a be equal to b.\n\n"; + + final String testCase = "Let a be equal to b."; + + assertEquals(expected, ps.parseRawInput(testCase).toString()); + } + @Test public void testEmptyStringReturnsEmptyList() { final ArrayList expectedList = new ArrayList<>(); expectedList.add(""); - - when(mps.parseRawInput(anyString())).thenReturn(new Node("", null)); assertEquals(expectedList, ps.retrieveStatements(mps.parseRawInput(""))); @@ -80,4 +117,14 @@ public class ParserServiceTest { assertEquals(expectation, ps.retrieveStatements(mps.parseRawInput("baseCase"))); } + + @Test + public void testDriveParsingProcess() { + mps.root = new Node("", null); + final ArrayList testdummy = new ArrayList<>(); + when(mps.parseRawInput(anyString())).thenReturn(mps.root); + when(mps.retrieveStatements(mps.root)).thenReturn(testdummy); + + ps.driveParsingProcess(""); + } } \ No newline at end of file From cbaea65b5653c4dfff43d271acfa95c0ee582ec8 Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Sun, 3 Mar 2019 18:58:34 -0700 Subject: [PATCH 08/76] PAN-10 travis.yml update --- .travis.yml | 3 +-- 1 file changed, 1 insertion(+), 2 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 From e4594dc9009546cde0f58adca9fd3d12c82324b9 Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Sun, 3 Mar 2019 19:01:01 -0700 Subject: [PATCH 09/76] PAN-10 deleted commented-out code --- .../edu/msudenver/tsp/services/parser/ParserService.java | 6 ------ 1 file changed, 6 deletions(-) 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 4bf6e49..98e6c6a 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 @@ -41,12 +41,6 @@ class ParserService { // convert to the same case for easier processing input = input.toLowerCase(); - // eliminate periods at the end of the input - /*if(input.charAt(input.length()-1) == '.') - { - input.substring(0, input.length()-1); - }*/ - root = new Node(input, null); // special case: nothing is submitted From 3762c10359bde48d747a517a722f69ff4cdd058d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 19:03:48 -0700 Subject: [PATCH 10/76] 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 6a8f2399959bf8bbf9b13c3b58d2a28b01439a72 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Sun, 3 Mar 2019 19:04:55 -0700 Subject: [PATCH 11/76] Update .travis.yml --- .travis.yml | 3 +-- 1 file changed, 1 insertion(+), 2 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 From a0753903b253111e4f0885946be65b37e192c5cf Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 3 Mar 2019 21:12:07 -0700 Subject: [PATCH 12/76] 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 fae060e0395035d290fefad7a68f59332a1a0a52 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 17:57:37 -0700 Subject: [PATCH 13/76] Update README.md --- README.md | 50 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 49 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index dc1251a..34d5ce3 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,50 @@ # Pandamonium Theorem Prover -This is the main repository for the Technical Software Project +This project contains several different modules for different parts of the system. + +* [psersistence](persistence/README.md) +* [web-server](src/README.md) + +## Getting Started + +1. Clone the project. `git clone git@github.com:atusa17/tsp.git` +2. Open the `pandamonium-theorem-prover` folder with IntelliJ. Use auto-import for a Gradle project. +3. Individual Components have their own README. Continue there. + +## Running the Tests + +This project is unit tested with JUnit and Mockito. You can run the unit tests with IntelliJ or Gradle. To run them with IntelliJ, browse to any `*Test.java` file and use IntelliJ's built-in test runner to run or debug the test. To run all the unit tests with Gradle: + +* On a Linux or Macintosh machine: + $ ./gradlew test +* On a Windows machine: + $ gradlew.bat test + +You can also test modules individually: + +* On a Linux or Macintosh machine: + + $ ./gradlew persistence:test + +* On a Windows machine: + + $ gradlew.bat persistence:test + +## Integration Tests + +To run the integration tests with IntelliJ, browse to any `*Test.java` file residing in any module name `integrationTest` and use IntelliJ's built-in test runner to run or debug the test. To run all the integration tests with Gradle: + +* On a Linux or Macintosh machine: + + $ ./gradlew integrationTest + +* On a Windows machine + + $ gradlew.bat integrationTest + +## Built with + +* [Spring Boot](https://projects.spring.io/spring-boot/) - Web framework +* [Spring Web Flow](https://projects.spring.io/spring-webflow/) - MVC framework +* [Gradle](https://gradle.org/) - Dependency management +* [JUnit](http://junit.org/junit4/) - Unit tests +* [Mockito](http://site.mockito.org/) - Mock objects library From b154648fdfb759a334c27f321a206e93adb94e99 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 17:59:00 -0700 Subject: [PATCH 14/76] Update README.md --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 34d5ce3..43c138b 100644 --- a/README.md +++ b/README.md @@ -15,19 +15,19 @@ This project contains several different modules for different parts of the syste This project is unit tested with JUnit and Mockito. You can run the unit tests with IntelliJ or Gradle. To run them with IntelliJ, browse to any `*Test.java` file and use IntelliJ's built-in test runner to run or debug the test. To run all the unit tests with Gradle: * On a Linux or Macintosh machine: - $ ./gradlew test + $ ./gradlew test * On a Windows machine: - $ gradlew.bat test + $ gradlew.bat test You can also test modules individually: * On a Linux or Macintosh machine: - $ ./gradlew persistence:test + $ ./gradlew persistence:test * On a Windows machine: - $ gradlew.bat persistence:test + $ gradlew.bat persistence:test ## Integration Tests @@ -35,11 +35,11 @@ To run the integration tests with IntelliJ, browse to any `*Test.java` file resi * On a Linux or Macintosh machine: - $ ./gradlew integrationTest + $ ./gradlew integrationTest * On a Windows machine - $ gradlew.bat integrationTest + $ gradlew.bat integrationTest ## Built with From 953f8d807cb25965204ecbd698e9692ff4f299d1 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 18:01:24 -0700 Subject: [PATCH 15/76] Update README.md --- README.md | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 43c138b..9141861 100644 --- a/README.md +++ b/README.md @@ -15,19 +15,22 @@ This project contains several different modules for different parts of the syste This project is unit tested with JUnit and Mockito. You can run the unit tests with IntelliJ or Gradle. To run them with IntelliJ, browse to any `*Test.java` file and use IntelliJ's built-in test runner to run or debug the test. To run all the unit tests with Gradle: * On a Linux or Macintosh machine: - $ ./gradlew test + + ```$ ./gradlew test``` + * On a Windows machine: - $ gradlew.bat test + + ```$ gradlew.bat test``` You can also test modules individually: * On a Linux or Macintosh machine: - $ ./gradlew persistence:test + ```$ ./gradlew persistence:test``` * On a Windows machine: - $ gradlew.bat persistence:test + ```$ gradlew.bat persistence:test``` ## Integration Tests @@ -35,11 +38,11 @@ To run the integration tests with IntelliJ, browse to any `*Test.java` file resi * On a Linux or Macintosh machine: - $ ./gradlew integrationTest + ```$ ./gradlew integrationTest``` * On a Windows machine - $ gradlew.bat integrationTest + ```$ gradlew.bat integrationTest``` ## Built with From f2498f4bda3180785bb772d5ce35a8331f0927e8 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 18:01:52 -0700 Subject: [PATCH 16/76] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9141861..aa68281 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # Pandamonium Theorem Prover This project contains several different modules for different parts of the system. -* [psersistence](persistence/README.md) +* [persistence](persistence/README.md) * [web-server](src/README.md) ## Getting Started From 0b6e18b795b6c6af22eab9b67340c3d8b9b83d24 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 18:12:33 -0700 Subject: [PATCH 17/76] Update README.md --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index aa68281..1f5edb6 100644 --- a/README.md +++ b/README.md @@ -51,3 +51,4 @@ To run the integration tests with IntelliJ, browse to any `*Test.java` file resi * [Gradle](https://gradle.org/) - Dependency management * [JUnit](http://junit.org/junit4/) - Unit tests * [Mockito](http://site.mockito.org/) - Mock objects library +* [Lombok](https://projectlombok.org/) - Boilerplate Code Generator From 0167ac1a11e4b1aeb5efd79f137289dfde3daf11 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 18:13:36 -0700 Subject: [PATCH 18/76] Create README.md --- persistence/README.md | 61 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 persistence/README.md diff --git a/persistence/README.md b/persistence/README.md new file mode 100644 index 0000000..4258ce9 --- /dev/null +++ b/persistence/README.md @@ -0,0 +1,61 @@ +## PTP Persistence API + +The PTP Persistence API is the web API for accessing the theorems database. + + + +## Running from IntelliJ + +* Create a new run configuration in IntelliJ. + + ``` + Name: "PTP Persistence API Tomcat" + Application Server: Tomcat (8.5.12) + HTTP Port: 8090 + JMX Port: 1090 + Deployment tabe: Deploy persistence-api.war (exploded) + ``` +## Running the Tests + +This project is unit tested with JUnit and Mockito. You can run the unit tests with IntelliJ or Gradle. To run them with IntelliJ, browse to any `*Test.java` file and use IntelliJ's built-in test runner to run or debug the test. To run all the unit tests with Gradle: + +* On a Linux or Macintosh machine: + + ```$ ./gradlew test``` + +* On a Windows machine: + + ```$ gradlew.bat test``` + +You can also test modules individually: + +* On a Linux or Macintosh machine: + + ```$ ./gradlew persistence:test``` + +* On a Windows machine: + + ```$ gradlew.bat persistence:test``` + +## Integration Tests + +To run the integration tests with IntelliJ, browse to any `*Test.java` file residing in any module name `integrationTest` and use IntelliJ's built-in test runner to run or debug the test. To run all the integration tests with Gradle: + +* On a Linux or Macintosh machine: + + ```$ ./gradlew integrationTest``` + +* On a Windows machine + + ```$ gradlew.bat integrationTest``` + +## Built with + +* [Spring Boot](https://projects.spring.io/spring-boot/) - Web framework +* [Spring Web Flow](https://projects.spring.io/spring-webflow/) - MVC framework +* [Spring Data](https://spring.io/projects/spring-data/) - Persistence framework +* [Gradle](https://gradle.org/) - Dependency management +* [JUnit](http://junit.org/junit4/) - Unit tests +* [Mockito](http://site.mockito.org/) - Mock objects library +* [Lombok](https://projectlombok.org/) - Boilerplate Code Generator +* [Hibernate ORM](http://hibernate.org/orm/) - Object/Relational Mapping From 27e56039f48c0b1d4f396693e6e34ebfa6710abc Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Mon, 4 Mar 2019 18:15:22 -0700 Subject: [PATCH 19/76] Create README.md --- src/README.md | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 src/README.md diff --git a/src/README.md b/src/README.md new file mode 100644 index 0000000..6ee4af6 --- /dev/null +++ b/src/README.md @@ -0,0 +1,58 @@ +## PTP Persistence API + +The PTP Persistence API is the web API for accessing the theorems database. + + + +## Running from IntelliJ + +* Create a new run configuration in IntelliJ. + + ``` + Name: "Pandamonium Theorem Prover Tomcat" + Application Server: Tomcat (8.5.12) + HTTP Port: 8080 + JMX Port: 1080 + Deployment tabe: Deploy pandamonium-theorem-prover.war (exploded) + ``` +## Running the Tests + +This project is unit tested with JUnit and Mockito. You can run the unit tests with IntelliJ or Gradle. To run them with IntelliJ, browse to any `*Test.java` file and use IntelliJ's built-in test runner to run or debug the test. To run all the unit tests with Gradle: + +* On a Linux or Macintosh machine: + + ```$ ./gradlew test``` + +* On a Windows machine: + + ```$ gradlew.bat test``` + +You can also test modules individually: + +* On a Linux or Macintosh machine: + + ```$ ./gradlew persistence:test``` + +* On a Windows machine: + + ```$ gradlew.bat persistence:test``` + +## Integration Tests + +To run the integration tests with IntelliJ, browse to any `*Test.java` file residing in any module name `integrationTest` and use IntelliJ's built-in test runner to run or debug the test. To run all the integration tests with Gradle: + +* On a Linux or Macintosh machine: + + ```$ ./gradlew integrationTest``` + +* On a Windows machine + + ```$ gradlew.bat integrationTest``` + +## Built with + +* [Spring Boot](https://projects.spring.io/spring-boot/) - Web framework +* [Gradle](https://gradle.org/) - Dependency management +* [JUnit](http://junit.org/junit4/) - Unit tests +* [Mockito](http://site.mockito.org/) - Mock objects library +* [Lombok](https://projectlombok.org/) - Boilerplate Code Generator From 6f5bbab5ac46e33855bf15032929daef378490d7 Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Mon, 4 Mar 2019 21:23:45 -0700 Subject: [PATCH 20/76] PAN-10 Corrected many styling errors which required little refactoring. --- .../msudenver/tsp/services/parser/Node.java | 16 ++-- .../tsp/services/parser/ParserService.java | 43 ++++------ .../services/parser/ParserServiceTest.java | 86 +++++++++++-------- 3 files changed, 79 insertions(+), 66 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java b/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java index 8f9893f..2cf31d8 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java +++ b/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java @@ -9,15 +9,21 @@ public class Node Node parent; int depth; - public Node(final String s, final Node p) + public Node(final String statement, final Node parent) { - statement = s + "\n"; + this.statement = statement + "\n"; left = null; right = null; center = null; - parent = p; - if(p != null) depth = p.depth + 1; - else depth = 0; + this.parent = parent; + if(parent != null) + { + depth = parent.depth + 1; + } + else + { + depth = 0; + } } @Override 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 98e6c6a..d440fb6 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 @@ -15,7 +15,7 @@ class ParserService { private final TheoremController theoremController; private final NotationController notationController; private final ProofController proofController; - Node root; + private Node root; @Autowired public ParserService(final DefinitionController definitionController, final TheoremController theoremController, @@ -26,24 +26,24 @@ class ParserService { this.proofController = proofController; } - public void driveParsingProcess(final String userInput) + public boolean parseUserInput(final String userInput) { - final Node tree; - final ArrayList statements; + try { + final Node tree = parseRawInput(userInput); + final ArrayList statements = retrieveStatements(tree); - tree = parseRawInput(userInput); - statements = retrieveStatements(tree); - retrieveDefinitions(statements); + return true; + } catch(final Exception e) { + return false; + } } public Node parseRawInput(String input) { - // convert to the same case for easier processing input = input.toLowerCase(); root = new Node(input, null); - // special case: nothing is submitted if(input.equals("")) { return root; @@ -56,7 +56,7 @@ class ParserService { private void recurse(final Node current) { - int iContain; + int wordBeginsHere; if(current.statement.contains("let")) { @@ -64,15 +64,15 @@ class ParserService { current); if(current.statement.contains("if")){ - iContain = current.statement.indexOf("if"); + wordBeginsHere = current.statement.indexOf("if"); } else if(current.statement.contains("then")){ - iContain = current.statement.indexOf("then"); + wordBeginsHere = current.statement.indexOf("then"); } else { - iContain = current.statement.length(); + wordBeginsHere = current.statement.length(); } - current.left.center = new Node(current.statement.substring(current.statement.indexOf("let")+3, - iContain), + current.left.center = new Node(current.statement.substring(current.statement.indexOf("let")+"let".length(), + wordBeginsHere), current.left); recurse(current.left.center); } @@ -82,10 +82,10 @@ class ParserService { { current.center = new Node("if", current); - iContain = (current.statement.contains("then") ? current.statement.indexOf("then") : current.statement.length()); + wordBeginsHere = (current.statement.contains("then") ? current.statement.indexOf("then") : current.statement.length()); - current.center.center = new Node(current.statement.substring(current.statement.indexOf("if")+2, - iContain), + current.center.center = new Node(current.statement.substring(current.statement.indexOf("if")+"if".length(), + wordBeginsHere), current.center); recurse(current.center.center); } @@ -95,7 +95,7 @@ class ParserService { { current.right = new Node("then", current); - current.right.center = new Node(current.statement.substring(current.statement.indexOf("then")+4), + current.right.center = new Node(current.statement.substring(current.statement.indexOf("then")+"then".length()), current.right); recurse(current.right.center); } @@ -127,9 +127,4 @@ class ParserService { return statementList; } - - public void retrieveDefinitions(final ArrayList list) - { - // stub - } } 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 e2d32ed..9cd2005 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 @@ -3,12 +3,13 @@ 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.Mock; +import org.mockito.InjectMocks; import org.mockito.runners.MockitoJUnitRunner; import java.util.ArrayList; 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; @@ -16,28 +17,35 @@ import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ParserServiceTest { - @Mock - DefinitionController definitionControllerMock = mock(DefinitionController.class); + private final DefinitionController definitionControllerMock = mock(DefinitionController.class); + private final ParserService mockParserService = mock(ParserService.class); - @Mock - ParserService mps = mock(ParserService.class); - - ParserService ps = new ParserService(definitionControllerMock, null, + @InjectMocks + private final ParserService parserService = new ParserService(definitionControllerMock, null, null, null); @Test public void testEmptyStringEqualsEmptyString() { - assertEquals("0: \n", ps.parseRawInput("").toString()); + final String expected = "0: \n"; + final String actual = parserService.parseRawInput("").toString(); + + assertEquals(expected, actual); } @Test public void testUselessStringEqualsUselessString() { - assertEquals("0: cat\n", ps.parseRawInput("cat").toString()); + final String expected = "0: cat\n"; + final String actual = parserService.parseRawInput("cat").toString(); + + assertEquals(expected, actual); } @Test public void testSingleIfReturnsIfPlusEmptyString() { - assertEquals("0: if\n... 1: if\n... 2: \n\n", ps.parseRawInput("if").toString()); + final String expected = "0: if\n... 1: if\n... 2: \n\n"; + final String actual = parserService.parseRawInput("if").toString(); + + assertEquals(expected, actual); } @Test @@ -48,9 +56,9 @@ public class ParserServiceTest { "... 1: then\n" + "... 2: x^2 is even\n\n"; - final String testCase = "if x is even then x^2 is even"; + final String actual = parserService.parseRawInput("if x is even then x^2 is even").toString(); - assertEquals(expected, ps.parseRawInput(testCase).toString()); + assertEquals(expected, actual); } @Test @@ -61,9 +69,9 @@ public class ParserServiceTest { "... 1: then\n" + "... 2: x^2 is even.\n\n"; - final String testCase = "Let x be even. Then x^2 is even."; + final String actual = parserService.parseRawInput("Let x be even. Then x^2 is even.").toString(); - assertEquals(expected, ps.parseRawInput(testCase).toString()); + assertEquals(expected, actual); } @Test @@ -76,20 +84,20 @@ public class ParserServiceTest { "... 1: then\n" + "... 2: c.\n\n"; - final String testCase = "Let a. If b, then c."; + final String actual = parserService.parseRawInput("Let a. If b, then c.").toString(); - assertEquals(expected, ps.parseRawInput(testCase).toString()); + assertEquals(expected, actual); } @Test - public void testLetAlone() { + public void testLetStatementWithoutAnyIfOrThenStatements() { final String expected = "0: let a be equal to b.\n" + "... 1: let\n" + "... 2: a be equal to b.\n\n"; - final String testCase = "Let a be equal to b."; + final String actual = parserService.parseRawInput("Let a be equal to b.").toString(); - assertEquals(expected, ps.parseRawInput(testCase).toString()); + assertEquals(expected, actual); } @Test @@ -97,34 +105,38 @@ public class ParserServiceTest { final ArrayList expectedList = new ArrayList<>(); expectedList.add(""); - when(mps.parseRawInput(anyString())).thenReturn(new Node("", null)); + when(mockParserService.parseRawInput(anyString())).thenReturn(new Node("", null)); + final ArrayList actualList = parserService.retrieveStatements(mockParserService.parseRawInput("")); - assertEquals(expectedList, ps.retrieveStatements(mps.parseRawInput(""))); + assertEquals(expectedList, actualList); } @Test public void testBaseCaseReturnsXIsEven() { - final ArrayList expectation = new ArrayList<>(); - expectation.add("x is even"); - expectation.add("x^2 is even"); + final ArrayList expectedList = new ArrayList<>(); + expectedList.add("x is even"); + expectedList.add("x^2 is even"); - ps.root = new Node("if x is even then x^2 is even", null); - ps.root.center = new Node("if", ps.root); - ps.root.center.center = new Node(" x is even ", ps.root.center); - ps.root.right = new Node("then", ps.root); - ps.root.right.center = new Node(" x^2 is even", ps.root.right); - when(mps.parseRawInput(anyString())).thenReturn(ps.root); + final Node testNode = new Node("if x is even then x^2 is even", null); + testNode.center = new Node("if", testNode); + testNode.center.center = new Node(" x is even ", testNode.center); + testNode.right = new Node("then", testNode); + testNode.right.center = new Node(" x^2 is even", testNode.right); - assertEquals(expectation, ps.retrieveStatements(mps.parseRawInput("baseCase"))); + when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); + final ArrayList actualList = parserService.retrieveStatements(mockParserService.parseRawInput("baseCase")); + + assertEquals(expectedList, actualList); } @Test - public void testDriveParsingProcess() { - mps.root = new Node("", null); - final ArrayList testdummy = new ArrayList<>(); - when(mps.parseRawInput(anyString())).thenReturn(mps.root); - when(mps.retrieveStatements(mps.root)).thenReturn(testdummy); + public void testDriveParseUserInput() { + final Node testNode = new Node("", null); + when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); + when(mockParserService.retrieveStatements(testNode)).thenReturn(new ArrayList<>()); - ps.driveParsingProcess(""); + final boolean successfulTestDrive = parserService.parseUserInput(""); + + assertTrue(successfulTestDrive); } } \ No newline at end of file From 357e9b23cce433582406d03e6e6650775141211c Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Mon, 4 Mar 2019 22:24:27 -0700 Subject: [PATCH 21/76] PAN-10 Refactored direct access of fields to getter and setter methods. --- .../msudenver/tsp/services/parser/Node.java | 15 ++-- .../tsp/services/parser/ParserService.java | 76 +++++++++---------- .../services/parser/ParserServiceTest.java | 17 +++-- 3 files changed, 54 insertions(+), 54 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java b/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java index 2cf31d8..2b92dec 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java +++ b/services/src/main/java/edu/msudenver/tsp/services/parser/Node.java @@ -1,13 +1,16 @@ package edu.msudenver.tsp.services.parser; +import lombok.Getter; +import lombok.Setter; + public class Node { - String statement; - Node left; - Node right; - Node center; - Node parent; - int depth; + @Getter private final String statement; + @Getter @Setter private Node left; + @Getter @Setter private Node right; + @Getter @Setter private Node center; + @Getter private final Node parent; + @Getter private final int depth; public Node(final String statement, final Node parent) { 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 d440fb6..58e894d 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 @@ -8,6 +8,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.ArrayList; +import java.util.List; @Service class ParserService { @@ -30,7 +31,7 @@ class ParserService { { try { final Node tree = parseRawInput(userInput); - final ArrayList statements = retrieveStatements(tree); + final List statements = retrieveStatements(tree); return true; } catch(final Exception e) { @@ -58,72 +59,67 @@ class ParserService { { int wordBeginsHere; - if(current.statement.contains("let")) + if(current.getStatement().contains("let")) { - current.left = new Node("let", - current); + current.setLeft(new Node("let", current)); - if(current.statement.contains("if")){ - wordBeginsHere = current.statement.indexOf("if"); - } else if(current.statement.contains("then")){ - wordBeginsHere = current.statement.indexOf("then"); + if(current.getStatement().contains("if")){ + wordBeginsHere = current.getStatement().indexOf("if"); + } else if(current.getStatement().contains("then")){ + wordBeginsHere = current.getStatement().indexOf("then"); } else { - wordBeginsHere = current.statement.length(); + wordBeginsHere = current.getStatement().length(); } - current.left.center = new Node(current.statement.substring(current.statement.indexOf("let")+"let".length(), + current.getLeft().setCenter(new Node(current.getStatement().substring(current.getStatement().indexOf("let")+"let".length(), wordBeginsHere), - current.left); - recurse(current.left.center); + current.getLeft())); + recurse(current.getLeft().getCenter()); } - if(current.statement.contains("if")) + if(current.getStatement().contains("if")) { - current.center = new Node("if", - current); - wordBeginsHere = (current.statement.contains("then") ? current.statement.indexOf("then") : current.statement.length()); + current.setCenter(new Node("if", current)); + wordBeginsHere = (current.getStatement().contains("then") ? current.getStatement().indexOf("then") : current.getStatement().length()); - current.center.center = new Node(current.statement.substring(current.statement.indexOf("if")+"if".length(), + current.getCenter().setCenter(new Node(current.getStatement().substring(current.getStatement().indexOf("if")+"if".length(), wordBeginsHere), - current.center); - recurse(current.center.center); + current.getCenter())); + recurse(current.getCenter().getCenter()); } - if(current.statement.contains("then")) + if(current.getStatement().contains("then")) { - current.right = new Node("then", - current); - current.right.center = new Node(current.statement.substring(current.statement.indexOf("then")+"then".length()), - current.right); - recurse(current.right.center); + current.setRight(new Node("then", current)); + current.getRight().setCenter(new Node(current.getStatement().substring(current.getStatement().indexOf("then")+"then".length()), + current.getRight())); + recurse(current.getRight().getCenter()); } } - public ArrayList retrieveStatements(final Node parsedTree) + public List retrieveStatements(final Node parsedTree) { - final ArrayList statementList = new ArrayList<>(); - - traverse(parsedTree, statementList); - - return statementList; + return populateStatementList(parsedTree, new ArrayList<>()); } - private ArrayList traverse(final Node node, final ArrayList statementList) + private ArrayList populateStatementList(final Node node, final ArrayList statementList) { - if(node == null) return statementList; - - if(!(node.statement.contains("let") || node.statement.contains("if") || node.statement.contains("then"))) + if(node == null) { - statementList.add(node.statement.trim()); + return statementList; } - traverse(node.left, statementList); + final String statement = node.getStatement().trim(); + if(!(statement.contains("let") || statement.contains("if") || statement.contains("then"))) + { + statementList.add(statement); + } - traverse(node.center, statementList); - - traverse(node.right, statementList); + populateStatementList(node.getLeft(), statementList); + populateStatementList(node.getCenter(), statementList); + populateStatementList(node.getRight(), statementList); return statementList; } 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 9cd2005..829a02a 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 @@ -7,6 +7,7 @@ import org.mockito.InjectMocks; import org.mockito.runners.MockitoJUnitRunner; import java.util.ArrayList; +import java.util.List; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -102,29 +103,29 @@ public class ParserServiceTest { @Test public void testEmptyStringReturnsEmptyList() { - final ArrayList expectedList = new ArrayList<>(); + final List expectedList = new ArrayList<>(); expectedList.add(""); when(mockParserService.parseRawInput(anyString())).thenReturn(new Node("", null)); - final ArrayList actualList = parserService.retrieveStatements(mockParserService.parseRawInput("")); + final List actualList = parserService.retrieveStatements(mockParserService.parseRawInput("")); assertEquals(expectedList, actualList); } @Test public void testBaseCaseReturnsXIsEven() { - final ArrayList expectedList = new ArrayList<>(); + final List expectedList = new ArrayList<>(); expectedList.add("x is even"); expectedList.add("x^2 is even"); final Node testNode = new Node("if x is even then x^2 is even", null); - testNode.center = new Node("if", testNode); - testNode.center.center = new Node(" x is even ", testNode.center); - testNode.right = new Node("then", testNode); - testNode.right.center = new Node(" x^2 is even", testNode.right); + testNode.setCenter(new Node("if", testNode)); + testNode.getCenter().setCenter(new Node(" x is even ", testNode.getCenter())); + testNode.setRight(new Node("then", testNode)); + testNode.getRight().setCenter(new Node(" x^2 is even", testNode.getRight())); when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); - final ArrayList actualList = parserService.retrieveStatements(mockParserService.parseRawInput("baseCase")); + final List actualList = parserService.retrieveStatements(mockParserService.parseRawInput("baseCase")); assertEquals(expectedList, actualList); } From 2f5aef80925bd2e4d8aff7c443021059b99e696d Mon Sep 17 00:00:00 2001 From: BrittanyBi Date: Mon, 4 Mar 2019 23:00:26 -0700 Subject: [PATCH 22/76] PAN-10 ParserService.recurse() code refactored to be more readable. --- .../tsp/services/parser/ParserService.java | 48 ++++++++++++------- 1 file changed, 31 insertions(+), 17 deletions(-) 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 58e894d..d8f8782 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 @@ -57,35 +57,46 @@ class ParserService { private void recurse(final Node current) { - int wordBeginsHere; + int startIndex; + int endIndex; + final String statement = current.getStatement(); + String nextStatement; - if(current.getStatement().contains("let")) + if(statement.equals("")) + { + return; + } + + if(statement.contains("let")) { current.setLeft(new Node("let", current)); - if(current.getStatement().contains("if")){ - wordBeginsHere = current.getStatement().indexOf("if"); - } else if(current.getStatement().contains("then")){ - wordBeginsHere = current.getStatement().indexOf("then"); + startIndex = statement.indexOf("let")+"let".length(); + + if(statement.contains("if")){ + endIndex = statement.indexOf("if"); + } else if(statement.contains("then")){ + endIndex = statement.indexOf("then"); } else { - wordBeginsHere = current.getStatement().length(); + endIndex = statement.length(); } - current.getLeft().setCenter(new Node(current.getStatement().substring(current.getStatement().indexOf("let")+"let".length(), - wordBeginsHere), - current.getLeft())); + nextStatement = statement.substring(startIndex, endIndex); + + current.getLeft().setCenter(new Node(nextStatement, current.getLeft())); recurse(current.getLeft().getCenter()); } - if(current.getStatement().contains("if")) + if(statement.contains("if")) { current.setCenter(new Node("if", current)); - wordBeginsHere = (current.getStatement().contains("then") ? current.getStatement().indexOf("then") : current.getStatement().length()); - current.getCenter().setCenter(new Node(current.getStatement().substring(current.getStatement().indexOf("if")+"if".length(), - wordBeginsHere), - current.getCenter())); + startIndex = statement.indexOf("if")+"if".length(); + endIndex = (statement.contains("then") ? statement.indexOf("then") : statement.length()); + nextStatement = statement.substring(startIndex, endIndex); + + current.getCenter().setCenter(new Node(nextStatement, current.getCenter())); recurse(current.getCenter().getCenter()); } @@ -93,8 +104,11 @@ class ParserService { if(current.getStatement().contains("then")) { current.setRight(new Node("then", current)); - current.getRight().setCenter(new Node(current.getStatement().substring(current.getStatement().indexOf("then")+"then".length()), - current.getRight())); + + startIndex = statement.indexOf("then")+"then".length(); + nextStatement = statement.substring(startIndex); + + current.getRight().setCenter(new Node(nextStatement, current.getRight())); recurse(current.getRight().getCenter()); } } From 103d09bb0e6a529ed1b866dd15e8a5ba29a7f295 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Tue, 5 Mar 2019 11:48:18 -0700 Subject: [PATCH 23/76] PAN-10 added a null check to the recurse method --- .../tsp/services/parser/ParserService.java | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) 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 d8f8782..0106b8b 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 @@ -35,8 +35,9 @@ class ParserService { return true; } catch(final Exception e) { - return false; + e.printStackTrace(); } + return false; } public Node parseRawInput(String input) @@ -59,14 +60,16 @@ class ParserService { { int startIndex; int endIndex; - final String statement = current.getStatement(); - String nextStatement; + final String statement; - if(statement.equals("")) - { + if (current != null) { + statement = current.getStatement(); + } else { return; } + String nextStatement; + if(statement.contains("let")) { current.setLeft(new Node("let", current)); From d6b18c2279d98b80ca342ffb2d8ffb5a6ac32e11 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 7 Mar 2019 10:27:51 -0700 Subject: [PATCH 24/76] 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 25/76] 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 26/76] 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 e9661fdf78161ae9b565619b5b280c31b99f1de6 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 10 Mar 2019 11:48:34 -0600 Subject: [PATCH 27/76] PAN-60 created initial RestService --- services/build.gradle | 6 +- .../msudenver/tsp/services/RestService.java | 99 +++++++++++++++++++ 2 files changed, 104 insertions(+), 1 deletion(-) create mode 100644 services/src/main/java/edu/msudenver/tsp/services/RestService.java diff --git a/services/build.gradle b/services/build.gradle index a53319f..05efbeb 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -19,6 +19,10 @@ repositories { dependencies { compile project(':persistence') - testCompile group: 'junit', name: 'junit', version: '4.12' + compile group: 'org.apache.httpcomponents', name: 'httpcore', version: '4.4.11' + 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 group: 'junit', name: 'junit', version: '4.12' } diff --git a/services/src/main/java/edu/msudenver/tsp/services/RestService.java b/services/src/main/java/edu/msudenver/tsp/services/RestService.java new file mode 100644 index 0000000..d9473a2 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/RestService.java @@ -0,0 +1,99 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.apache.http.HttpResponse; +import org.apache.http.client.fluent.Request; +import org.apache.http.util.EntityUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Slf4j +@Service +public class RestService { + private static final Gson GSON = new Gson(); + private final RequestFactory requestFactory; + + @Autowired + public RestClient(final RequestFactory requestFactory) { + this.requestFactory = requestFactory; + } + + public boolean delete(final String uri, final Integer connectionTimeout, final Integer socketTimeout, final HttpStatus httpStatus) { + LOG.info("Sending DELETE {}", uri); + final Optional response = send(requestFactory.delete(uri), null, connectionTimeout, socketTimeout); + + return response.isPresent() && response.get().getStatusLine().getStatusCode() == httpStatus.value(); + } + + Optional get(final String uri, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout, final String auth) { + LOG.info("Sending GET {}", uri); + return send(requestFactory.get(uri), auth, connectionTimeout, socketTimeout, type); + } + + Optional post(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout) { + LOG.info("Sending POST {} with body: {}", uri, requestJson); + return send(requestFactory.post(uri, requestJson), null, connectionTimeout, socketTimeout, type); + } + + Optional post(final String uri, final String requestJson, final Integer connectionTimeout, final Integer socketTimeout) { + LOG.info("Sending POST {} with body: {}", uri, requestJson); + return send(requestFactory.post(uri, requestJson), null, connectionTimeout, socketTimeout); + } + + Optional put(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout, final String auth) { + LOG.info("Sending PUT {} with body: {}", uri, requestJson); + return send(requestFactory.put(uri, requestJson), auth, 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); + if (optionalHttpResponse.isPresent()) { + final HttpResponse httpResponse = optionalHttpResponse.get(); + LOG.info("Received {} response", httpResponse.getStatusLine().getStatusCode()); + + final String jsonResponse = httpResponse.getEntity() == null ? null : EntityUtils.toString(httpResponse.getEntity()); + if (StringUtils.isNotBlank(jsonResponse)) { + final T responses = GSON.fromJson(jsonResponse, type.getType()); + if (responses instanceof List) { + LOG.info("Found {} responses.", ((List) responses).size()); + if (((List) responses).isEmpty()) { + return Optional.empty(); + } + } + + return Optional.ofNullable(responses); + } + } + } catch (final Exception e) { + LOG.error("Could not send request", e); + } + + return Optional.empty(); + } + + private Optional send(final Request request, final String auth, final Integer connectionTimeout, final Integer socketTimeout) { + if (StringUtils.isNotBlank(auth)) { + request.addHeader("Authorization", "Basic " + auth); + } + + try { + return Optional.ofNullable(request.connectTimeout(connectionTimeout) + .socketTimeout(socketTimeout) + .execute() + .returnResponse()); + } catch (final Exception e) { + LOG.error("Could not send request", e); + return Optional.empty(); + } + } +} + + From 22e401062a1b4286d60cdeb47834d431edc2ab46 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 10 Mar 2019 12:03:11 -0600 Subject: [PATCH 28/76] PAN-60 created the RequestFactory --- .../msudenver/tsp/services/RestService.java | 3 ++- .../tsp/services/factory/RequestFactory.java | 25 +++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java 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 d9473a2..78f0cb9 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/RestService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/RestService.java @@ -2,6 +2,7 @@ package edu.msudenver.tsp.services; import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; +import edu.msudenver.tsp.services.factory.RequestFactory; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; import org.apache.http.HttpResponse; @@ -21,7 +22,7 @@ public class RestService { private final RequestFactory requestFactory; @Autowired - public RestClient(final RequestFactory requestFactory) { + public RestService(final RequestFactory requestFactory) { this.requestFactory = requestFactory; } 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 new file mode 100644 index 0000000..726b9a8 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java @@ -0,0 +1,25 @@ +package edu.msudenver.tsp.services.factory; + +import org.apache.commons.lang3.StringUtils; +import org.apache.http.client.fluent.Request; +import org.apache.http.entity.ContentType; +import org.springframework.stereotype.Service; + +@Service +public class RequestFactory { + public Request delete(final String uri) { + return Request.Delete(uri); + } + + public Request get(final String uri) { + return Request.Get(uri); + } + + public Request post(final String uri, final String requestJson) { + return StringUtils.isNotBlank(requestJson) ? Request.Post(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Post(uri); + } + + public Request put(final String uri, final String requestJson) { + return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Put(uri); + } +} \ No newline at end of file From c826185bba1e5fcc8453c58e58d000d6ecbd1ff5 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 10 Mar 2019 12:33:54 -0600 Subject: [PATCH 29/76] PAN-60 Created an example UserService --- .../tsp/persistence/dto/AccountDto.java | 26 ++++++++- .../tsp/persistence/dto/BaseDto.java | 2 +- .../tsp/persistence/dto/Definition.java | 2 +- .../tsp/persistence/dto/DefinitionDto.java | 2 +- .../tsp/persistence/dto/Notation.java | 2 +- .../msudenver/tsp/services/UserService.java | 57 +++++++++++++++++++ .../msudenver/tsp/services/dto/Account.java | 22 +++++++ .../msudenver/tsp/services/dto/BaseDto.java | 13 +++++ .../src/main/resources/application.properties | 3 + 9 files changed, 122 insertions(+), 7 deletions(-) create mode 100644 services/src/main/java/edu/msudenver/tsp/services/UserService.java create mode 100644 services/src/main/java/edu/msudenver/tsp/services/dto/Account.java create mode 100644 services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java create mode 100644 services/src/main/resources/application.properties 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..882826c 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 @@ -22,10 +22,30 @@ 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 administratorStatus; + @Temporal(TemporalType.DATE) private Date lastLogin; - public static final long serialVersionUID = 7095627971593953734L; + private static final long serialVersionUID = 7095627971593953734L; + + @JsonProperty("administrator_status") + public boolean getAdministratorStatus() { + return administratorStatus; + } + + @JsonProperty("administrator_status") + public void setAdministratorStatus(final boolean administratorStatus) { + this.administratorStatus = administratorStatus; + } + + @JsonProperty("last_login") + public Date getLastLogin() { + return lastLogin; + } + + @JsonProperty("last_login") + public void setLastLogin(final Date lastLogin) { + this.lastLogin = lastLogin; + } public interface Insert {} } 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/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java new file mode 100644 index 0000000..f119441 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -0,0 +1,57 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.GsonBuilder; +import com.google.gson.reflect.TypeToken; +import edu.msudenver.tsp.services.dto.Account; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; + +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; + +@Slf4j +@Service +public class UserService { + private final RestService restService; + @Value("${persistence.api.connection.timeout.milliseconds}") private int connectionTimeoutMilliseconds; + @Value("${persistence.api.socket.timeout.milliseconds}") private int socketTimeoutMilliseconds; + @Value("${persistence.api.base.url}") private String persistenceApiBaseUrl; + + @Autowired + public UserService(final RestService restService) { + this.restService = restService; + } + + public Optional createNewAccount(final Account account) { + if (account == null) { + LOG.error("Given null account, returning {}"); + return Optional.empty(); + } + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken() {}; + final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/accounts/", + new GsonBuilder().create().toJson(account), + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to create new account {}", account.toString()); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error creating new account {}", e); + return Optional.empty(); + } finally { + LOG.info("Create new account request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } +} 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 new file mode 100644 index 0000000..c82731a --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Account.java @@ -0,0 +1,22 @@ +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; +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +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; + @NotNull @SerializedName("administrator_status") private boolean administratorStatus; + @Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin; + + private static final long serialVersionUID = 7095627971593953734L; + +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java b/services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java new file mode 100644 index 0000000..4dc5dfd --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/BaseDto.java @@ -0,0 +1,13 @@ +package edu.msudenver.tsp.services.dto; + +import lombok.Data; + +import java.io.Serializable; + +@Data +public class BaseDto implements Serializable { + private int id; + private Integer version; + + private static final long serialVersionUID = 5343705942114910963L; +} diff --git a/services/src/main/resources/application.properties b/services/src/main/resources/application.properties new file mode 100644 index 0000000..ff86c7e --- /dev/null +++ b/services/src/main/resources/application.properties @@ -0,0 +1,3 @@ +persistence.api.connection.timeout.milliseconds = 5000 +persistence.api.socket.timeout.milliseconds = 10000 +persistence.api.base.url = http://localhost:8090/ \ No newline at end of file From f617ee7bd93bfc8647264617193cfe3517716703 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 10 Mar 2019 12:47:05 -0600 Subject: [PATCH 30/76] PAN-60 Fixed an issue with the connection to the database --- .../tsp/persistence/controller/NotationController.java | 2 +- .../msudenver/tsp/persistence/controller/ProofController.java | 2 +- .../msudenver/tsp/persistence/controller/TheoremController.java | 2 +- persistence/src/main/resources/application.properties | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) 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 index 35b8a86..b68bad1 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java @@ -7,5 +7,5 @@ import org.springframework.stereotype.Component; @Component @AllArgsConstructor public class NotationController { - final private NotationRepository notationRepository; + 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 51e5d25..e52b209 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 @@ -7,5 +7,5 @@ import org.springframework.stereotype.Component; @Component @AllArgsConstructor public class ProofController { - final private ProofRepository proofRepository; + private final ProofRepository proofRepository; } 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..9c26063 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 @@ -7,5 +7,5 @@ import org.springframework.stereotype.Component; @Component @AllArgsConstructor public class TheoremController { - final private TheoremRepository theoremRepository; + private final TheoremRepository theoremRepository; } diff --git a/persistence/src/main/resources/application.properties b/persistence/src/main/resources/application.properties index 0068dff..c7ecc80 100644 --- a/persistence/src/main/resources/application.properties +++ b/persistence/src/main/resources/application.properties @@ -1,6 +1,6 @@ spring.jpa.hibernate.ddl-auto = none spring.jpa.database=mysql -spring.datasource.url=jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false +spring.datasource.url=jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false&serverTimezone=UTC spring.datasource.username=panda spring.datasource.password=secret spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver From f4c7b55b62a43d910fdc3d58d0465e7066011b08 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 10 Mar 2019 13:00:59 -0600 Subject: [PATCH 31/76] PAN-60 Fixed a refactoring issue --- .../msudenver/tsp/persistence/AccountsIntegrationTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 b30a252..d442d01 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -29,7 +29,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("test password", savedAccount.getPassword()); - assertTrue(savedAccount.isAdministratorStatus()); + assertTrue(savedAccount.getAdministratorStatus()); savedAccount.setPassword("Test Update"); @@ -37,7 +37,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); - assertTrue(savedAccount.isAdministratorStatus()); + assertTrue(savedAccount.getAdministratorStatus()); assertEquals(updatedAccount.getId(), id); accountsRepository.delete(accountDto); From fd760293ef3787128eb00c7dac3136b8841f3458 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Mon, 11 Mar 2019 00:09:34 -0600 Subject: [PATCH 32/76] 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 33/76] 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 34/76] 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 35/76] 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 36/76] 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 37/76] 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 38/76] 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 39/76] 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 40/76] 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 41/76] 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 139dc943c3b64e48e487b64f7dbf693e2f8e764c Mon Sep 17 00:00:00 2001 From: - <-> Date: Thu, 14 Mar 2019 16:58:17 -0600 Subject: [PATCH 42/76] PAN-16 finished --- build.gradle | 142 +-------- gradlew~Stashed changes | 295 ++++++++---------- ...damonium-theorem-prover.main.kotlin_module | Bin 16 -> 0 bytes persistence/build.gradle | 6 +- services/build.gradle | 6 +- .../msudenver/tsp/website/Application.java | 17 +- .../msudenver/tsp/website/ProofsDriver.java | 1 + .../tsp/website/TheoremEntryController.java | 43 +++ .../msudenver/tsp/website/forms/Theorem.java | 19 ++ .../tsp/website/service/ProofDriver.java | 16 + src/main/resources/application.properties | 2 + src/main/webapp/WEB-INF/jsp/Theorem.jsp | 15 + src/main/webapp/WEB-INF/jsp/success.jsp | 6 + src/main/webapp/WEB-INF/jsp/welcome.jsp | 12 + src/main/webapp/index.jsp | 16 - utilities/build.gradle | 6 +- 16 files changed, 275 insertions(+), 327 deletions(-) delete mode 100644 out/production/classes/META-INF/edu.msudenver.tsp.pandamonium-theorem-prover.main.kotlin_module create mode 100644 src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java create mode 100644 src/main/java/edu/msudenver/tsp/website/forms/Theorem.java create mode 100644 src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java create mode 100644 src/main/resources/application.properties create mode 100644 src/main/webapp/WEB-INF/jsp/Theorem.jsp create mode 100644 src/main/webapp/WEB-INF/jsp/success.jsp create mode 100644 src/main/webapp/WEB-INF/jsp/welcome.jsp delete mode 100644 src/main/webapp/index.jsp diff --git a/build.gradle b/build.gradle index 6690226..4e8c15d 100644 --- a/build.gradle +++ b/build.gradle @@ -1,97 +1,23 @@ buildscript { + ext { + springBootVersion = '1.4.3.RELEASE' + } repositories { mavenCentral() } dependencies { - classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE") + classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } -plugins { - id 'groovy' - id 'java' - id 'org.jetbrains.kotlin.jvm' version '1.3.11' - id 'net.ltgt.apt' version '0.10' - id "org.sonarqube" version "2.6" - id 'org.unbroken-dome.test-sets' version '1.4.5' - id 'war' -} - +apply plugin: 'java' +apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' -description = 'Pandamonium Theorem Prover' - -group 'edu.msudenver.tsp' -version '1.0' - -ext['slf4j.version'] = '1.7.22' -ext['classmate.version'] = '1.3.1' -ext['joda-time.version'] = '2.9.7' - -def branch = 'git symbolic-ref --short HEAD'.execute().text.trim() - -sonarqube { - properties { - property "sonar.projectName", 'Pandamonium Theorem Prover' - } +jar { + baseName = 'boot-gradle' + version = '0.0.1-SNAPSHOT' } - -allprojects { - sonarqube { - properties { - property "sonar.host.url", "https://sonarcloud.io" - property "sonar.projectKey", "atusa17_ptp" - property "sonar.organization", "atusa17-github" - property "sonar.login", "9dcc611cd79f175459248b053b25450e36e38463" - } - } - apply plugin: 'java' - apply plugin: 'jacoco' - apply plugin: 'org.unbroken-dome.test-sets' - apply plugin: 'idea' - apply plugin: 'io.spring.dependency-management' -} - -subprojects { - apply plugin: 'java' - repositories { - mavenCentral() - } - - dependencies { - compile 'org.apache.commons:commons-lang3:3.5' - // The production code uses the SLF4J logging API at compile time - compile 'org.slf4j:slf4j-api:1.7.21' - compile "joda-time:joda-time:2.2" - compile('org.springframework:spring-context:5.0.9.RELEASE') - - compileOnly 'org.projectlombok:lombok:1.18.4' - - testCompile group: 'junit', name: 'junit', version: '4.11' - testCompile group: 'junit', name: 'junit', version: '4.12' - testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} - - } - - test { - if (System.properties['test.profile'] != 'integrationTest') { - exclude '**/*integrationTest*' - } else { - exclude '**/*edu/*' - } - } - - testSets { - unitTest - integrationTest - } -} - -bootJar { - baseName = 'gs-spring-boot' - version = '0.1.0' -} - sourceCompatibility = 1.8 targetCompatibility = 1.8 @@ -99,51 +25,9 @@ repositories { mavenCentral() } + dependencies { - compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8" - compile 'org.codehaus.groovy:groovy-all:2.3.11' - compile 'org.apache.commons:commons-lang3:3.5' - // The production code uses the SLF4J logging API at compile time - compile 'org.slf4j:slf4j-api:1.7.22' - compile "joda-time:joda-time:2.2" - compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' - - testCompile group: 'junit', name: 'junit', version: '4.12' - testCompile "org.springframework:spring-test:5.0.9.RELEASE" - testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} - - compileOnly 'org.projectlombok:lombok:1.18.4' - - apt 'org.projectlombok:lombok:1.18.4' -} - -project(':persistence') { - dependencies { - compile project(':utilities') - } -} - -test { - if (System.properties['test.profile'] != 'integrationTest') { - exclude '**/*integrationTest*' - } else { - exclude '**/*edu/*' - } -} - -testSets { - unitTest - integrationTest -} - -compileKotlin { - kotlinOptions.jvmTarget = "1.8" -} -compileTestKotlin { - kotlinOptions.jvmTarget = "1.8" -} - -wrapper { - gradleVersion = '5.2.1' - distributionType = Wrapper.DistributionType.ALL + compile('org.springframework.boot:spring-boot-starter-web','org.apache.tomcat.embed:tomcat-embed-jasper' + ,'javax.servlet:jstl') + testCompile('org.springframework.boot:spring-boot-starter-test') } \ No newline at end of file diff --git a/gradlew~Stashed changes b/gradlew~Stashed changes index 4453cce..6690226 100755 --- a/gradlew~Stashed changes +++ b/gradlew~Stashed changes @@ -1,172 +1,149 @@ -#!/usr/bin/env sh - -############################################################################## -## -## Gradle start up script for UN*X -## -############################################################################## - -# Attempt to set APP_HOME -# Resolve links: $0 may be a link -PRG="$0" -# Need this for relative symlinks. -while [ -h "$PRG" ] ; do - ls=`ls -ld "$PRG"` - link=`expr "$ls" : '.*-> \(.*\)$'` - if expr "$link" : '/.*' > /dev/null; then - PRG="$link" - else - PRG=`dirname "$PRG"`"/$link" - fi -done -SAVED="`pwd`" -cd "`dirname \"$PRG\"`/" >/dev/null -APP_HOME="`pwd -P`" -cd "$SAVED" >/dev/null - -APP_NAME="Gradle" -APP_BASE_NAME=`basename "$0"` - -# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS="" - -# Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD="maximum" - -warn ( ) { - echo "$*" +buildscript { + repositories { + mavenCentral() + } + dependencies { + classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE") + } } -die ( ) { - echo - echo "$*" - echo - exit 1 +plugins { + id 'groovy' + id 'java' + id 'org.jetbrains.kotlin.jvm' version '1.3.11' + id 'net.ltgt.apt' version '0.10' + id "org.sonarqube" version "2.6" + id 'org.unbroken-dome.test-sets' version '1.4.5' + id 'war' } -# OS specific support (must be 'true' or 'false'). -cygwin=false -msys=false -darwin=false -nonstop=false -case "`uname`" in - CYGWIN* ) - cygwin=true - ;; - Darwin* ) - darwin=true - ;; - MINGW* ) - msys=true - ;; - NONSTOP* ) - nonstop=true - ;; -esac +apply plugin: 'org.springframework.boot' -CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar +description = 'Pandamonium Theorem Prover' -# Determine the Java command to use to start the JVM. -if [ -n "$JAVA_HOME" ] ; then - if [ -x "$JAVA_HOME/jre/sh/java" ] ; then - # IBM's JDK on AIX uses strange locations for the executables - JAVACMD="$JAVA_HOME/jre/sh/java" - else - JAVACMD="$JAVA_HOME/bin/java" - fi - if [ ! -x "$JAVACMD" ] ; then - die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME +group 'edu.msudenver.tsp' +version '1.0' -Please set the JAVA_HOME variable in your environment to match the -location of your Java installation." - fi -else - JAVACMD="java" - which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +ext['slf4j.version'] = '1.7.22' +ext['classmate.version'] = '1.3.1' +ext['joda-time.version'] = '2.9.7' -Please set the JAVA_HOME variable in your environment to match the -location of your Java installation." -fi +def branch = 'git symbolic-ref --short HEAD'.execute().text.trim() -# Increase the maximum file descriptors if we can. -if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then - MAX_FD_LIMIT=`ulimit -H -n` - if [ $? -eq 0 ] ; then - if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then - MAX_FD="$MAX_FD_LIMIT" - fi - ulimit -n $MAX_FD - if [ $? -ne 0 ] ; then - warn "Could not set maximum file descriptor limit: $MAX_FD" - fi - else - warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" - fi -fi - -# For Darwin, add options to specify how the application appears in the dock -if $darwin; then - GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" -fi - -# For Cygwin, switch paths to Windows format before running java -if $cygwin ; then - APP_HOME=`cygpath --path --mixed "$APP_HOME"` - CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` - JAVACMD=`cygpath --unix "$JAVACMD"` - - # We build the pattern for arguments to be converted via cygpath - ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` - SEP="" - for dir in $ROOTDIRSRAW ; do - ROOTDIRS="$ROOTDIRS$SEP$dir" - SEP="|" - done - OURCYGPATTERN="(^($ROOTDIRS))" - # Add a user-defined pattern to the cygpath arguments - if [ "$GRADLE_CYGPATTERN" != "" ] ; then - OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" - fi - # Now convert the arguments - kludge to limit ourselves to /bin/sh - i=0 - for arg in "$@" ; do - CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` - CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option - - if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition - eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` - else - eval `echo args$i`="\"$arg\"" - fi - i=$((i+1)) - done - case $i in - (0) set -- ;; - (1) set -- "$args0" ;; - (2) set -- "$args0" "$args1" ;; - (3) set -- "$args0" "$args1" "$args2" ;; - (4) set -- "$args0" "$args1" "$args2" "$args3" ;; - (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; - (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; - (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; - (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; - (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; - esac -fi - -# Escape application args -save ( ) { - for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done - echo " " +sonarqube { + properties { + property "sonar.projectName", 'Pandamonium Theorem Prover' + } } -APP_ARGS=$(save "$@") -# Collect all arguments for the java command, following the shell quoting and substitution rules -eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" +allprojects { + sonarqube { + properties { + property "sonar.host.url", "https://sonarcloud.io" + property "sonar.projectKey", "atusa17_ptp" + property "sonar.organization", "atusa17-github" + property "sonar.login", "9dcc611cd79f175459248b053b25450e36e38463" + } + } + apply plugin: 'java' + apply plugin: 'jacoco' + apply plugin: 'org.unbroken-dome.test-sets' + apply plugin: 'idea' + apply plugin: 'io.spring.dependency-management' +} -# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong -if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then - cd "$(dirname "$0")" -fi +subprojects { + apply plugin: 'java' + repositories { + mavenCentral() + } -exec "$JAVACMD" "$@" + dependencies { + compile 'org.apache.commons:commons-lang3:3.5' + // The production code uses the SLF4J logging API at compile time + compile 'org.slf4j:slf4j-api:1.7.21' + compile "joda-time:joda-time:2.2" + compile('org.springframework:spring-context:5.0.9.RELEASE') + + compileOnly 'org.projectlombok:lombok:1.18.4' + + testCompile group: 'junit', name: 'junit', version: '4.11' + testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} + + } + + test { + if (System.properties['test.profile'] != 'integrationTest') { + exclude '**/*integrationTest*' + } else { + exclude '**/*edu/*' + } + } + + testSets { + unitTest + integrationTest + } +} + +bootJar { + baseName = 'gs-spring-boot' + version = '0.1.0' +} + +sourceCompatibility = 1.8 +targetCompatibility = 1.8 + +repositories { + mavenCentral() +} + +dependencies { + compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8" + compile 'org.codehaus.groovy:groovy-all:2.3.11' + compile 'org.apache.commons:commons-lang3:3.5' + // The production code uses the SLF4J logging API at compile time + compile 'org.slf4j:slf4j-api:1.7.22' + compile "joda-time:joda-time:2.2" + compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' + + testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile "org.springframework:spring-test:5.0.9.RELEASE" + testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} + + compileOnly 'org.projectlombok:lombok:1.18.4' + + apt 'org.projectlombok:lombok:1.18.4' +} + +project(':persistence') { + dependencies { + compile project(':utilities') + } +} + +test { + if (System.properties['test.profile'] != 'integrationTest') { + exclude '**/*integrationTest*' + } else { + exclude '**/*edu/*' + } +} + +testSets { + unitTest + integrationTest +} + +compileKotlin { + kotlinOptions.jvmTarget = "1.8" +} +compileTestKotlin { + kotlinOptions.jvmTarget = "1.8" +} + +wrapper { + gradleVersion = '5.2.1' + distributionType = Wrapper.DistributionType.ALL +} \ No newline at end of file diff --git a/out/production/classes/META-INF/edu.msudenver.tsp.pandamonium-theorem-prover.main.kotlin_module b/out/production/classes/META-INF/edu.msudenver.tsp.pandamonium-theorem-prover.main.kotlin_module deleted file mode 100644 index 8fb60192d378759239a3ecbf60eac8c8de446e9c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 16 RcmZQzU|?ooU|@t|UH|}6022TJ diff --git a/persistence/build.gradle b/persistence/build.gradle index b832e7e..52341ee 100644 --- a/persistence/build.gradle +++ b/persistence/build.gradle @@ -9,11 +9,7 @@ version '1.0' sourceCompatibility = 1.8 -sonarqube { - properties { - property "sonar.projectName", 'Pandamonium Persistence Tier' - } -} + repositories { mavenCentral() diff --git a/services/build.gradle b/services/build.gradle index 05efbeb..ff4cffd 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -7,11 +7,7 @@ version '1.0' sourceCompatibility = 1.8 -sonarqube { - properties { - property "sonar.projectName", 'Theorem Prover Services' - } -} + repositories { mavenCentral() diff --git a/src/main/java/edu/msudenver/tsp/website/Application.java b/src/main/java/edu/msudenver/tsp/website/Application.java index c8f0854..1d5b42e 100644 --- a/src/main/java/edu/msudenver/tsp/website/Application.java +++ b/src/main/java/edu/msudenver/tsp/website/Application.java @@ -1,23 +1,21 @@ package edu.msudenver.tsp.website; -import lombok.extern.slf4j.Slf4j; -import org.springframework.boot.CommandLineRunner; + import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; -import org.springframework.context.ApplicationContext; -import org.springframework.context.annotation.Bean; -import java.util.Arrays; -@Slf4j +//import lombok.extern.slf4j.Slf4j; + @SpringBootApplication public class Application { public static void main(final String[] args) { SpringApplication.run(Application.class, args); } +} - @Bean + /*@Bean public CommandLineRunner commandLineRunner(final ApplicationContext ctx) { return args -> { @@ -28,6 +26,9 @@ public class Application { for (final String beanName : beanNames) { LOG.info(beanName); } - }; + } } } +*/ + + diff --git a/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java b/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java index a6d4715..a8a5de0 100644 --- a/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java +++ b/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java @@ -1,4 +1,5 @@ package edu.msudenver.tsp.website; public class ProofsDriver { + //Business Logic will go here } diff --git a/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java b/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java new file mode 100644 index 0000000..c62f84a --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java @@ -0,0 +1,43 @@ +package edu.msudenver.tsp.website; + +import edu.msudenver.tsp.website.forms.Theorem; +import edu.msudenver.tsp.website.service.ProofDriver; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.ui.Model; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.servlet.ModelAndView; + + +@Controller +public class TheoremEntryController { + + @Autowired + ProofDriver proofDriver; + + @RequestMapping("/welcome") + public ModelAndView firstPage() + { + return new ModelAndView("welcome"); + } + + @RequestMapping("/theorem") + public ModelAndView theoremPage() + { + return new ModelAndView("Theorem"); + } + + + @RequestMapping(value = "/save", method = RequestMethod.POST) + public String saveTheorem(@Validated Theorem theorem, Model model) { + proofDriver.processProof(theorem.getTheoremName()); + model.addAttribute("theromName", theorem.getTheoremName()); + return "success"; + } + + +} + + diff --git a/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java b/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java new file mode 100644 index 0000000..07524df --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java @@ -0,0 +1,19 @@ +package edu.msudenver.tsp.website.forms; + +public class Theorem { + private String theoremName ; + + + public String getTheoremName() { + return theoremName; + } + + public void setTheoremName(String theoremName) { + this.theoremName = theoremName; + } + + + + + +} diff --git a/src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java b/src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java new file mode 100644 index 0000000..b95c206 --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java @@ -0,0 +1,16 @@ +package edu.msudenver.tsp.website.service; + +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; + +@Service +public class ProofDriver { + List theromList = new ArrayList(); + public String processProof(String theoremName){ + //Business Logic + return theoremName + "Accepted"; + } + +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 0000000..f3ce324 --- /dev/null +++ b/src/main/resources/application.properties @@ -0,0 +1,2 @@ +spring.mvc.view.prefix:/WEB-INF/jsp/ +spring.mvc.view.suffix:.jsp \ No newline at end of file diff --git a/src/main/webapp/WEB-INF/jsp/Theorem.jsp b/src/main/webapp/WEB-INF/jsp/Theorem.jsp new file mode 100644 index 0000000..d9f580b --- /dev/null +++ b/src/main/webapp/WEB-INF/jsp/Theorem.jsp @@ -0,0 +1,15 @@ +<%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + +Theroem Page + + +
+Enter Theroem Name
+ +
+ + \ No newline at end of file diff --git a/src/main/webapp/WEB-INF/jsp/success.jsp b/src/main/webapp/WEB-INF/jsp/success.jsp new file mode 100644 index 0000000..6919cde --- /dev/null +++ b/src/main/webapp/WEB-INF/jsp/success.jsp @@ -0,0 +1,6 @@ + + +Name:<%= request.getParameter("theoremName")%> + + + \ No newline at end of file diff --git a/src/main/webapp/WEB-INF/jsp/welcome.jsp b/src/main/webapp/WEB-INF/jsp/welcome.jsp new file mode 100644 index 0000000..c3d088f --- /dev/null +++ b/src/main/webapp/WEB-INF/jsp/welcome.jsp @@ -0,0 +1,12 @@ +<%@ page language="java" contentType="text/html; charset=ISO-8859-1" + pageEncoding="ISO-8859-1"%> + + + + + Guru Success Page + + +Welcome User!!!! + + \ No newline at end of file diff --git a/src/main/webapp/index.jsp b/src/main/webapp/index.jsp deleted file mode 100644 index f8d618c..0000000 --- a/src/main/webapp/index.jsp +++ /dev/null @@ -1,16 +0,0 @@ -<%-- - Created by IntelliJ IDEA. - User: atusa - Date: 2/1/19 - Time: 8:03 PM - To change this template use File | Settings | File Templates. ---%> -<%@ page contentType="text/html;charset=UTF-8" language="java" %> - - - $Title$ - - - $END$ - - diff --git a/utilities/build.gradle b/utilities/build.gradle index b9e2ce9..24beb45 100644 --- a/utilities/build.gradle +++ b/utilities/build.gradle @@ -7,11 +7,7 @@ version '1.0' sourceCompatibility = 1.8 -sonarqube { - properties { - property "sonar.projectName", 'Parsing and Proofs Utilities' - } -} + repositories { mavenCentral() From c45c0a61080487efdcc2f3ab20df07f5e4f4565e Mon Sep 17 00:00:00 2001 From: - <-> Date: Thu, 14 Mar 2019 17:04:10 -0600 Subject: [PATCH 43/76] add to PAN-16 --- .../resources/application.properties | 2 + .../persistence/TheoremsIntegrationTest.java | 84 +++++ .../tsp/persistence/dto/TheoremType.java | 5 + .../controller/TheoremControllerTest.java | 314 ++++++++++++++++++ src/main/webapp/index.jsp | 16 + 5 files changed, 421 insertions(+) create mode 100644 out/production/resources/application.properties create mode 100644 persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java create mode 100644 persistence/src/main/java/edu/msudenver/tsp/persistence/dto/TheoremType.java create mode 100644 persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java create mode 100644 src/main/webapp/index.jsp diff --git a/out/production/resources/application.properties b/out/production/resources/application.properties new file mode 100644 index 0000000..f3ce324 --- /dev/null +++ b/out/production/resources/application.properties @@ -0,0 +1,2 @@ +spring.mvc.view.prefix:/WEB-INF/jsp/ +spring.mvc.view.suffix:.jsp \ No newline at end of file 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..a6109f2 --- /dev/null +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java @@ -0,0 +1,84 @@ +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.getProvenStatus()); + 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.getProvenStatus()); + 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); + + 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/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 +} 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..f3993cc --- /dev/null +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -0,0 +1,314 @@ +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.Collections; +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 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(); + 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 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(); + 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 diff --git a/src/main/webapp/index.jsp b/src/main/webapp/index.jsp new file mode 100644 index 0000000..f8d618c --- /dev/null +++ b/src/main/webapp/index.jsp @@ -0,0 +1,16 @@ +<%-- + Created by IntelliJ IDEA. + User: atusa + Date: 2/1/19 + Time: 8:03 PM + To change this template use File | Settings | File Templates. +--%> +<%@ page contentType="text/html;charset=UTF-8" language="java" %> + + + $Title$ + + + $END$ + + From 401383f5da30a076b019935d9e3f507255750665 Mon Sep 17 00:00:00 2001 From: Alex Tusa <41128169+atusa17@users.noreply.github.com> Date: Thu, 14 Mar 2019 20:45:56 -0600 Subject: [PATCH 44/76] Delete gradlew~Stashed changes --- gradlew~Stashed changes | 149 ---------------------------------------- 1 file changed, 149 deletions(-) delete mode 100755 gradlew~Stashed changes diff --git a/gradlew~Stashed changes b/gradlew~Stashed changes deleted file mode 100755 index 6690226..0000000 --- a/gradlew~Stashed changes +++ /dev/null @@ -1,149 +0,0 @@ -buildscript { - repositories { - mavenCentral() - } - dependencies { - classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE") - } -} - -plugins { - id 'groovy' - id 'java' - id 'org.jetbrains.kotlin.jvm' version '1.3.11' - id 'net.ltgt.apt' version '0.10' - id "org.sonarqube" version "2.6" - id 'org.unbroken-dome.test-sets' version '1.4.5' - id 'war' -} - -apply plugin: 'org.springframework.boot' - -description = 'Pandamonium Theorem Prover' - -group 'edu.msudenver.tsp' -version '1.0' - -ext['slf4j.version'] = '1.7.22' -ext['classmate.version'] = '1.3.1' -ext['joda-time.version'] = '2.9.7' - -def branch = 'git symbolic-ref --short HEAD'.execute().text.trim() - -sonarqube { - properties { - property "sonar.projectName", 'Pandamonium Theorem Prover' - } -} - -allprojects { - sonarqube { - properties { - property "sonar.host.url", "https://sonarcloud.io" - property "sonar.projectKey", "atusa17_ptp" - property "sonar.organization", "atusa17-github" - property "sonar.login", "9dcc611cd79f175459248b053b25450e36e38463" - } - } - apply plugin: 'java' - apply plugin: 'jacoco' - apply plugin: 'org.unbroken-dome.test-sets' - apply plugin: 'idea' - apply plugin: 'io.spring.dependency-management' -} - -subprojects { - apply plugin: 'java' - repositories { - mavenCentral() - } - - dependencies { - compile 'org.apache.commons:commons-lang3:3.5' - // The production code uses the SLF4J logging API at compile time - compile 'org.slf4j:slf4j-api:1.7.21' - compile "joda-time:joda-time:2.2" - compile('org.springframework:spring-context:5.0.9.RELEASE') - - compileOnly 'org.projectlombok:lombok:1.18.4' - - testCompile group: 'junit', name: 'junit', version: '4.11' - testCompile group: 'junit', name: 'junit', version: '4.12' - testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} - - } - - test { - if (System.properties['test.profile'] != 'integrationTest') { - exclude '**/*integrationTest*' - } else { - exclude '**/*edu/*' - } - } - - testSets { - unitTest - integrationTest - } -} - -bootJar { - baseName = 'gs-spring-boot' - version = '0.1.0' -} - -sourceCompatibility = 1.8 -targetCompatibility = 1.8 - -repositories { - mavenCentral() -} - -dependencies { - compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8" - compile 'org.codehaus.groovy:groovy-all:2.3.11' - compile 'org.apache.commons:commons-lang3:3.5' - // The production code uses the SLF4J logging API at compile time - compile 'org.slf4j:slf4j-api:1.7.22' - compile "joda-time:joda-time:2.2" - compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' - - testCompile group: 'junit', name: 'junit', version: '4.12' - testCompile "org.springframework:spring-test:5.0.9.RELEASE" - testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} - - compileOnly 'org.projectlombok:lombok:1.18.4' - - apt 'org.projectlombok:lombok:1.18.4' -} - -project(':persistence') { - dependencies { - compile project(':utilities') - } -} - -test { - if (System.properties['test.profile'] != 'integrationTest') { - exclude '**/*integrationTest*' - } else { - exclude '**/*edu/*' - } -} - -testSets { - unitTest - integrationTest -} - -compileKotlin { - kotlinOptions.jvmTarget = "1.8" -} -compileTestKotlin { - kotlinOptions.jvmTarget = "1.8" -} - -wrapper { - gradleVersion = '5.2.1' - distributionType = Wrapper.DistributionType.ALL -} \ No newline at end of file From 0afe995950e608b89567d687f636191b25394c74 Mon Sep 17 00:00:00 2001 From: - <-> Date: Fri, 15 Mar 2019 01:44:51 -0600 Subject: [PATCH 45/76] Reverted build file changes --- build.gradle | 142 ++++++++++++++++-- persistence/build.gradle | 6 +- services/build.gradle | 8 +- .../msudenver/tsp/website/Application.java | 18 --- utilities/build.gradle | 6 +- 5 files changed, 145 insertions(+), 35 deletions(-) diff --git a/build.gradle b/build.gradle index 4e8c15d..6690226 100644 --- a/build.gradle +++ b/build.gradle @@ -1,23 +1,97 @@ buildscript { - ext { - springBootVersion = '1.4.3.RELEASE' - } repositories { mavenCentral() } dependencies { - classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") + classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE") } } -apply plugin: 'java' -apply plugin: 'eclipse' +plugins { + id 'groovy' + id 'java' + id 'org.jetbrains.kotlin.jvm' version '1.3.11' + id 'net.ltgt.apt' version '0.10' + id "org.sonarqube" version "2.6" + id 'org.unbroken-dome.test-sets' version '1.4.5' + id 'war' +} + apply plugin: 'org.springframework.boot' -jar { - baseName = 'boot-gradle' - version = '0.0.1-SNAPSHOT' +description = 'Pandamonium Theorem Prover' + +group 'edu.msudenver.tsp' +version '1.0' + +ext['slf4j.version'] = '1.7.22' +ext['classmate.version'] = '1.3.1' +ext['joda-time.version'] = '2.9.7' + +def branch = 'git symbolic-ref --short HEAD'.execute().text.trim() + +sonarqube { + properties { + property "sonar.projectName", 'Pandamonium Theorem Prover' + } } + +allprojects { + sonarqube { + properties { + property "sonar.host.url", "https://sonarcloud.io" + property "sonar.projectKey", "atusa17_ptp" + property "sonar.organization", "atusa17-github" + property "sonar.login", "9dcc611cd79f175459248b053b25450e36e38463" + } + } + apply plugin: 'java' + apply plugin: 'jacoco' + apply plugin: 'org.unbroken-dome.test-sets' + apply plugin: 'idea' + apply plugin: 'io.spring.dependency-management' +} + +subprojects { + apply plugin: 'java' + repositories { + mavenCentral() + } + + dependencies { + compile 'org.apache.commons:commons-lang3:3.5' + // The production code uses the SLF4J logging API at compile time + compile 'org.slf4j:slf4j-api:1.7.21' + compile "joda-time:joda-time:2.2" + compile('org.springframework:spring-context:5.0.9.RELEASE') + + compileOnly 'org.projectlombok:lombok:1.18.4' + + testCompile group: 'junit', name: 'junit', version: '4.11' + testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} + + } + + test { + if (System.properties['test.profile'] != 'integrationTest') { + exclude '**/*integrationTest*' + } else { + exclude '**/*edu/*' + } + } + + testSets { + unitTest + integrationTest + } +} + +bootJar { + baseName = 'gs-spring-boot' + version = '0.1.0' +} + sourceCompatibility = 1.8 targetCompatibility = 1.8 @@ -25,9 +99,51 @@ repositories { mavenCentral() } - dependencies { - compile('org.springframework.boot:spring-boot-starter-web','org.apache.tomcat.embed:tomcat-embed-jasper' - ,'javax.servlet:jstl') - testCompile('org.springframework.boot:spring-boot-starter-test') + compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8" + compile 'org.codehaus.groovy:groovy-all:2.3.11' + compile 'org.apache.commons:commons-lang3:3.5' + // The production code uses the SLF4J logging API at compile time + compile 'org.slf4j:slf4j-api:1.7.22' + compile "joda-time:joda-time:2.2" + compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' + + testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile "org.springframework:spring-test:5.0.9.RELEASE" + testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} + + compileOnly 'org.projectlombok:lombok:1.18.4' + + apt 'org.projectlombok:lombok:1.18.4' +} + +project(':persistence') { + dependencies { + compile project(':utilities') + } +} + +test { + if (System.properties['test.profile'] != 'integrationTest') { + exclude '**/*integrationTest*' + } else { + exclude '**/*edu/*' + } +} + +testSets { + unitTest + integrationTest +} + +compileKotlin { + kotlinOptions.jvmTarget = "1.8" +} +compileTestKotlin { + kotlinOptions.jvmTarget = "1.8" +} + +wrapper { + gradleVersion = '5.2.1' + distributionType = Wrapper.DistributionType.ALL } \ No newline at end of file diff --git a/persistence/build.gradle b/persistence/build.gradle index 52341ee..b832e7e 100644 --- a/persistence/build.gradle +++ b/persistence/build.gradle @@ -9,7 +9,11 @@ version '1.0' sourceCompatibility = 1.8 - +sonarqube { + properties { + property "sonar.projectName", 'Pandamonium Persistence Tier' + } +} repositories { mavenCentral() diff --git a/services/build.gradle b/services/build.gradle index ff4cffd..f63faa6 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -7,7 +7,11 @@ version '1.0' sourceCompatibility = 1.8 - +sonarqube { + properties { + property "sonar.projectName", 'Theorem Prover Services' + } +} repositories { mavenCentral() @@ -19,6 +23,6 @@ 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 group: 'junit', name: 'junit', version: '4.12' } diff --git a/src/main/java/edu/msudenver/tsp/website/Application.java b/src/main/java/edu/msudenver/tsp/website/Application.java index 1d5b42e..17154e8 100644 --- a/src/main/java/edu/msudenver/tsp/website/Application.java +++ b/src/main/java/edu/msudenver/tsp/website/Application.java @@ -4,9 +4,6 @@ package edu.msudenver.tsp.website; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; - -//import lombok.extern.slf4j.Slf4j; - @SpringBootApplication public class Application { @@ -15,20 +12,5 @@ public class Application { } } - /*@Bean - public CommandLineRunner commandLineRunner(final ApplicationContext ctx) { - return args -> { - - LOG.info("Beans provided by Spring Boot:"); - - final String[] beanNames = ctx.getBeanDefinitionNames(); - Arrays.sort(beanNames); - for (final String beanName : beanNames) { - LOG.info(beanName); - } - } - } -} -*/ diff --git a/utilities/build.gradle b/utilities/build.gradle index 24beb45..b9e2ce9 100644 --- a/utilities/build.gradle +++ b/utilities/build.gradle @@ -7,7 +7,11 @@ version '1.0' sourceCompatibility = 1.8 - +sonarqube { + properties { + property "sonar.projectName", 'Parsing and Proofs Utilities' + } +} repositories { mavenCentral() From bd7455c679c89f74ba9fd02443fb0f2a4d11d141 Mon Sep 17 00:00:00 2001 From: atusa Date: Fri, 15 Mar 2019 15:04:45 -0600 Subject: [PATCH 46/76] 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 47/76] 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 48/76] 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 49/76] 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 50/76] 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 51/76] 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 52/76] 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 53/76] 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 54/76] 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 55/76] 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 56/76] 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 57/76] 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 58/76] 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 59/76] 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); From 9f5d9e24f5641bf7f676e55432a51ddce5d88868 Mon Sep 17 00:00:00 2001 From: - <-> Date: Mon, 18 Mar 2019 13:52:01 -0600 Subject: [PATCH 60/76] made few changes also adding test method --- build.gradle | 4 ++++ .../msudenver/tsp/website/Application.java | 14 ++++++++++++++ .../msudenver/tsp/website/ProofsDriver.java | 5 ----- .../tsp/website/TheoremEntryController.java | 15 ++++++++------- .../msudenver/tsp/website/forms/Theorem.java | 19 +++++++++++++------ .../tsp/website/service/ProofDriver.java | 16 ---------------- src/main/webapp/WEB-INF/jsp/Theorem.jsp | 3 ++- src/main/webapp/WEB-INF/jsp/success.jsp | 3 ++- .../tsp/website/ProofsDriverTest.java | 5 ----- 9 files changed, 43 insertions(+), 41 deletions(-) delete mode 100644 src/main/java/edu/msudenver/tsp/website/ProofsDriver.java delete mode 100644 src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java delete mode 100644 src/test/java/edu/msudenver/tsp/website/ProofsDriverTest.java diff --git a/build.gradle b/build.gradle index 6690226..3231c9e 100644 --- a/build.gradle +++ b/build.gradle @@ -70,6 +70,8 @@ subprojects { testCompile group: 'junit', name: 'junit', version: '4.11' testCompile group: 'junit', name: 'junit', version: '4.12' testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} + testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.2.RELEASE' + testCompile 'javax.el:javax.el-api:3.0.0' } @@ -107,6 +109,8 @@ dependencies { compile 'org.slf4j:slf4j-api:1.7.22' compile "joda-time:joda-time:2.2" compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' + compile('org.springframework.boot:spring-boot-starter-web','org.apache.tomcat.embed:tomcat-embed-jasper' + ,'javax.servlet:jstl') testCompile group: 'junit', name: 'junit', version: '4.12' testCompile "org.springframework:spring-test:5.0.9.RELEASE" diff --git a/src/main/java/edu/msudenver/tsp/website/Application.java b/src/main/java/edu/msudenver/tsp/website/Application.java index 17154e8..b700c5a 100644 --- a/src/main/java/edu/msudenver/tsp/website/Application.java +++ b/src/main/java/edu/msudenver/tsp/website/Application.java @@ -1,16 +1,30 @@ package edu.msudenver.tsp.website; +import lombok.extern.java.Log; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.context.ApplicationContext; +import org.springframework.context.annotation.Bean; + +import java.util.Arrays; @SpringBootApplication +@Slf4j + public class Application { public static void main(final String[] args) { SpringApplication.run(Application.class, args); } + } + + + diff --git a/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java b/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java deleted file mode 100644 index a8a5de0..0000000 --- a/src/main/java/edu/msudenver/tsp/website/ProofsDriver.java +++ /dev/null @@ -1,5 +0,0 @@ -package edu.msudenver.tsp.website; - -public class ProofsDriver { - //Business Logic will go here -} diff --git a/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java b/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java index c62f84a..53db791 100644 --- a/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java +++ b/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java @@ -1,7 +1,8 @@ package edu.msudenver.tsp.website; import edu.msudenver.tsp.website.forms.Theorem; -import edu.msudenver.tsp.website.service.ProofDriver; +import lombok.AllArgsConstructor; +import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; @@ -10,12 +11,11 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; - +@Slf4j @Controller +@AllArgsConstructor public class TheoremEntryController { - @Autowired - ProofDriver proofDriver; @RequestMapping("/welcome") public ModelAndView firstPage() @@ -26,14 +26,15 @@ public class TheoremEntryController { @RequestMapping("/theorem") public ModelAndView theoremPage() { + //System.out.println("Inside controller"); return new ModelAndView("Theorem"); } - @RequestMapping(value = "/save", method = RequestMethod.POST) public String saveTheorem(@Validated Theorem theorem, Model model) { - proofDriver.processProof(theorem.getTheoremName()); - model.addAttribute("theromName", theorem.getTheoremName()); + + model.addAttribute("theromName1", theorem.getTheoremName1()); + model.addAttribute("theromName2", theorem.getTheoremName2()); return "success"; } diff --git a/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java b/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java index 07524df..935f762 100644 --- a/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java +++ b/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java @@ -1,17 +1,24 @@ package edu.msudenver.tsp.website.forms; public class Theorem { - private String theoremName ; + private String theoremName1 ; + private String theoremName2 ; - - public String getTheoremName() { - return theoremName; + public String getTheoremName1() { + return theoremName1; } - public void setTheoremName(String theoremName) { - this.theoremName = theoremName; + public void setTheoremName1(String theoremName) { + this.theoremName1 = theoremName; } + public String getTheoremName2() { + return theoremName2; + } + + public void setTheoremName2(String theoremName) { + this.theoremName2 = theoremName; + } diff --git a/src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java b/src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java deleted file mode 100644 index b95c206..0000000 --- a/src/main/java/edu/msudenver/tsp/website/service/ProofDriver.java +++ /dev/null @@ -1,16 +0,0 @@ -package edu.msudenver.tsp.website.service; - -import org.springframework.stereotype.Service; - -import java.util.ArrayList; -import java.util.List; - -@Service -public class ProofDriver { - List theromList = new ArrayList(); - public String processProof(String theoremName){ - //Business Logic - return theoremName + "Accepted"; - } - -} diff --git a/src/main/webapp/WEB-INF/jsp/Theorem.jsp b/src/main/webapp/WEB-INF/jsp/Theorem.jsp index d9f580b..183b974 100644 --- a/src/main/webapp/WEB-INF/jsp/Theorem.jsp +++ b/src/main/webapp/WEB-INF/jsp/Theorem.jsp @@ -8,7 +8,8 @@
-Enter Theroem Name
+Enter Theorem 1: +
Enter Theorem 2:
diff --git a/src/main/webapp/WEB-INF/jsp/success.jsp b/src/main/webapp/WEB-INF/jsp/success.jsp index 6919cde..0ed9148 100644 --- a/src/main/webapp/WEB-INF/jsp/success.jsp +++ b/src/main/webapp/WEB-INF/jsp/success.jsp @@ -1,6 +1,7 @@ -Name:<%= request.getParameter("theoremName")%> +
Name1:<%= request.getParameter("theoremName1")%> +
Name2:<%= request.getParameter("theoremName2")%> \ No newline at end of file diff --git a/src/test/java/edu/msudenver/tsp/website/ProofsDriverTest.java b/src/test/java/edu/msudenver/tsp/website/ProofsDriverTest.java deleted file mode 100644 index 04a68e1..0000000 --- a/src/test/java/edu/msudenver/tsp/website/ProofsDriverTest.java +++ /dev/null @@ -1,5 +0,0 @@ -package edu.msudenver.tsp.website; - -public class ProofsDriverTest { - -} \ No newline at end of file From f0cb7633c68dbec07ccb0d7a1e9a02b1353cf357 Mon Sep 17 00:00:00 2001 From: - <-> Date: Tue, 19 Mar 2019 00:11:38 -0600 Subject: [PATCH 61/76] updated with passed tests --- build.gradle | 2 - .../msudenver/tsp/website/Application.java | 30 ----------- .../tsp/website/controller/Application.java | 23 ++++++++ .../TheoremEntryController.java | 21 ++++---- .../tsp/website/controller/forms/Theorem.java | 25 +++++++++ .../msudenver/tsp/website/forms/Theorem.java | 26 --------- src/main/webapp/WEB-INF/jsp/Theorem.jsp | 4 +- src/main/webapp/WEB-INF/jsp/success.jsp | 3 +- src/main/webapp/WEB-INF/jsp/welcome.jsp | 3 +- .../TheoremEntryControllerTest.java | 53 +++++++++++++++++++ 10 files changed, 115 insertions(+), 75 deletions(-) delete mode 100644 src/main/java/edu/msudenver/tsp/website/Application.java create mode 100644 src/main/java/edu/msudenver/tsp/website/controller/Application.java rename src/main/java/edu/msudenver/tsp/website/{ => controller}/TheoremEntryController.java (66%) create mode 100644 src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java delete mode 100644 src/main/java/edu/msudenver/tsp/website/forms/Theorem.java create mode 100644 src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java diff --git a/build.gradle b/build.gradle index 3231c9e..b50c1d6 100644 --- a/build.gradle +++ b/build.gradle @@ -70,8 +70,6 @@ subprojects { testCompile group: 'junit', name: 'junit', version: '4.11' testCompile group: 'junit', name: 'junit', version: '4.12' testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} - testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.2.RELEASE' - testCompile 'javax.el:javax.el-api:3.0.0' } diff --git a/src/main/java/edu/msudenver/tsp/website/Application.java b/src/main/java/edu/msudenver/tsp/website/Application.java deleted file mode 100644 index b700c5a..0000000 --- a/src/main/java/edu/msudenver/tsp/website/Application.java +++ /dev/null @@ -1,30 +0,0 @@ -package edu.msudenver.tsp.website; - - -import lombok.extern.java.Log; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.CommandLineRunner; -import org.springframework.boot.SpringApplication; -import org.springframework.boot.autoconfigure.SpringBootApplication; -import org.springframework.context.ApplicationContext; -import org.springframework.context.annotation.Bean; - -import java.util.Arrays; - -@SpringBootApplication -@Slf4j - -public class Application { - - public static void main(final String[] args) { - SpringApplication.run(Application.class, args); - } - -} - - - - - - diff --git a/src/main/java/edu/msudenver/tsp/website/controller/Application.java b/src/main/java/edu/msudenver/tsp/website/controller/Application.java new file mode 100644 index 0000000..b165a26 --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/controller/Application.java @@ -0,0 +1,23 @@ +package edu.msudenver.tsp.website.controller; + + + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication + + +public class Application { + + public static void main(final String[] args) { + SpringApplication.run(Application.class, args); + } + +} + + + + + + diff --git a/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java b/src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java similarity index 66% rename from src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java rename to src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java index 53db791..57d2ef3 100644 --- a/src/main/java/edu/msudenver/tsp/website/TheoremEntryController.java +++ b/src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java @@ -1,9 +1,8 @@ -package edu.msudenver.tsp.website; +package edu.msudenver.tsp.website.controller; -import edu.msudenver.tsp.website.forms.Theorem; +import edu.msudenver.tsp.website.controller.forms.Theorem; import lombok.AllArgsConstructor; import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.validation.annotation.Validated; @@ -17,28 +16,28 @@ import org.springframework.web.servlet.ModelAndView; public class TheoremEntryController { - @RequestMapping("/welcome") - public ModelAndView firstPage() - { - return new ModelAndView("welcome"); - } @RequestMapping("/theorem") public ModelAndView theoremPage() { - //System.out.println("Inside controller"); + + return new ModelAndView("Theorem"); } + @RequestMapping(value = "/save", method = RequestMethod.POST) public String saveTheorem(@Validated Theorem theorem, Model model) { - model.addAttribute("theromName1", theorem.getTheoremName1()); - model.addAttribute("theromName2", theorem.getTheoremName2()); + model.addAttribute("theromName", theorem.getTheoremName()); + return "success"; } + public ModelAndView firstPage() { + return new ModelAndView("welcome"); + } } diff --git a/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java b/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java new file mode 100644 index 0000000..fc9660c --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java @@ -0,0 +1,25 @@ +package edu.msudenver.tsp.website.controller.forms; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter + +public class Theorem { + private String theoremName ; + + + public String getTheoremName() { + return theoremName; + } + + public void setTheoremName1(String theoremName) { + this.theoremName = theoremName; + } + + + + + +} diff --git a/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java b/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java deleted file mode 100644 index 935f762..0000000 --- a/src/main/java/edu/msudenver/tsp/website/forms/Theorem.java +++ /dev/null @@ -1,26 +0,0 @@ -package edu.msudenver.tsp.website.forms; - -public class Theorem { - private String theoremName1 ; - private String theoremName2 ; - - public String getTheoremName1() { - return theoremName1; - } - - public void setTheoremName1(String theoremName) { - this.theoremName1 = theoremName; - } - - public String getTheoremName2() { - return theoremName2; - } - - public void setTheoremName2(String theoremName) { - this.theoremName2 = theoremName; - } - - - - -} diff --git a/src/main/webapp/WEB-INF/jsp/Theorem.jsp b/src/main/webapp/WEB-INF/jsp/Theorem.jsp index 183b974..ae55b1d 100644 --- a/src/main/webapp/WEB-INF/jsp/Theorem.jsp +++ b/src/main/webapp/WEB-INF/jsp/Theorem.jsp @@ -8,8 +8,8 @@
-Enter Theorem 1: -
Enter Theorem 2:
+Enter Theorem Name: +
diff --git a/src/main/webapp/WEB-INF/jsp/success.jsp b/src/main/webapp/WEB-INF/jsp/success.jsp index 0ed9148..5802680 100644 --- a/src/main/webapp/WEB-INF/jsp/success.jsp +++ b/src/main/webapp/WEB-INF/jsp/success.jsp @@ -1,7 +1,6 @@ -
Name1:<%= request.getParameter("theoremName1")%> -
Name2:<%= request.getParameter("theoremName2")%> +
Name:<%= request.getParameter("theoremName")%> \ No newline at end of file diff --git a/src/main/webapp/WEB-INF/jsp/welcome.jsp b/src/main/webapp/WEB-INF/jsp/welcome.jsp index c3d088f..1342bc5 100644 --- a/src/main/webapp/WEB-INF/jsp/welcome.jsp +++ b/src/main/webapp/WEB-INF/jsp/welcome.jsp @@ -1,5 +1,4 @@ -<%@ page language="java" contentType="text/html; charset=ISO-8859-1" - pageEncoding="ISO-8859-1"%> + diff --git a/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java b/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java new file mode 100644 index 0000000..5864497 --- /dev/null +++ b/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java @@ -0,0 +1,53 @@ +package edu.msudenver.tsp.website.controller; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.runners.MockitoJUnitRunner; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.ui.Model; +import org.springframework.web.servlet.ModelAndView; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; + +import java.util.Map; + +import static org.junit.Assert.*; + +@RunWith(MockitoJUnitRunner.class) +public class TheoremEntryControllerTest { + + @InjectMocks + private TheoremEntryController theoremEntryController; + + @Autowired + protected MockMvc mockMvc; + + @Test + public void contexLoads() throws Exception { + assertNotNull(theoremEntryController); + } + + @Test + public void firstPage(){ + + final ModelAndView modelAndView= theoremEntryController.firstPage(); + + assertNotNull(modelAndView); + assertEquals("welcome",modelAndView.getViewName()); + } + + @Test + public void theoremPage(){ + + final ModelAndView modelAndView= theoremEntryController.theoremPage(); + + assertNotNull(modelAndView); + assertEquals("Theorem",modelAndView.getViewName()); + } + + +} From 5479130178071ca752bff18b680f0d11af73d642 Mon Sep 17 00:00:00 2001 From: - <-> Date: Tue, 19 Mar 2019 17:44:53 -0600 Subject: [PATCH 62/76] fixed again, thanks Alex for your detailed reviews I have learned alot :) --- build.gradle | 2 ++ .../website/{controller => }/Application.java | 8 ++---- .../controller/TheoremEntryController.java | 27 ++++++------------ .../tsp/website/controller/forms/Theorem.java | 21 ++++---------- src/main/webapp/WEB-INF/jsp/Theorem.jsp | 6 ++-- src/main/webapp/WEB-INF/jsp/success.jsp | 3 +- src/main/webapp/WEB-INF/jsp/welcome.jsp | 11 -------- .../TheoremEntryControllerTest.java | 28 +++++++------------ 8 files changed, 35 insertions(+), 71 deletions(-) rename src/main/java/edu/msudenver/tsp/website/{controller => }/Application.java (71%) delete mode 100644 src/main/webapp/WEB-INF/jsp/welcome.jsp diff --git a/build.gradle b/build.gradle index b50c1d6..3231c9e 100644 --- a/build.gradle +++ b/build.gradle @@ -70,6 +70,8 @@ subprojects { testCompile group: 'junit', name: 'junit', version: '4.11' testCompile group: 'junit', name: 'junit', version: '4.12' testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} + testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.2.RELEASE' + testCompile 'javax.el:javax.el-api:3.0.0' } diff --git a/src/main/java/edu/msudenver/tsp/website/controller/Application.java b/src/main/java/edu/msudenver/tsp/website/Application.java similarity index 71% rename from src/main/java/edu/msudenver/tsp/website/controller/Application.java rename to src/main/java/edu/msudenver/tsp/website/Application.java index b165a26..12556af 100644 --- a/src/main/java/edu/msudenver/tsp/website/controller/Application.java +++ b/src/main/java/edu/msudenver/tsp/website/Application.java @@ -1,16 +1,14 @@ -package edu.msudenver.tsp.website.controller; - - +package edu.msudenver.tsp.website; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication - public class Application { - public static void main(final String[] args) { + public static void main(final String[] args) + { SpringApplication.run(Application.class, args); } diff --git a/src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java b/src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java index 57d2ef3..4605fa3 100644 --- a/src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java +++ b/src/main/java/edu/msudenver/tsp/website/controller/TheoremEntryController.java @@ -6,6 +6,8 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; @@ -13,31 +15,20 @@ import org.springframework.web.servlet.ModelAndView; @Slf4j @Controller @AllArgsConstructor +@RequestMapping("/theorem") public class TheoremEntryController { - - - - @RequestMapping("/theorem") - public ModelAndView theoremPage() + @GetMapping({"/",""}) + public ModelAndView enterTheoremPage() { - - return new ModelAndView("Theorem"); } - - @RequestMapping(value = "/save", method = RequestMethod.POST) + @PostMapping({"/",""}) public String saveTheorem(@Validated Theorem theorem, Model model) { - model.addAttribute("theromName", theorem.getTheoremName()); + model.addAttribute("theromName1", theorem.getTheoremName1()); + model.addAttribute("theromName2", theorem.getTheoremName2()); return "success"; } - - - public ModelAndView firstPage() { - return new ModelAndView("welcome"); - } -} - - +} \ No newline at end of file diff --git a/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java b/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java index fc9660c..7b15b36 100644 --- a/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java +++ b/src/main/java/edu/msudenver/tsp/website/controller/forms/Theorem.java @@ -3,23 +3,14 @@ package edu.msudenver.tsp.website.controller.forms; import lombok.Getter; import lombok.Setter; +import javax.validation.constraints.NotBlank; + @Getter @Setter - public class Theorem { - private String theoremName ; - - - public String getTheoremName() { - return theoremName; - } - - public void setTheoremName1(String theoremName) { - this.theoremName = theoremName; - } - - - - + private String theoremName1 ; + private String theoremName2 ; + @NotBlank(message = "Theorem name must not be blank") private String theoremName; + private String theorem; } diff --git a/src/main/webapp/WEB-INF/jsp/Theorem.jsp b/src/main/webapp/WEB-INF/jsp/Theorem.jsp index ae55b1d..8933e48 100644 --- a/src/main/webapp/WEB-INF/jsp/Theorem.jsp +++ b/src/main/webapp/WEB-INF/jsp/Theorem.jsp @@ -7,9 +7,9 @@ Theroem Page -
-Enter Theorem Name: - + +Enter Theorem Name : +
Enter Theorem:
diff --git a/src/main/webapp/WEB-INF/jsp/success.jsp b/src/main/webapp/WEB-INF/jsp/success.jsp index 5802680..ea5294b 100644 --- a/src/main/webapp/WEB-INF/jsp/success.jsp +++ b/src/main/webapp/WEB-INF/jsp/success.jsp @@ -1,6 +1,7 @@ -
Name:<%= request.getParameter("theoremName")%> +
Name:<%= request.getParameter("theoremName1")%> +
Name:<%= request.getParameter("theoremName2")%> \ No newline at end of file diff --git a/src/main/webapp/WEB-INF/jsp/welcome.jsp b/src/main/webapp/WEB-INF/jsp/welcome.jsp deleted file mode 100644 index 1342bc5..0000000 --- a/src/main/webapp/WEB-INF/jsp/welcome.jsp +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - Guru Success Page - - -Welcome User!!!! - - \ No newline at end of file diff --git a/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java b/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java index 5864497..f71de78 100644 --- a/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java +++ b/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java @@ -23,27 +23,19 @@ public class TheoremEntryControllerTest { @InjectMocks private TheoremEntryController theoremEntryController; - @Autowired - protected MockMvc mockMvc; - - @Test - public void contexLoads() throws Exception { - assertNotNull(theoremEntryController); - } - - @Test - public void firstPage(){ - - final ModelAndView modelAndView= theoremEntryController.firstPage(); - - assertNotNull(modelAndView); - assertEquals("welcome",modelAndView.getViewName()); - } - @Test public void theoremPage(){ - final ModelAndView modelAndView= theoremEntryController.theoremPage(); + final ModelAndView modelAndView= theoremEntryController.enterTheoremPage(); + + assertNotNull(modelAndView); + assertEquals("Theorem",modelAndView.getViewName()); + } + + @Test + public void saveTheorem(){ + + final ModelAndView modelAndView= theoremEntryController.enterTheoremPage(); assertNotNull(modelAndView); assertEquals("Theorem",modelAndView.getViewName()); From 8c79d9975e7bd36c5e173575c9cda00ef507f50d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 20 Mar 2019 22:32:25 -0600 Subject: [PATCH 63/76] Merge branches 'PAN-16' and 'master' of https://github.com/atusa17/ptp into PAN-16 # Conflicts: # services/build.gradle --- .../tsp/website/controller/TheoremEntryControllerTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java b/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java index 2e7df0e..2624c17 100644 --- a/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java +++ b/src/test/java/edu/msudenver/tsp/website/controller/TheoremEntryControllerTest.java @@ -2,7 +2,6 @@ package edu.msudenver.tsp.website.controller; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; import org.springframework.web.servlet.ModelAndView; @@ -12,7 +11,7 @@ import static org.junit.Assert.assertNotNull; @RunWith(MockitoJUnitRunner.class) public class TheoremEntryControllerTest { - @Mock private TheoremEntryController theoremEntryController; + private final TheoremEntryController theoremEntryController = new TheoremEntryController(); @Test public void testEnterTheoremPage() { From 80f55c4879aa4eace47f297514a5a963dbae259c Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:25:52 -0600 Subject: [PATCH 64/76] PAN-52 Fixed issue with the Theorems API --- .../persistence/controller/TheoremController.java | 12 +++++++----- .../controller/TheoremControllerTest.java | 13 +++++++++++-- 2 files changed, 18 insertions(+), 7 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 ef0e760..1342f1a 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 @@ -75,19 +75,21 @@ public class TheoremController { @GetMapping("/proven_status") public @ResponseBody - ResponseEntity> getAllTheoremsByProvenStatus(@PathVariable("proven_status") final Boolean provenStatus) { + ResponseEntity> getAllTheoremsByProvenStatus(@RequestParam("proven_status") final String 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); + final Boolean isProven = Boolean.parseBoolean(provenStatus); + + LOG.debug("Querying for theorems with proven status {}", isProven); final StopWatch stopWatch = new StopWatch(); stopWatch.start(); - final List listOfTheorems = theoremRepository.findByProvenStatus(provenStatus); + final List listOfTheorems = theoremRepository.findByProvenStatus(isProven); stopWatch.stop(); @@ -95,11 +97,11 @@ public class TheoremController { LOG.info("Returning list of all theorems with size {}", listOfTheorems.size()); if (listOfTheorems.isEmpty()) { - LOG.warn("No theorems were found for proven status {}", provenStatus); + LOG.warn("No theorems were found for proven status {}", isProven); return new ResponseEntity<>(HttpStatus.NOT_FOUND); } - LOG.info("Returning list of theorems with proven status {}", provenStatus); + LOG.info("Returning list of theorems with proven status {}", isProven); 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 ffc0913..f9944e4 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 @@ -135,7 +135,7 @@ public class TheoremControllerTest { 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()); @@ -155,11 +155,20 @@ public class TheoremControllerTest { verifyZeroInteractions(theoremRepository); } + @Test + public void testGetAllTheoremsByProvenStatus_invalidProvenStatus() { + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByProvenStatus("test"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + @Test 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()); From 413a78f729d77189c7bfc827d19fd1de407aec11 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:28:09 -0600 Subject: [PATCH 65/76] PAN-52 Fixed issue with the Theorems API --- .../tsp/persistence/controller/TheoremController.java | 4 ++-- 1 file changed, 2 insertions(+), 2 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 1342f1a..7037d90 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 @@ -107,7 +107,7 @@ public class TheoremController { @GetMapping("/name") public @ResponseBody - ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { + ResponseEntity> getAllTheoremsByName(@RequestParam("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"); @@ -137,7 +137,7 @@ public class TheoremController { @GetMapping("/id") public @ResponseBody - ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { + ResponseEntity getTheoremById(@RequestParam("id") final Integer id) { LOG.info("Received request to query for theorem with id {}", id); if (id == null) { LOG.error("ERROR: ID was null"); From 6b7cf5cd918946b1596ac41af61294c0a8990475 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:28:51 -0600 Subject: [PATCH 66/76] PAN-52 Fixed issue with the Theorems API --- .../msudenver/tsp/persistence/controller/ProofController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 e60659a..e218bbf 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 @@ -105,7 +105,7 @@ public class ProofController { @GetMapping("/theorem_name") public @ResponseBody - ResponseEntity> getAllProofsByTheoremName(@PathVariable("theorem_name") final String theoremName) { + ResponseEntity> getAllProofsByTheoremName(@RequestParam("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"); From 1e15082fcc18721dcab2b9a8b84efb43a3e7fcea Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:32:57 -0600 Subject: [PATCH 67/76] PAN-52 Fixed issue with the Theorems API --- .../tsp/persistence/controller/TheoremController.java | 11 ++++++++++- 1 file changed, 10 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 7037d90..71d5e62 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 @@ -107,13 +107,20 @@ public class TheoremController { @GetMapping("/name") public @ResponseBody - ResponseEntity> getAllTheoremsByName(@RequestParam("name") final String name) { + ResponseEntity> getAllTheoremsByName(@RequestParam("name") 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); } + name = name.toLowerCase(); + + if (name.contains("_") || name.contains("-")) { + name = name.replace("-", "\\s"); + name = name.replace("-", "\\s"); + } + LOG.debug("Querying for theorems with name {}", name); final StopWatch stopWatch = new StopWatch(); @@ -181,6 +188,8 @@ public class TheoremController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } + theorem.setName(theorem.getName().toLowerCase()); + LOG.debug("Saving new theorem"); final StopWatch stopWatch = new StopWatch(); From ba4c7502db8087387bbe80e4d0f1045ef5ca12eb Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:39:24 -0600 Subject: [PATCH 68/76] PAN-52 Fixed issue with the Theorems API --- persistence/scripts/mysql/local_development.sql | 1 + .../src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java | 1 + .../tsp/persistence/controller/TheoremControllerTest.java | 1 + 3 files changed, 3 insertions(+) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 52480e5..44f9fa6 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -26,6 +26,7 @@ version int default 1 create table theorems ( id int not null auto_increment primary key unique, name varchar(512) not null, +theorem varchar(1024) not null, theorem_type enum ('THEOREM', 'PROPOSITION', 'LEMMA', 'COROLLARY') not null, branch varchar(512) not null, referenced_definitions json, diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java index 14e1da1..5f0f2bf 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Theorem.java @@ -21,6 +21,7 @@ import java.util.List; @EqualsAndHashCode(callSuper = true) 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) @Size(min = 1, max = 1024, message = "theorem must be between 1 and 1024 characters") private String theorem; @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; 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 f9944e4..6be6200 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 @@ -352,6 +352,7 @@ public class TheoremControllerTest { final Theorem theorem = new Theorem(); theorem.setName("Test theorem"); + theorem.setTheorem("test theorem thing here"); theorem.setBranch("Test branch"); theorem.setProvenStatus(true); theorem.setTheoremType(TheoremType.THEOREM); From f8a1d8bf8918c6a15983758d118dd13a2b2d0073 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:55:15 -0600 Subject: [PATCH 69/76] PAN-52 Fixed issue with the Theorems API --- persistence/scripts/mysql/local_development.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 44f9fa6..0bb4f8f 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -27,7 +27,7 @@ create table theorems ( id int not null auto_increment primary key unique, name varchar(512) not null, theorem varchar(1024) not null, -theorem_type enum ('THEOREM', 'PROPOSITION', 'LEMMA', 'COROLLARY') not null, +theorem_type varchar(20) not null, branch varchar(512) not null, referenced_definitions json, referenced_theorems json, From 4622c49ceec8e7252c67425e8cbabc3a34909aef Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 10:59:14 -0600 Subject: [PATCH 70/76] PAN-52 Fixed issue with the Theorems API --- .../tsp/persistence/controller/TheoremController.java | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 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 71d5e62..d6bae87 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 @@ -45,13 +45,20 @@ public class TheoremController { @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllTheoremsByBranch(@RequestParam("branch") final String branch) { + ResponseEntity> getAllTheoremsByBranch(@RequestParam("branch") String branch) { LOG.info("Received request to query for theorems related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } + branch = branch.toLowerCase(); + + if (branch.contains("_") || branch.contains("-")) { + branch = branch.replace("_", "\\s"); + branch = branch.replace("-", "\\s"); + } + LOG.debug("Querying for theorems with branch {}", branch); final StopWatch stopWatch = new StopWatch(); @@ -188,8 +195,6 @@ public class TheoremController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - theorem.setName(theorem.getName().toLowerCase()); - LOG.debug("Saving new theorem"); final StopWatch stopWatch = new StopWatch(); From ab360abcf8277908cb8d2894e7254a465789843a Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 11:02:46 -0600 Subject: [PATCH 71/76] PAN-52 Fixed issue with the Theorems API --- .../msudenver/tsp/persistence/controller/TheoremController.java | 2 -- 1 file changed, 2 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 d6bae87..1214812 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 @@ -52,8 +52,6 @@ public class TheoremController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - branch = branch.toLowerCase(); - if (branch.contains("_") || branch.contains("-")) { branch = branch.replace("_", "\\s"); branch = branch.replace("-", "\\s"); From 07cdef3d446e4cac6350ec39ac2e3daa4f5ccb7b Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 11:05:32 -0600 Subject: [PATCH 72/76] PAN-52 Fixed issue with the Theorems API --- .../tsp/persistence/controller/TheoremController.java | 8 ++++---- .../tsp/persistence/controller/TheoremControllerTest.java | 4 ++-- 2 files changed, 6 insertions(+), 6 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 1214812..b6bb7b9 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 @@ -53,8 +53,8 @@ public class TheoremController { } if (branch.contains("_") || branch.contains("-")) { - branch = branch.replace("_", "\\s"); - branch = branch.replace("-", "\\s"); + branch = branch.replace("_", " "); + branch = branch.replace("-", " "); } LOG.debug("Querying for theorems with branch {}", branch); @@ -122,8 +122,8 @@ public class TheoremController { name = name.toLowerCase(); if (name.contains("_") || name.contains("-")) { - name = name.replace("-", "\\s"); - name = name.replace("-", "\\s"); + name = name.replace("-", " "); + name = name.replace("-", " "); } LOG.debug("Querying for theorems with name {}", 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 6be6200..c65ed44 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 @@ -95,7 +95,7 @@ public class TheoremControllerTest { when(theoremRepository.findByBranch(anyString())).thenReturn(listOfTheorems); - final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test"); + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByBranch("test-branch"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -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()); From d0cde837e9689faadc34106a4fbeac38a9386dea Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 11:09:01 -0600 Subject: [PATCH 73/76] PAN-52 Fixed issue with the Theorems API --- .../tsp/persistence/controller/TheoremController.java | 4 +--- .../tsp/persistence/controller/TheoremControllerTest.java | 4 ++-- 2 files changed, 3 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 b6bb7b9..457ac10 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 @@ -119,10 +119,8 @@ public class TheoremController { return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } - name = name.toLowerCase(); - if (name.contains("_") || name.contains("-")) { - name = name.replace("-", " "); + name = name.replace("_", " "); name = name.replace("-", " "); } 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 c65ed44..a667d0a 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 @@ -184,7 +184,7 @@ public class TheoremControllerTest { 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()); @@ -208,7 +208,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()); From c9a2a978fcbdec54d86896eb471a28d70d230845 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 11:20:52 -0600 Subject: [PATCH 74/76] PAN-52 Fixed issue with the Theorems API --- persistence/scripts/mysql/local_development.sql | 1 + .../tsp/persistence/ProofsIntegrationTest.java | 3 +++ .../tsp/persistence/TheoremsIntegrationTest.java | 3 +++ .../persistence/controller/ProofController.java | 14 ++++++++++++-- .../edu/msudenver/tsp/persistence/dto/Proof.java | 4 ++++ .../controller/ProofControllerTest.java | 11 ++++++----- 6 files changed, 29 insertions(+), 7 deletions(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 0bb4f8f..15934b0 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -38,6 +38,7 @@ CREATE TABLE proofs ( id INT NOT NULL AUTO_INCREMENT, theorem_name VARCHAR(512) NOT NULL, + proof VARCHAR(4096) 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/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java index 4af0f76..2061320 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -33,6 +33,7 @@ public class ProofsIntegrationTest { assertEquals("Test proof", savedProof.getTheoremName()); assertEquals("Test branch", savedProof.getBranch()); + assertEquals("test", savedProof.getProof()); assertNotNull(savedProof.getDateCreated()); assertNotNull(savedProof.getLastUpdated()); assertEquals(2, savedProof.getReferencedTheorems().size()); @@ -50,6 +51,7 @@ public class ProofsIntegrationTest { assertEquals(Integer.valueOf(0), updatedProof.getVersion()); assertEquals("Test proof", updatedProof.getTheoremName()); assertEquals("Test Update", updatedProof.getBranch()); + assertEquals("test", updatedProof.getProof()); assertNotNull(updatedProof.getLastUpdated()); assertNotNull(updatedProof.getDateCreated()); assertNotEquals(updatedProof.getDateCreated().toInstant(), updatedProof.getLastUpdated().toInstant()); @@ -77,6 +79,7 @@ public class ProofsIntegrationTest { final Proof proof = new Proof(); proof.setTheoremName("Test proof"); + proof.setProof("test"); proof.setBranch("Test branch"); proof.setDateCreated(new Date()); proof.setReferencedTheorems(referencedTheoremsList); 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 d5c22c3..7090456 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/TheoremsIntegrationTest.java @@ -32,6 +32,7 @@ public class TheoremsIntegrationTest { assertEquals("Test theorem", savedTheorem.getName()); assertEquals("Test branch", savedTheorem.getBranch()); + assertEquals("test", savedTheorem.getTheorem()); assertTrue(savedTheorem.getProvenStatus()); assertEquals(2, savedTheorem.getReferencedTheorems().size()); assertEquals(2, savedTheorem.getReferencedDefinitions().size()); @@ -48,6 +49,7 @@ public class TheoremsIntegrationTest { assertEquals(Integer.valueOf(0), updatedTheorem.getVersion()); assertEquals("Test theorem", updatedTheorem.getName()); assertEquals("Test Update", updatedTheorem.getBranch()); + assertEquals("test", updatedTheorem.getTheorem()); assertTrue(updatedTheorem.getProvenStatus()); assertEquals(2, updatedTheorem.getReferencedTheorems().size()); assertEquals(2, updatedTheorem.getReferencedDefinitions().size()); @@ -73,6 +75,7 @@ public class TheoremsIntegrationTest { final Theorem theorem = new Theorem(); theorem.setName("Test theorem"); + theorem.setTheorem("test"); theorem.setBranch("Test branch"); theorem.setProvenStatus(true); theorem.setTheoremType(TheoremType.THEOREM); 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 e218bbf..d682c32 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 @@ -75,13 +75,18 @@ public class ProofController { @GetMapping("/branch") public @ResponseBody - ResponseEntity> getAllProofsByBranch(@RequestParam("branch") final String branch) { + ResponseEntity> getAllProofsByBranch(@RequestParam("branch") String branch) { LOG.info("Received request to query for proofs related to the {} branch of mathematics", branch); if (branch == null) { LOG.error("ERROR: branch was null"); return new ResponseEntity<>(HttpStatus.BAD_REQUEST); } + if (branch.contains("_") || branch.contains("-")) { + branch = branch.replace("_"," "); + branch = branch.replace("-", " "); + } + LOG.debug("Querying for proofs with branch {}", branch); final StopWatch stopWatch = new StopWatch(); @@ -105,13 +110,18 @@ public class ProofController { @GetMapping("/theorem_name") public @ResponseBody - ResponseEntity> getAllProofsByTheoremName(@RequestParam("theorem_name") final String theoremName) { + ResponseEntity> getAllProofsByTheoremName(@RequestParam("theorem_name") 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); } + if (theoremName.contains("_") || theoremName.contains("-")) { + theoremName = theoremName.replace("_"," "); + theoremName = theoremName.replace("-", " "); + } + LOG.debug("Querying for proofs of the theorem {}", theoremName); final StopWatch stopWatch = new StopWatch(); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java index 683039b..bd927d8 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java @@ -8,6 +8,7 @@ import org.springframework.data.jpa.domain.support.AuditingEntityListener; import javax.persistence.*; import javax.validation.constraints.NotBlank; +import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; import java.io.Serializable; import java.util.Date; @@ -22,6 +23,9 @@ public class Proof extends BaseDto implements Serializable { @Size(min = 1, max = 512, message = "The name must be at least 1 character and at most 512 characters") @Column(name = "theorem_name") private String theoremName; + @NotNull(groups = Insert.class) + @Size(min = 1, max = 4096, message = "The proof must be at least 1 character and at most 4096 characters") + private String proof; @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; 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 6e77bb3..6ad1948 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 @@ -53,7 +53,7 @@ public class ProofControllerTest { when(proofRepository.findByBranch(anyString())).thenReturn(listOfProofs); - final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("test"); + final ResponseEntity> responseEntity = proofController.getAllProofsByBranch("Test_branch"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -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()); @@ -93,7 +93,7 @@ public class ProofControllerTest { when(proofRepository.findByTheoremName(anyString())).thenReturn(listOfProofs); - final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("test"); + final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName("Test_proof"); assertNotNull(responseEntity); assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); @@ -104,7 +104,7 @@ public class ProofControllerTest { } @Test - public void testGetAllProfsByTheoremName_nullTheoremName() { + public void testGetAllProofsByTheoremName_nullTheoremName() { final ResponseEntity> responseEntity = proofController.getAllProofsByTheoremName(null); assertNotNull(responseEntity); @@ -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-proof"); assertNotNull(responseEntity); assertFalse(responseEntity.hasBody()); @@ -299,6 +299,7 @@ public class ProofControllerTest { final Proof proof = new Proof(); proof.setTheoremName("Test proof"); proof.setBranch("Test branch"); + proof.setProof("test proof"); proof.setDateCreated(new Date()); proof.setReferencedTheorems(referencedTheoremsList); proof.setReferencedDefinitions(referencedDefinitionsList); From f5dbdac990e405d626151005734059eaf33f5e6e Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 11:29:30 -0600 Subject: [PATCH 75/76] PAN-52 Fixed issue with the Theorems API --- persistence/scripts/mysql/local_development.sql | 1 - .../edu/msudenver/tsp/persistence/ProofsIntegrationTest.java | 3 +++ .../src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java | 2 ++ .../tsp/persistence/controller/ProofControllerTest.java | 1 + 4 files changed, 6 insertions(+), 1 deletion(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 15934b0..27005d4 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -41,7 +41,6 @@ CREATE TABLE proofs proof VARCHAR(4096) 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, 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 2061320..b18c47d 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -34,6 +34,7 @@ public class ProofsIntegrationTest { assertEquals("Test proof", savedProof.getTheoremName()); assertEquals("Test branch", savedProof.getBranch()); assertEquals("test", savedProof.getProof()); + assertEquals(Integer.valueOf(1), savedProof.getTheorem()); assertNotNull(savedProof.getDateCreated()); assertNotNull(savedProof.getLastUpdated()); assertEquals(2, savedProof.getReferencedTheorems().size()); @@ -52,6 +53,7 @@ public class ProofsIntegrationTest { assertEquals("Test proof", updatedProof.getTheoremName()); assertEquals("Test Update", updatedProof.getBranch()); assertEquals("test", updatedProof.getProof()); + assertEquals(Integer.valueOf(1), savedProof.getTheorem()); assertNotNull(updatedProof.getLastUpdated()); assertNotNull(updatedProof.getDateCreated()); assertNotEquals(updatedProof.getDateCreated().toInstant(), updatedProof.getLastUpdated().toInstant()); @@ -80,6 +82,7 @@ public class ProofsIntegrationTest { final Proof proof = new Proof(); proof.setTheoremName("Test proof"); proof.setProof("test"); + proof.setTheorem(1); proof.setBranch("Test branch"); proof.setDateCreated(new Date()); proof.setReferencedTheorems(referencedTheoremsList); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java index bd927d8..fba2b1a 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Proof.java @@ -26,6 +26,8 @@ public class Proof extends BaseDto implements Serializable { @NotNull(groups = Insert.class) @Size(min = 1, max = 4096, message = "The proof must be at least 1 character and at most 4096 characters") private String proof; + @NotNull(groups = Insert.class) + private Integer theorem; @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; 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 6ad1948..14c2482 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 @@ -298,6 +298,7 @@ public class ProofControllerTest { final Proof proof = new Proof(); proof.setTheoremName("Test proof"); + proof.setTheorem(1); proof.setBranch("Test branch"); proof.setProof("test proof"); proof.setDateCreated(new Date()); From 296cf62be6579e3eb67ce3c67e343442533770a8 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 21 Mar 2019 11:40:19 -0600 Subject: [PATCH 76/76] PAN-52 Fixed issue with the Theorems API --- out/production/resources/application.properties | 3 ++- src/main/resources/application.properties | 3 +-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/out/production/resources/application.properties b/out/production/resources/application.properties index f3ce324..a8a0755 100644 --- a/out/production/resources/application.properties +++ b/out/production/resources/application.properties @@ -1,2 +1,3 @@ spring.mvc.view.prefix:/WEB-INF/jsp/ -spring.mvc.view.suffix:.jsp \ No newline at end of file +spring.mvc.view.suffix:.jsp +server.port=8090 \ No newline at end of file diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index a8a0755..f3ce324 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -1,3 +1,2 @@ spring.mvc.view.prefix:/WEB-INF/jsp/ -spring.mvc.view.suffix:.jsp -server.port=8090 \ No newline at end of file +spring.mvc.view.suffix:.jsp \ No newline at end of file