From 86c5e8123e4f418f08aca2f9b7e94ecf264f1d94 Mon Sep 17 00:00:00 2001 From: zeliu Date: Thu, 7 Mar 2019 10:22:08 -0700 Subject: [PATCH 01/53] Here is the JSP file for hoempage --- ...damonium-theorem-prover.main.kotlin_module | Bin 16 -> 0 bytes src/main/webapp/index.jsp | 20 ++++++++++++------ 2 files changed, 13 insertions(+), 7 deletions(-) delete mode 100644 out/production/classes/META-INF/edu.msudenver.tsp.pandamonium-theorem-prover.main.kotlin_module 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/src/main/webapp/index.jsp b/src/main/webapp/index.jsp index f8d618c..0efda13 100644 --- a/src/main/webapp/index.jsp +++ b/src/main/webapp/index.jsp @@ -5,12 +5,18 @@ Time: 8:03 PM To change this template use File | Settings | File Templates. --%> -<%@ page contentType="text/html;charset=UTF-8" language="java" %> +<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%> - - $Title$ - - - $END$ - + + Test page + + + +

Test stuffs

+test hyperlink +
+ +
+ + From ba37ffeb5793efd6be3f2aa0a869e5e27c5e5cb2 Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 10 Mar 2019 15:55:43 -0600 Subject: [PATCH 02/53] PAN-15 Created initial UserService implementation and initial integration tests --- .../tsp/services/ServicesTestConfig.java | 17 ++++++++ .../services/UserServiceIntegrationTest.java | 43 +++++++++++++++++++ .../integrationTest/resources/test.properties | 3 ++ .../msudenver/tsp/services/ServiceConfig.java | 14 ++++++ .../msudenver/tsp/services/UserService.java | 4 +- .../msudenver/tsp/services/dto/Account.java | 8 ++-- .../tsp/services/parser/ParserService.java | 18 -------- .../src/main/resources/application.properties | 6 +-- 8 files changed, 86 insertions(+), 27 deletions(-) create mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java create mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java create mode 100644 services/src/integrationTest/resources/test.properties create mode 100644 services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java new file mode 100644 index 0000000..4c9e2b4 --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java @@ -0,0 +1,17 @@ +package edu.msudenver.tsp.services; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; + +@Configuration +@ComponentScan +public class ServicesTestConfig { + + @Bean + @Autowired + public UserService userService(final RestService restService) { + return new UserService(restService); + } +} diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java new file mode 100644 index 0000000..e434d64 --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -0,0 +1,43 @@ +package edu.msudenver.tsp.services; + +import edu.msudenver.tsp.services.dto.Account; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.text.ParseException; +import java.util.Date; +import java.util.Optional; + +import static org.junit.Assert.assertTrue; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = ServicesTestConfig.class) +@TestPropertySource("classpath:test.properties") +public class UserServiceIntegrationTest { + @Autowired + @Qualifier("userService") + private UserService userService; + + @Test + public void testCreateNewUser() throws ParseException { + final Account testAccount = new Account(); + testAccount.setUsername("test user"); + testAccount.setPassword("test password"); + testAccount.setAdministratorStatus(false); + testAccount.setLastLogin(new Date()); + + final Optional testCreatedAccount = userService.createNewAccount(testAccount); + + assertTrue(testCreatedAccount.isPresent()); + final Account returnedAccount = testCreatedAccount.get(); + Assert.assertEquals("test user", returnedAccount.getUsername()); + Assert.assertEquals("test password", returnedAccount.getPassword()); + Assert.assertEquals(false, returnedAccount.isAdministratorStatus()); + } +} diff --git a/services/src/integrationTest/resources/test.properties b/services/src/integrationTest/resources/test.properties new file mode 100644 index 0000000..3690a57 --- /dev/null +++ b/services/src/integrationTest/resources/test.properties @@ -0,0 +1,3 @@ +persistence.api.connection.timeout.milliseconds=5000 +persistence.api.socket.timeout.milliseconds=10000 +persistence.api.base.url=http://localhost:8090/ diff --git a/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java new file mode 100644 index 0000000..db65cc6 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java @@ -0,0 +1,14 @@ +package edu.msudenver.tsp.services; + +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration; +import org.springframework.boot.devtools.autoconfigure.DevToolsDataSourceAutoConfiguration; +import org.springframework.context.annotation.Configuration; + +@Configuration +@EnableAutoConfiguration(exclude = {DevToolsDataSourceAutoConfiguration.class, + HibernateJpaAutoConfiguration.class, + DataSourceAutoConfiguration.class}) +public class ServiceConfig { +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index f119441..0862ae5 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -34,8 +34,8 @@ public class UserService { try { final TypeToken typeToken = new TypeToken() {}; - final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/accounts/", - new GsonBuilder().create().toJson(account), + final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "accounts/", + new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds); 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..b7135ec 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,19 +1,19 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; -import edu.msudenver.tsp.persistence.dto.AccountDto; +import lombok.Data; 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; +@Data 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; + @Size(max = 50) private String username; + @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..5bebbc1 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,10 +1,5 @@ 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 org.springframework.stereotype.Service; import java.util.ArrayList; @@ -12,21 +7,8 @@ import java.util.List; @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 { diff --git a/services/src/main/resources/application.properties b/services/src/main/resources/application.properties index ff86c7e..710f97b 100644 --- a/services/src/main/resources/application.properties +++ b/services/src/main/resources/application.properties @@ -1,3 +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 +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 10b0a09690020b5bdd47ebb998a50c3a50166e3f Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 10 Mar 2019 16:18:19 -0600 Subject: [PATCH 03/53] PAN-15 Updated the gradle dependencies --- services/build.gradle | 7 +++++- .../msudenver/tsp/services/dto/Account.java | 2 ++ .../services/parser/ParserServiceTest.java | 23 +++++++------------ 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/services/build.gradle b/services/build.gradle index 05efbeb..00a0119 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -18,11 +18,16 @@ repositories { } dependencies { - compile project(':persistence') 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: 'javax.persistence', name: 'javax.persistence-api', version: '2.2' + compile group: 'javax.validation', name: 'validation-api', version: '2.0.1.Final' + compile group: 'org.springframework.boot', name: 'spring-boot-autoconfigure', version: '2.1.3.RELEASE' + compile group: 'org.springframework.boot', name: 'spring-boot-devtools', version: '2.1.3.RELEASE' + compile group: 'org.springframework', name: 'spring-web', version: '5.1.5.RELEASE' 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' + testCompile group: 'org.springframework', name: 'spring-test', version: '5.1.5.RELEASE' } 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 b7135ec..1190dd8 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 @@ -2,6 +2,7 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; import lombok.Data; +import lombok.EqualsAndHashCode; import javax.persistence.Temporal; import javax.persistence.TemporalType; @@ -11,6 +12,7 @@ import java.io.Serializable; import java.util.Date; @Data +@EqualsAndHashCode(callSuper = true) public class Account extends BaseDto implements Serializable { @Size(max = 50) private String username; @Size(max = 256) private String password; 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..1b23d95 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,8 @@ 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.Spy; import org.mockito.runners.MockitoJUnitRunner; import java.util.ArrayList; @@ -12,18 +11,12 @@ 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); - - @InjectMocks - private final ParserService parserService = new ParserService(definitionControllerMock, null, - null, null); + @Spy private ParserService parserService; @Test public void testEmptyStringEqualsEmptyString() { @@ -106,8 +99,8 @@ public class ParserServiceTest { final List expectedList = new ArrayList<>(); expectedList.add(""); - when(mockParserService.parseRawInput(anyString())).thenReturn(new Node("", null)); - final List actualList = parserService.retrieveStatements(mockParserService.parseRawInput("")); + when(parserService.parseRawInput(anyString())).thenReturn(new Node("", null)); + final List actualList = parserService.retrieveStatements(parserService.parseRawInput("")); assertEquals(expectedList, actualList); } @@ -124,8 +117,8 @@ public class ParserServiceTest { testNode.setRight(new Node("then", testNode)); testNode.getRight().setCenter(new Node(" x^2 is even", testNode.getRight())); - when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); - final List actualList = parserService.retrieveStatements(mockParserService.parseRawInput("baseCase")); + when(parserService.parseRawInput(anyString())).thenReturn(testNode); + final List actualList = parserService.retrieveStatements(parserService.parseRawInput("baseCase")); assertEquals(expectedList, actualList); } @@ -133,8 +126,8 @@ public class ParserServiceTest { @Test public void testDriveParseUserInput() { final Node testNode = new Node("", null); - when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); - when(mockParserService.retrieveStatements(testNode)).thenReturn(new ArrayList<>()); + when(parserService.parseRawInput(anyString())).thenReturn(testNode); + when(parserService.retrieveStatements(testNode)).thenReturn(new ArrayList<>()); final boolean successfulTestDrive = parserService.parseUserInput(""); From 238908f4facf34e91949a9a61283e90dfe1f1a98 Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 10 Mar 2019 17:03:50 -0600 Subject: [PATCH 04/53] PAN-15 Updated tests --- .../services/UserServiceIntegrationTest.java | 9 ++++---- .../msudenver/tsp/services/dto/Account.java | 2 ++ .../services/parser/ParserServiceTest.java | 23 +++++++------------ 3 files changed, 14 insertions(+), 20 deletions(-) diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java index e434d64..c3a71d0 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -1,7 +1,6 @@ package edu.msudenver.tsp.services; import edu.msudenver.tsp.services.dto.Account; -import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; @@ -14,7 +13,7 @@ import java.text.ParseException; import java.util.Date; import java.util.Optional; -import static org.junit.Assert.assertTrue; +import static org.junit.Assert.*; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = ServicesTestConfig.class) @@ -36,8 +35,8 @@ public class UserServiceIntegrationTest { assertTrue(testCreatedAccount.isPresent()); final Account returnedAccount = testCreatedAccount.get(); - Assert.assertEquals("test user", returnedAccount.getUsername()); - Assert.assertEquals("test password", returnedAccount.getPassword()); - Assert.assertEquals(false, returnedAccount.isAdministratorStatus()); + assertEquals("test user", returnedAccount.getUsername()); + assertEquals("test password", returnedAccount.getPassword()); + assertFalse(returnedAccount.isAdministratorStatus()); } } 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 b7135ec..1190dd8 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 @@ -2,6 +2,7 @@ package edu.msudenver.tsp.services.dto; import com.google.gson.annotations.SerializedName; import lombok.Data; +import lombok.EqualsAndHashCode; import javax.persistence.Temporal; import javax.persistence.TemporalType; @@ -11,6 +12,7 @@ import java.io.Serializable; import java.util.Date; @Data +@EqualsAndHashCode(callSuper = true) public class Account extends BaseDto implements Serializable { @Size(max = 50) private String username; @Size(max = 256) private String password; 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..1b23d95 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,8 @@ 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.Spy; import org.mockito.runners.MockitoJUnitRunner; import java.util.ArrayList; @@ -12,18 +11,12 @@ 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); - - @InjectMocks - private final ParserService parserService = new ParserService(definitionControllerMock, null, - null, null); + @Spy private ParserService parserService; @Test public void testEmptyStringEqualsEmptyString() { @@ -106,8 +99,8 @@ public class ParserServiceTest { final List expectedList = new ArrayList<>(); expectedList.add(""); - when(mockParserService.parseRawInput(anyString())).thenReturn(new Node("", null)); - final List actualList = parserService.retrieveStatements(mockParserService.parseRawInput("")); + when(parserService.parseRawInput(anyString())).thenReturn(new Node("", null)); + final List actualList = parserService.retrieveStatements(parserService.parseRawInput("")); assertEquals(expectedList, actualList); } @@ -124,8 +117,8 @@ public class ParserServiceTest { testNode.setRight(new Node("then", testNode)); testNode.getRight().setCenter(new Node(" x^2 is even", testNode.getRight())); - when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); - final List actualList = parserService.retrieveStatements(mockParserService.parseRawInput("baseCase")); + when(parserService.parseRawInput(anyString())).thenReturn(testNode); + final List actualList = parserService.retrieveStatements(parserService.parseRawInput("baseCase")); assertEquals(expectedList, actualList); } @@ -133,8 +126,8 @@ public class ParserServiceTest { @Test public void testDriveParseUserInput() { final Node testNode = new Node("", null); - when(mockParserService.parseRawInput(anyString())).thenReturn(testNode); - when(mockParserService.retrieveStatements(testNode)).thenReturn(new ArrayList<>()); + when(parserService.parseRawInput(anyString())).thenReturn(testNode); + when(parserService.retrieveStatements(testNode)).thenReturn(new ArrayList<>()); final boolean successfulTestDrive = parserService.parseUserInput(""); From 5d429b2c8ea9f4bde67c1f7ee33db09dc5799a14 Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 10 Mar 2019 17:06:47 -0600 Subject: [PATCH 05/53] PAN-15 Updated tests --- services/build.gradle | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/services/build.gradle b/services/build.gradle index 00a0119..05efbeb 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -18,16 +18,11 @@ repositories { } dependencies { + compile project(':persistence') 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: 'javax.persistence', name: 'javax.persistence-api', version: '2.2' - compile group: 'javax.validation', name: 'validation-api', version: '2.0.1.Final' - compile group: 'org.springframework.boot', name: 'spring-boot-autoconfigure', version: '2.1.3.RELEASE' - compile group: 'org.springframework.boot', name: 'spring-boot-devtools', version: '2.1.3.RELEASE' - compile group: 'org.springframework', name: 'spring-web', version: '5.1.5.RELEASE' 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' - testCompile group: 'org.springframework', name: 'spring-test', version: '5.1.5.RELEASE' } From ffaf020b8005651688ca877ad35a7a6fb3b5dc1a Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 10 Mar 2019 17:21:32 -0600 Subject: [PATCH 06/53] PAN-15 WORKING AND WITH TRAVIS!!! --- services/build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/services/build.gradle b/services/build.gradle index 05efbeb..fd28275 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -25,4 +25,5 @@ dependencies { compile fileTree(dir: 'lib', include: '**/*.jar') testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile group: 'org.springframework', name: 'spring-test', version: '5.1.5.RELEASE' } From 46122cbafd1c7211635b07723d0324c2a50790ee Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 10 Mar 2019 19:58:04 -0600 Subject: [PATCH 07/53] PAN-15 Created gradle tasks to start the persistence API and to start the API asynchronously --- build.gradle | 26 +++++++++++++++++++++----- persistence/build.gradle | 11 +++++++++++ 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/build.gradle b/build.gradle index 6690226..6c4a792 100644 --- a/build.gradle +++ b/build.gradle @@ -1,6 +1,20 @@ +import java.util.concurrent.Callable +import java.util.concurrent.ExecutorService +import java.util.concurrent.Executors + +class RunAsyncTask extends DefaultTask { + String taskToExecute = ':persistence:startPersistenceApi' + @TaskAction + def startAsync() { + ExecutorService es = Executors.newSingleThreadExecutor() + es.submit({taskToExecute.execute()} as Callable) + } +} + buildscript { repositories { mavenCentral() + maven { url 'http://dl.bintray.com/vermeulen-mp/gradle-plugins' } } dependencies { classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE") @@ -15,6 +29,7 @@ plugins { id "org.sonarqube" version "2.6" id 'org.unbroken-dome.test-sets' version '1.4.5' id 'war' + id "com.wiredforcode.spawn" version "0.8.2" } apply plugin: 'org.springframework.boot' @@ -87,11 +102,6 @@ subprojects { } } -bootJar { - baseName = 'gs-spring-boot' - version = '0.1.0' -} - sourceCompatibility = 1.8 targetCompatibility = 1.8 @@ -136,6 +146,12 @@ testSets { integrationTest } +task startApi(type: RunAsyncTask) { + dependsOn ':persistence:loadDb' + dependsOn 'build' + taskToExecute = ':persistence:startPersistenceApi' +} + compileKotlin { kotlinOptions.jvmTarget = "1.8" } diff --git a/persistence/build.gradle b/persistence/build.gradle index b832e7e..4672194 100644 --- a/persistence/build.gradle +++ b/persistence/build.gradle @@ -3,6 +3,9 @@ plugins { id 'java' } +apply plugin: 'io.spring.dependency-management' +apply plugin: 'org.springframework.boot' + description = 'Provides database access and connectivity' group 'edu.msudenver.tsp' version '1.0' @@ -50,3 +53,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 bc92dc60d425eeb30f2c6ba0e13a95242a391471 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Thu, 14 Mar 2019 10:51:38 -0600 Subject: [PATCH 08/53] 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 09/53] 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 10/53] 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 11/53] 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 12/53] PAN-52 Added findByName to the TheoremRepository, and to the TheoremController as well as the corresponding tests, and a foreign key mapping from the proofs table to the corresponding theorem in the theorems table --- .../scripts/mysql/local_development.sql | 20 +++++----- .../controller/TheoremController.java | 30 ++++++++++++++ .../repository/TheoremRepository.java | 2 + .../controller/TheoremControllerTest.java | 40 +++++++++++++++++++ 4 files changed, 83 insertions(+), 9 deletions(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 0b68072..860c41b 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -35,13 +35,15 @@ version int default 1 ); CREATE TABLE proofs ( - id INT NOT NULL AUTO_INCREMENT, - name VARCHAR(512) NOT NULL, - branch VARCHAR(512) NOT NULL, - referenced_definitions JSON, - referenced_theorems JSON, - date_added DATE, - last_updated DATE, - version INT DEFAULT 1, + id INT NOT NULL AUTO_INCREMENT, + name VARCHAR(512) NOT NULL, + branch VARCHAR(512) NOT NULL, + theorem INT NOT NULL, + FOREIGN KEY fk_theorem (theorem) REFERENCES theorems (id) ON DELETE NO ACTION ON UPDATE NO ACTION, + referenced_definitions JSON, + referenced_theorems JSON, + date_added DATE, + last_updated DATE, + version INT DEFAULT 1, PRIMARY KEY (id) -) \ No newline at end of file +); \ No newline at end of file diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java index 9a0f699..68ce608 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -101,6 +101,36 @@ public class TheoremController { return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); } + @GetMapping("/{name}") + public @ResponseBody + ResponseEntity> getAllTheoremsByName(@PathVariable("name") final String name) { + LOG.info("Received request to query for theorems whose name is " + name); + if (name == null) { + LOG.error("ERROR: name was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for theorems with name " + name); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfTheorems = theoremRepository.findByName(name); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning list of all theorems with size " + listOfTheorems.size()); + + if (listOfTheorems.isEmpty()) { + LOG.warn("No theorems were found with name {}", name); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + + LOG.info("Returning list of theorems with name {}", name); + return new ResponseEntity<>(listOfTheorems, HttpStatus.OK); + } + @GetMapping("/{id}") public @ResponseBody ResponseEntity getTheoremById(@PathVariable("id") final Integer id) { diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java index 75df2ee..2e3c9f6 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -12,4 +12,6 @@ public interface TheoremRepository extends JpaRepository { List findByBranch(String branch); List findByProvenStatus(Boolean provenStatus); + + List findByName(String name); } diff --git a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java index f3993cc..6d09a22 100644 --- a/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java +++ b/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/TheoremControllerTest.java @@ -166,6 +166,46 @@ public class TheoremControllerTest { assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); } + @Test + public void testGetAllTheoremsByName() { + final TheoremDto theoremDto = createTheorem(); + final List listOfTheorems = new ArrayList<>(); + listOfTheorems.add(theoremDto); + listOfTheorems.add(theoremDto); + + when(theoremRepository.findByName(anyString())).thenReturn(listOfTheorems); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("Test Theorem"); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(theorem -> assertEquals(theoremDto, theorem)); + } + + @Test + public void testGetAllTheoremsByName_nullName() { + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(theoremRepository); + } + + @Test + public void testGetAllTheoremsByName_noNameFound() { + when(theoremRepository.findByName(anyString())).thenReturn(Collections.emptyList()); + + final ResponseEntity> responseEntity = theoremController.getAllTheoremsByName("No name"); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + } + @Test public void testInsertTheorem() { final TheoremDto theoremDto = createTheorem(); From bd7455c679c89f74ba9fd02443fb0f2a4d11d141 Mon Sep 17 00:00:00 2001 From: atusa Date: Fri, 15 Mar 2019 15:04:45 -0600 Subject: [PATCH 13/53] 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 14/53] 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 15/53] 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 16/53] 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 17/53] 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 18/53] 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 19/53] 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 20/53] 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 21/53] 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 22/53] 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 23/53] 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 24/53] 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 25/53] 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 26/53] 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 860e5379e6f70ad11be3fc83597cce1c8b78f54e Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Wed, 20 Mar 2019 16:06:24 -0600 Subject: [PATCH 27/53] PAN-15 UserService.java and completed UserSservice integration test --- ...damonium-theorem-prover.main.kotlin_module | Bin 16 -> 0 bytes .../scripts/mysql/local_development.sql | 1 + .../repository/AccountsRepository.java | 3 + .../controller/AccountControllerTest.java | 1 + .../services/UserServiceIntegrationTest.java | 24 +++- .../msudenver/tsp/services/RestService.java | 9 +- .../msudenver/tsp/services/UserService.java | 115 +++++++++++++++++- .../msudenver/tsp/services/dto/Account.java | 1 + .../tsp/services/factory/RequestFactory.java | 4 + 9 files changed, 148 insertions(+), 10 deletions(-) delete mode 100644 out/production/classes/META-INF/edu.msudenver.tsp.pandamonium-theorem-prover.main.kotlin_module 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/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 1f885cc..eb1549c 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -16,6 +16,7 @@ values ('admin', 'secret', true), ('BrittanyBi', 'secret', true), ('lanlanzeliu', 'secret', true), ('tramanh305', 'secret', true); + create table definitions ( id int not null auto_increment primary key unique, name varchar(200) not null, 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 454cd77..542ffe8 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 @@ -6,4 +6,7 @@ import org.springframework.stereotype.Repository; @Repository public interface AccountsRepository extends CrudRepository { + + + } 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 0b88630..8dd69ca 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 @@ -33,6 +33,7 @@ public class AccountControllerTest { @Test public void testGetAllAccounts() { + final AccountDto accountDto = createAccount(); final List accountDtoList = new ArrayList<>(); accountDtoList.add(accountDto); diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java index c3a71d0..c006236 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -9,7 +9,6 @@ import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestPropertySource; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import java.text.ParseException; import java.util.Date; import java.util.Optional; @@ -24,7 +23,7 @@ public class UserServiceIntegrationTest { private UserService userService; @Test - public void testCreateNewUser() throws ParseException { + public void testUserService(){ final Account testAccount = new Account(); testAccount.setUsername("test user"); testAccount.setPassword("test password"); @@ -38,5 +37,26 @@ public class UserServiceIntegrationTest { assertEquals("test user", returnedAccount.getUsername()); assertEquals("test password", returnedAccount.getPassword()); assertFalse(returnedAccount.isAdministratorStatus()); + + final Optional updatePasswordTestCreatedAccount = userService.updatePassword(returnedAccount, "password"); + + assertTrue(updatePasswordTestCreatedAccount.isPresent()); + final Account returnedUpdatedPasswordAccount = updatePasswordTestCreatedAccount.get(); + assertEquals("test user", returnedUpdatedPasswordAccount.getUsername()); + assertEquals("password", returnedUpdatedPasswordAccount.getPassword()); + assertFalse(returnedAccount.isAdministratorStatus()); + + final Optional updateUsernameTestCreatedAccount = userService.updateUsername(returnedUpdatedPasswordAccount, "user"); + + assertTrue(updateUsernameTestCreatedAccount.isPresent()); + final Account returnedUpdatedUsernameAccount = updateUsernameTestCreatedAccount.get(); + assertEquals("user", returnedUpdatedUsernameAccount.getUsername()); + assertEquals("password", returnedUpdatedUsernameAccount.getPassword()); + assertFalse(returnedAccount.isAdministratorStatus()); + + final boolean result = userService.deleteAccount(returnedUpdatedUsernameAccount); + + assertTrue(result); } + } 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..a8d043a 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/RestService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/RestService.java @@ -43,16 +43,21 @@ public class RestService { return send(requestFactory.post(uri, requestJson), null, 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); + } 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) { + Optional put(final String uri, final String requestJson, final TypeToken type, final Integer connectionTimeout, final Integer socketTimeout) { LOG.info("Sending PUT {} with body: {}", uri, requestJson); - return send(requestFactory.put(uri, requestJson), auth, connectionTimeout, socketTimeout, type); + return send(requestFactory.put(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/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index 0862ae5..9cb0b46 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -6,6 +6,7 @@ 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.http.HttpStatus; import org.springframework.stereotype.Service; import java.time.Duration; @@ -16,16 +17,19 @@ import java.util.Optional; @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; + @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) { + public Optional createNewAccount(final Account account) { if (account == null) { LOG.error("Given null account, returning {}"); return Optional.empty(); @@ -33,7 +37,8 @@ public class UserService { final Instant start = Instant.now(); try { - final TypeToken typeToken = new TypeToken() {}; + final TypeToken typeToken = new TypeToken() { + }; final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "accounts/", new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, @@ -41,7 +46,7 @@ public class UserService { socketTimeoutMilliseconds); if (persistenceApiResponse.isPresent()) { - LOG.info("Returning {}", persistenceApiResponse.get()); + LOG.info("Returning {}", persistenceApiResponse); } else { LOG.info("Unable to create new account {}", account.toString()); } @@ -54,4 +59,102 @@ public class UserService { LOG.info("Create new account request took {} ms", Duration.between(start, Instant.now()).toMillis()); } } + + public Optional updatePassword(final Account account , final String password){ + + if(account ==null){ + LOG.error("user not exist, returning{}"); + return Optional.empty(); + } + + final Integer id = account.getId(); + account.setPassword(password); + final Instant start = Instant.now(); + + try{ + final String auth = ""; + final TypeToken typeToken = new TypeToken(){}; + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/"+id, + new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to update password for account {}",account.toString()); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error updating account {}", e); + return Optional.empty(); + } finally { + LOG.info("Update account request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } + + public Optional updateUsername(final Account account , final String username){ + + if(account ==null){ + LOG.error("user not exist, returning{}"); + return Optional.empty(); + } + + final Integer id = account.getId(); + account.setUsername(username); + final Instant start = Instant.now(); + + try{ + final String auth = ""; + final TypeToken typeToken = new TypeToken(){}; + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/"+id, + new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to update username for account {}",account.toString()); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error updating account {}", e); + return Optional.empty(); + } finally { + LOG.info("Update account request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } + public boolean deleteAccount(final Account account){ + if(account ==null){ + LOG.error("Username not exist, returning{}"); + return false; + } + final Integer id = account.getId(); + final Instant start = Instant.now(); + + try{ + + final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl +"/accounts/"+id, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds, HttpStatus.NO_CONTENT ); + if(persistenceApiResponse){ + LOG.info("return {}", persistenceApiResponse); + } + else { + LOG.info("Unable to delete user {}",account.toString()); + } + + return persistenceApiResponse; + }catch (final Exception e) { + LOG.error("Error deleting user {}", e); + return false; + } finally { + LOG.info("delete user 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 index 1190dd8..b1a04d9 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 @@ -21,4 +21,5 @@ public class Account extends BaseDto implements Serializable { private static final long serialVersionUID = 7095627971593953734L; + } 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..e108cd1 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.Patch(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Patch(uri); + } } \ No newline at end of file From f5f959b4530cf351436d02d94586d7e556fe9852 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 20 Mar 2019 22:28:51 -0600 Subject: [PATCH 28/53] Merge branches 'PAN-15' and 'master' of https://github.com/atusa17/ptp into PAN-15 # Conflicts: # services/build.gradle --- persistence/build.gradle | 3 -- .../scripts/mysql/local_development.sql | 1 - .../msudenver/tsp/services/UserService.java | 33 +++++++++---------- 3 files changed, 15 insertions(+), 22 deletions(-) diff --git a/persistence/build.gradle b/persistence/build.gradle index 4672194..811725d 100644 --- a/persistence/build.gradle +++ b/persistence/build.gradle @@ -3,9 +3,6 @@ plugins { id 'java' } -apply plugin: 'io.spring.dependency-management' -apply plugin: 'org.springframework.boot' - description = 'Provides database access and connectivity' group 'edu.msudenver.tsp' version '1.0' diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index e8acdaf..52480e5 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -16,7 +16,6 @@ values ('admin', 'secret', true), ('BrittanyBi', 'secret', true), ('lanlanzeliu', 'secret', true), ('tramanh305', 'secret', true); - create table definitions ( id int not null auto_increment primary key unique, name varchar(200) not null, diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index 9cb0b46..7382653 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -17,19 +17,16 @@ import java.util.Optional; @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; + @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) { + public Optional createNewAccount(final Account account) { if (account == null) { LOG.error("Given null account, returning {}"); return Optional.empty(); @@ -37,8 +34,7 @@ public class UserService { final Instant start = Instant.now(); try { - final TypeToken typeToken = new TypeToken() { - }; + final TypeToken typeToken = new TypeToken() {}; final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "accounts/", new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, @@ -46,7 +42,7 @@ public class UserService { socketTimeoutMilliseconds); if (persistenceApiResponse.isPresent()) { - LOG.info("Returning {}", persistenceApiResponse); + LOG.info("Returning {}", persistenceApiResponse.get()); } else { LOG.info("Unable to create new account {}", account.toString()); } @@ -74,7 +70,7 @@ public class UserService { try{ final String auth = ""; final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/"+id, + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/id?id=" + id, new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, connectionTimeoutMilliseconds, @@ -93,7 +89,7 @@ public class UserService { } finally { LOG.info("Update account request took {} ms", Duration.between(start, Instant.now()).toMillis()); } - } + } public Optional updateUsername(final Account account , final String username){ @@ -109,7 +105,7 @@ public class UserService { try{ final String auth = ""; final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/"+id, + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/id?id="+id, new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, connectionTimeoutMilliseconds, @@ -129,9 +125,10 @@ public class UserService { LOG.info("Update account request took {} ms", Duration.between(start, Instant.now()).toMillis()); } } - public boolean deleteAccount(final Account account){ - if(account ==null){ - LOG.error("Username not exist, returning{}"); + + public boolean deleteAccount(final Account account) { + if(account == null){ + LOG.error("Username does not exist, returning {}"); return false; } final Integer id = account.getId(); @@ -139,14 +136,14 @@ public class UserService { try{ - final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl +"/accounts/"+id, + final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl + "/accounts/id?id=" + id, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, HttpStatus.NO_CONTENT ); if(persistenceApiResponse){ LOG.info("return {}", persistenceApiResponse); } else { - LOG.info("Unable to delete user {}",account.toString()); + LOG.info("Unable to delete user {}", account.toString()); } return persistenceApiResponse; From 9695f5082ad34a47f3551e778adaeff20c1704f5 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 20 Mar 2019 22:30:11 -0600 Subject: [PATCH 29/53] Merge branches 'PAN-15' and 'master' of https://github.com/atusa17/ptp into PAN-15 # Conflicts: # services/build.gradle --- .../main/java/edu/msudenver/tsp/services/UserService.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index 7382653..ffb78a5 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -70,7 +70,7 @@ public class UserService { try{ final String auth = ""; final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/id?id=" + id, + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/" + id, new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, connectionTimeoutMilliseconds, @@ -105,7 +105,7 @@ public class UserService { try{ final String auth = ""; final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/id?id="+id, + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/"+id, new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, connectionTimeoutMilliseconds, @@ -136,7 +136,7 @@ public class UserService { try{ - final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl + "/accounts/id?id=" + id, + final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl + "/accounts/" + id, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, HttpStatus.NO_CONTENT ); if(persistenceApiResponse){ From 8c79d9975e7bd36c5e173575c9cda00ef507f50d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Wed, 20 Mar 2019 22:32:25 -0600 Subject: [PATCH 30/53] 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 31/53] 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 32/53] 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 33/53] 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 34/53] 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 35/53] 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 36/53] 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 37/53] 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 38/53] 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 39/53] 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 40/53] 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 41/53] 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 42/53] 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 43/53] 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 From 89f1c55f51a4f4d8c8c6bb32271115c4df29c00c Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 24 Mar 2019 14:54:06 -0600 Subject: [PATCH 44/53] PAN-15 Fixed unit tests --- build.gradle | 6 ++- .../msudenver/tsp/services/UserService.java | 24 +++++----- .../tsp/services/UserServiceTest.java | 47 +++++++++++++++++++ .../msudenver/tsp/website/Application.java | 19 +------- src/main/webapp/index.jsp | 15 ++++-- 5 files changed, 79 insertions(+), 32 deletions(-) create mode 100644 services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java diff --git a/build.gradle b/build.gradle index cc21aa1..e00bb1b 100644 --- a/build.gradle +++ b/build.gradle @@ -1,3 +1,4 @@ + buildscript { repositories { mavenCentral() @@ -70,7 +71,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')} - } test { @@ -107,7 +107,11 @@ 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 'javax.el:javax.el-api:3.0.0' + testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.3.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')} diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index ffb78a5..d717e2b 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -56,19 +56,21 @@ public class UserService { } } - public Optional updatePassword(final Account account , final String password){ - - if(account ==null){ - LOG.error("user not exist, returning{}"); + public Optional updateAccount(final Account account) { + if (account == null) { + LOG.error("User does not exist, returning {}"); return Optional.empty(); } - final Integer id = account.getId(); - account.setPassword(password); + if (account.getId() == 0) { + LOG.error("No user ID specified! Returning {}"); + return Optional.empty(); + } + + final int id = account.getId(); final Instant start = Instant.now(); - try{ - final String auth = ""; + try { final TypeToken typeToken = new TypeToken(){}; final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/" + id, new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), @@ -79,15 +81,15 @@ public class UserService { if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to update password for account {}",account.toString()); + LOG.info("Unable to update user {} with id", account.getId()); } return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error updating account {}", e); + LOG.error("Error updating user {}", e); return Optional.empty(); } finally { - LOG.info("Update account request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Update user request took {} ms", Duration.between(start, Instant.now()).toMillis()); } } diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java new file mode 100644 index 0000000..52379b0 --- /dev/null +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -0,0 +1,47 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.reflect.TypeToken; +import edu.msudenver.tsp.services.dto.Account; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +import java.text.ParseException; +import java.util.Date; +import java.util.Optional; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.*; +import static org.mockito.Mockito.when; + + + + +@RunWith(MockitoJUnitRunner.class) +public class UserServiceTest { + @Mock + private RestService restService; + @InjectMocks + private UserService userService; + + @Test + public void testCreateNewAccount() throws ParseException { + + final Account account = new Account(); + account.setUsername("Test username"); + account.setPassword("test password"); + account.setAdministratorStatus(false); + account.setLastLogin(new Date()); + + when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) + .thenReturn(Optional.of(account)); + + final Optional response = userService.createNewAccount(account); + + assertTrue(response.isPresent()); + assertEquals(account, response.get()); + } +} \ No newline at end of file diff --git a/src/main/java/edu/msudenver/tsp/website/Application.java b/src/main/java/edu/msudenver/tsp/website/Application.java index c8f0854..3339429 100644 --- a/src/main/java/edu/msudenver/tsp/website/Application.java +++ b/src/main/java/edu/msudenver/tsp/website/Application.java @@ -1,15 +1,9 @@ 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 @SpringBootApplication public class Application { @@ -17,17 +11,8 @@ public class Application { SpringApplication.run(Application.class, args); } - @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/src/main/webapp/index.jsp b/src/main/webapp/index.jsp index f8d618c..6417074 100644 --- a/src/main/webapp/index.jsp +++ b/src/main/webapp/index.jsp @@ -5,12 +5,21 @@ Time: 8:03 PM To change this template use File | Settings | File Templates. --%> -<%@ page contentType="text/html;charset=UTF-8" language="java" %> +<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %> + - $Title$ + + Theroem Prover - $END$ +
+
+

Theorem Prover

+

Hello! ${message}

+ + Click on this link to visit theorem entering page. +
+
From 94440faa4d748f8792b764bd0a95645f3929c0fd Mon Sep 17 00:00:00 2001 From: zeliu Date: Sun, 24 Mar 2019 15:21:25 -0600 Subject: [PATCH 45/53] PAN-18 Here is the JSP file for hoempage --- .../resources/application.properties | 3 +-- src/main/webapp/index.jsp | 25 +++++++++++-------- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/out/production/resources/application.properties b/out/production/resources/application.properties index a8a0755..f3ce324 100644 --- a/out/production/resources/application.properties +++ b/out/production/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 diff --git a/src/main/webapp/index.jsp b/src/main/webapp/index.jsp index 0efda13..eaf742c 100644 --- a/src/main/webapp/index.jsp +++ b/src/main/webapp/index.jsp @@ -5,18 +5,23 @@ Time: 8:03 PM To change this template use File | Settings | File Templates. --%> -<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%> + + +<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %> + - Test page + + Theroem Prover - -

Test stuffs

-test hyperlink -
- -
- - +
+
+

Theorem Prover

+

Hello! ${message}

+ Click on this link to visit theorem entering page. +
+
+ + \ No newline at end of file From 3b4753215c0064158cf72af4a72104632dba1c0f Mon Sep 17 00:00:00 2001 From: zeliu Date: Sun, 24 Mar 2019 15:26:08 -0600 Subject: [PATCH 46/53] PAN-18 Refactored the HomeController --- .../resources/application.properties | 2 -- .../website/controller/HomeController.java | 28 +++++++++++++++++++ 2 files changed, 28 insertions(+), 2 deletions(-) delete mode 100644 out/production/resources/application.properties create mode 100644 src/main/java/edu/msudenver/tsp/website/controller/HomeController.java diff --git a/out/production/resources/application.properties b/out/production/resources/application.properties deleted file mode 100644 index f3ce324..0000000 --- a/out/production/resources/application.properties +++ /dev/null @@ -1,2 +0,0 @@ -spring.mvc.view.prefix:/WEB-INF/jsp/ -spring.mvc.view.suffix:.jsp \ No newline at end of file diff --git a/src/main/java/edu/msudenver/tsp/website/controller/HomeController.java b/src/main/java/edu/msudenver/tsp/website/controller/HomeController.java new file mode 100644 index 0000000..128ca0c --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/controller/HomeController.java @@ -0,0 +1,28 @@ +package edu.msudenver.tsp.website.controller; + +import lombok.AllArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; + +import java.util.Map; + +@Slf4j +@Controller +@AllArgsConstructor +@RequestMapping("/") +public class HomeController { + + @GetMapping("") + public String home(Map model) { + model.put("message", "Welcome to Theorem Prover !!"); + return "index"; + } + + @RequestMapping("/next") + public String next(Map model) { + model.put("message", "You are in new page !!"); + return "Theorem"; + } +} From 98f6b9e2b7551ba19bb94f13bb864e54c37ec038 Mon Sep 17 00:00:00 2001 From: zeliu Date: Sun, 24 Mar 2019 17:02:50 -0600 Subject: [PATCH 47/53] PAN-18 WORKING HOMEPAGE --- build.gradle | 2 +- .../website/controller/HomeController.java | 28 ------------------- src/main/webapp/{ => WEB-INF/jsp}/index.jsp | 8 +++--- 3 files changed, 5 insertions(+), 33 deletions(-) delete mode 100644 src/main/java/edu/msudenver/tsp/website/controller/HomeController.java rename src/main/webapp/{ => WEB-INF/jsp}/index.jsp (63%) diff --git a/build.gradle b/build.gradle index 1402ea7..d2d9c24 100644 --- a/build.gradle +++ b/build.gradle @@ -99,7 +99,7 @@ repositories { } dependencies { - compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8" + compile group: 'org.jacoco', name: 'org.jacoco.core', version: '0.8.3' 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 diff --git a/src/main/java/edu/msudenver/tsp/website/controller/HomeController.java b/src/main/java/edu/msudenver/tsp/website/controller/HomeController.java deleted file mode 100644 index 128ca0c..0000000 --- a/src/main/java/edu/msudenver/tsp/website/controller/HomeController.java +++ /dev/null @@ -1,28 +0,0 @@ -package edu.msudenver.tsp.website.controller; - -import lombok.AllArgsConstructor; -import lombok.extern.slf4j.Slf4j; -import org.springframework.stereotype.Controller; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.RequestMapping; - -import java.util.Map; - -@Slf4j -@Controller -@AllArgsConstructor -@RequestMapping("/") -public class HomeController { - - @GetMapping("") - public String home(Map model) { - model.put("message", "Welcome to Theorem Prover !!"); - return "index"; - } - - @RequestMapping("/next") - public String next(Map model) { - model.put("message", "You are in new page !!"); - return "Theorem"; - } -} diff --git a/src/main/webapp/index.jsp b/src/main/webapp/WEB-INF/jsp/index.jsp similarity index 63% rename from src/main/webapp/index.jsp rename to src/main/webapp/WEB-INF/jsp/index.jsp index eaf742c..54f56bb 100644 --- a/src/main/webapp/index.jsp +++ b/src/main/webapp/WEB-INF/jsp/index.jsp @@ -7,20 +7,20 @@ --%> -<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %> +<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %> - Theroem Prover + Theorem Prover

Theorem Prover

-

Hello! ${message}

+

Hello! Welcome to Theorem Prover !!

- Click on this link to visit theorem entering page. + Click on this link to visit theorem entering page.
From 8f2968bc2b0529c4dbb6f73b8c13df73cf26de77 Mon Sep 17 00:00:00 2001 From: zeliu Date: Sun, 24 Mar 2019 17:17:04 -0600 Subject: [PATCH 48/53] PAN-18 WORKING HOMEPAGE --- src/main/webapp/WEB-INF/jsp/index.jsp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/webapp/WEB-INF/jsp/index.jsp b/src/main/webapp/WEB-INF/jsp/index.jsp index 54f56bb..a31785b 100644 --- a/src/main/webapp/WEB-INF/jsp/index.jsp +++ b/src/main/webapp/WEB-INF/jsp/index.jsp @@ -12,13 +12,13 @@ - Theorem Prover + Pandamonium™ Theorem Prover

Theorem Prover

-

Hello! Welcome to Theorem Prover !!

+

Hello! Welcome to Pandamonium™ Theorem Prover!!

Click on this link to visit theorem entering page.
From 6791f6c61fe64cfa1cc96d65669da3def5c31e61 Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Sun, 24 Mar 2019 17:31:40 -0600 Subject: [PATCH 49/53] Merge branch 'master' of https://github.com/atusa17/ptp into PAN-15 # Conflicts: # src/main/java/edu/msudenver/tsp/website/Application.java --- .../services/UserServiceIntegrationTest.java | 38 +++++++-------- .../msudenver/tsp/services/UserService.java | 41 +++------------- .../tsp/services/UserServiceTest.java | 47 ++++++++++++++++--- 3 files changed, 66 insertions(+), 60 deletions(-) diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java index e8abd0b..be372fc 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -24,11 +24,7 @@ public class UserServiceIntegrationTest { @Test public void testUserService(){ - final Account testAccount = new Account(); - testAccount.setUsername("test user"); - testAccount.setPassword("test password"); - testAccount.setAdministratorStatus(false); - testAccount.setLastLogin(new Date()); + final Account testAccount = creatAccount(); final Optional testCreatedAccount = userService.createNewAccount(testAccount); @@ -38,25 +34,29 @@ public class UserServiceIntegrationTest { assertEquals("test password", returnedAccount.getPassword()); assertFalse(returnedAccount.isAdministratorStatus()); - final Optional updatePasswordTestCreatedAccount = userService.updateAccount(returnedAccount); + returnedAccount.setUsername("test updatedUser"); + returnedAccount.setPassword("test updatedPassword"); - assertTrue(updatePasswordTestCreatedAccount.isPresent()); - final Account returnedUpdatedPasswordAccount = updatePasswordTestCreatedAccount.get(); - assertEquals("test user", returnedUpdatedPasswordAccount.getUsername()); - assertEquals("password", returnedUpdatedPasswordAccount.getPassword()); - assertFalse(returnedAccount.isAdministratorStatus()); + final Optional updatedTestCreatedAccount = userService.updateAccount(returnedAccount); - final Optional updateUsernameTestCreatedAccount = userService.updateUsername(returnedUpdatedPasswordAccount, "user"); + assertTrue(updatedTestCreatedAccount .isPresent()); + final Account returnedUpdatedAccount = updatedTestCreatedAccount.get(); + assertEquals("test updatedUser", returnedUpdatedAccount.getUsername()); + assertEquals("test updatedPassword", returnedUpdatedAccount.getPassword()); + assertFalse(returnedUpdatedAccount.isAdministratorStatus()); - assertTrue(updateUsernameTestCreatedAccount.isPresent()); - final Account returnedUpdatedUsernameAccount = updateUsernameTestCreatedAccount.get(); - assertEquals("user", returnedUpdatedUsernameAccount.getUsername()); - assertEquals("password", returnedUpdatedUsernameAccount.getPassword()); - assertFalse(returnedAccount.isAdministratorStatus()); - - final boolean result = userService.deleteAccount(returnedUpdatedUsernameAccount); + final boolean result = userService.deleteAccount(returnedUpdatedAccount); assertTrue(result); } + private Account creatAccount(){ + final Account testAccount = new Account(); + testAccount.setUsername("test user"); + testAccount.setPassword("test password"); + testAccount.setAdministratorStatus(false); + testAccount.setLastLogin(new Date()); + + return testAccount; + } } diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index d717e2b..2e7a468 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -93,47 +93,18 @@ public class UserService { } } - public Optional updateUsername(final Account account , final String username){ - - if(account ==null){ - LOG.error("user not exist, returning{}"); - return Optional.empty(); - } - - final Integer id = account.getId(); - account.setUsername(username); - final Instant start = Instant.now(); - - try{ - final String auth = ""; - final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/"+id, - new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), - typeToken, - connectionTimeoutMilliseconds, - socketTimeoutMilliseconds); - - if (persistenceApiResponse.isPresent()) { - LOG.info("Returning {}", persistenceApiResponse.get()); - } else { - LOG.info("Unable to update username for account {}",account.toString()); - } - - return persistenceApiResponse; - } catch (final Exception e) { - LOG.error("Error updating account {}", e); - return Optional.empty(); - } finally { - LOG.info("Update account request took {} ms", Duration.between(start, Instant.now()).toMillis()); - } - } public boolean deleteAccount(final Account account) { if(account == null){ LOG.error("Username does not exist, returning {}"); return false; } - final Integer id = account.getId(); + + if (account.getId() == 0) { + LOG.error("No user ID specified! Returning {}"); + return false; + } + final int id = account.getId(); final Instant start = Instant.now(); try{ diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java index ab1f321..1fb9dda 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -27,11 +27,7 @@ public class UserServiceTest { @Test public void testCreateNewAccount() throws ParseException { - final Account account = new Account(); - account.setUsername("Test username"); - account.setPassword("test password"); - account.setAdministratorStatus(false); - account.setLastLogin(new Date()); + final Account account = createAccount(); when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) .thenReturn(Optional.of(account)); @@ -41,4 +37,43 @@ public class UserServiceTest { assertTrue(response.isPresent()); assertEquals(account, response.get()); } -} \ No newline at end of file + + @Test + public void testUpdateAccount() throws ParseException { + final Account account = createAccount(); + account.setId(1); + + when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) + .thenReturn(Optional.of(account)); + + final Optional response = userService.updateAccount(account); + + assertTrue(response.isPresent()); + assertEquals(account, response.get()); + } + + @Test + public void testDeleteAccount() throws ParseException { + final boolean response= true; + final Account account = createAccount(); + account.setId(1); + + when(restService.delete(anyString(), anyInt(), anyInt(), any())) + .thenReturn(response); + + final boolean persistenceApiResponse = userService.deleteAccount(account); + + assertTrue(persistenceApiResponse ); + assertEquals(response, persistenceApiResponse ); + } + + + private Account createAccount() { + final Account account = new Account(); + account.setUsername("Test username"); + account.setPassword("test password"); + account.setAdministratorStatus(true); + account.setLastLogin(new Date()); + return account; + } +} From 0bc56f57e6978cd5634e06a4c3f7c724303102e7 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 17:49:07 -0600 Subject: [PATCH 50/53] PAN-15 Merged with master --- build.gradle | 1 - .../msudenver/tsp/services/UserServiceIntegrationTest.java | 1 + .../java/edu/msudenver/tsp/services/UserServiceTest.java | 6 ++---- 3 files changed, 3 insertions(+), 5 deletions(-) diff --git a/build.gradle b/build.gradle index 2dfd518..d2d9c24 100644 --- a/build.gradle +++ b/build.gradle @@ -1,4 +1,3 @@ - buildscript { repositories { mavenCentral() diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java index be372fc..88da28f 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -49,6 +49,7 @@ public class UserServiceIntegrationTest { assertTrue(result); } + private Account creatAccount(){ final Account testAccount = new Account(); testAccount.setUsername("test user"); diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java index 1fb9dda..7f19401 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -19,10 +19,8 @@ import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class UserServiceTest { - @Mock - private RestService restService; - @InjectMocks - private UserService userService; + @Mock private RestService restService; + @InjectMocks private UserService userService; @Test public void testCreateNewAccount() throws ParseException { From b1d4ed9719c74b14d7ca0769be51ac9a4157e043 Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Wed, 27 Mar 2019 12:18:12 -0600 Subject: [PATCH 51/53] PAN-15 fix the request changes --- .../services/UserServiceIntegrationTest.java | 43 ++++--- .../msudenver/tsp/services/UserService.java | 114 ++++++++++++++++-- .../tsp/services/UserServiceTest.java | 56 +++++++-- .../website/controller/LogInController.java | 35 ++++++ 4 files changed, 212 insertions(+), 36 deletions(-) create mode 100644 src/main/java/edu/msudenver/tsp/website/controller/LogInController.java diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java index 88da28f..b3a547d 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -24,36 +24,47 @@ public class UserServiceIntegrationTest { @Test public void testUserService(){ - final Account testAccount = creatAccount(); - - final Optional testCreatedAccount = userService.createNewAccount(testAccount); + final Account testAccount = createAccount(); + final Optional testCreatedAccount = userService.createAccount(testAccount); assertTrue(testCreatedAccount.isPresent()); final Account returnedAccount = testCreatedAccount.get(); - assertEquals("test user", returnedAccount.getUsername()); - assertEquals("test password", returnedAccount.getPassword()); + assertEquals("test_user", returnedAccount.getUsername()); + assertEquals("test_password", returnedAccount.getPassword()); assertFalse(returnedAccount.isAdministratorStatus()); - returnedAccount.setUsername("test updatedUser"); - returnedAccount.setPassword("test updatedPassword"); + final Optional getAccountById = userService.getAccountById(returnedAccount.getId()); + assertTrue(getAccountById.isPresent()); + final Account returnedAccountById = getAccountById.get(); + assertEquals("test_user", returnedAccountById.getUsername()); + assertEquals("test_password", returnedAccountById.getPassword()); + assertFalse(returnedAccountById.isAdministratorStatus()); - final Optional updatedTestCreatedAccount = userService.updateAccount(returnedAccount); + final Optional getAccountByUsername = userService.getAccountByUsername(returnedAccount.getUsername()); + assertTrue(getAccountByUsername.isPresent()); + final Account returnedAccountByUsername = getAccountByUsername.get(); + assertEquals("test_user", returnedAccountByUsername.getUsername()); + assertEquals("test_password", returnedAccountByUsername.getPassword()); + assertFalse(returnedAccountById.isAdministratorStatus()); - assertTrue(updatedTestCreatedAccount .isPresent()); - final Account returnedUpdatedAccount = updatedTestCreatedAccount.get(); - assertEquals("test updatedUser", returnedUpdatedAccount.getUsername()); - assertEquals("test updatedPassword", returnedUpdatedAccount.getPassword()); + returnedAccount.setUsername("test_updatedUser"); + returnedAccount.setPassword("test_updatedPassword"); + + final Optional updatedAccount = userService.updateAccount(returnedAccount); + assertTrue(updatedAccount .isPresent()); + final Account returnedUpdatedAccount = updatedAccount.get(); + assertEquals("test_updatedUser", returnedUpdatedAccount.getUsername()); + assertEquals("test_updatedPassword", returnedUpdatedAccount.getPassword()); assertFalse(returnedUpdatedAccount.isAdministratorStatus()); final boolean result = userService.deleteAccount(returnedUpdatedAccount); - assertTrue(result); } - private Account creatAccount(){ + private Account createAccount(){ final Account testAccount = new Account(); - testAccount.setUsername("test user"); - testAccount.setPassword("test password"); + testAccount.setUsername("test_user"); + testAccount.setPassword("test_password"); testAccount.setAdministratorStatus(false); testAccount.setLastLogin(new Date()); diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index 2e7a468..593b0d9 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -26,7 +26,99 @@ public class UserService { this.restService = restService; } - public Optional createNewAccount(final Account account) { + public Optional getListOfAccount(){ + final String auth = ""; + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken() {}; + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/", + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds, + auth); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to get the list of accounts"); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error getting the list of accounts {}", e); + return Optional.empty(); + } finally { + LOG.info("Getting the list of accounts request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } + + public Optional getAccountById(final int id) { + + if (id == 0) { + LOG.error("No user ID specified! Returning {}"); + return Optional.empty(); + } + + final String auth = ""; + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken() {}; + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/id?id="+id, + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds, + auth); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to find account with id {}", id); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error getting account by id {}", e); + return Optional.empty(); + } finally { + LOG.info("Getting account by ID request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } + + public Optional getAccountByUsername(final String username) { + if (username == null) { + LOG.error("No username specified! Returning {}"); + return Optional.empty(); + } + + final String auth = ""; + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken() {}; + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/username?username="+username, + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds, + auth); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to GET account with username{}", username); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error getting account by username {}", e); + return Optional.empty(); + } finally { + LOG.info("Getting account by username request took {} ms", Duration.between(start, Instant.now()).toMillis()); + } + } + + public Optional createAccount(final Account account) { if (account == null) { LOG.error("Given null account, returning {}"); return Optional.empty(); @@ -58,7 +150,7 @@ public class UserService { public Optional updateAccount(final Account account) { if (account == null) { - LOG.error("User does not exist, returning {}"); + LOG.error("Specified account is null; returning {}"); return Optional.empty(); } @@ -81,7 +173,7 @@ public class UserService { if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to update user {} with id", account.getId()); + LOG.info("Unable to update user with id {}", account.getId()); } return persistenceApiResponse; @@ -95,8 +187,8 @@ public class UserService { public boolean deleteAccount(final Account account) { - if(account == null){ - LOG.error("Username does not exist, returning {}"); + if (account == null){ + LOG.error("Specified account is null; returning {}"); return false; } @@ -107,13 +199,13 @@ public class UserService { final int id = account.getId(); final Instant start = Instant.now(); - try{ + try { - final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl + "/accounts/" + id, + final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl + "accounts/" + id, connectionTimeoutMilliseconds, - socketTimeoutMilliseconds, HttpStatus.NO_CONTENT ); - if(persistenceApiResponse){ - LOG.info("return {}", persistenceApiResponse); + socketTimeoutMilliseconds, HttpStatus.NO_CONTENT); + if (persistenceApiResponse){ + LOG.info("Returning {}", persistenceApiResponse); } else { LOG.info("Unable to delete user {}", account.toString()); @@ -124,7 +216,7 @@ public class UserService { LOG.error("Error deleting user {}", e); return false; } finally { - LOG.info("delete user request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Delete user request took {} ms", Duration.between(start, Instant.now()).toMillis()); } } } diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java index 7f19401..4a478d9 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -8,8 +8,9 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; -import java.text.ParseException; +import java.util.ArrayList; import java.util.Date; +import java.util.List; import java.util.Optional; import static org.junit.Assert.assertEquals; @@ -23,27 +24,65 @@ public class UserServiceTest { @InjectMocks private UserService userService; @Test - public void testCreateNewAccount() throws ParseException { + public void testGetListOfAccounts(){ + final Account account1 = createAccount(); + final Account account2 = createAccount(); + final List accountList = new ArrayList<>(); + accountList.add(account1); + accountList.add(account2); + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenReturn(Optional.of(accountList)); + final Optional response = userService.getListOfAccount(); + + assertTrue(response.isPresent()); + assertEquals(accountList, response.get()); + } + + @Test + public void testGetAccountById(){ final Account account = createAccount(); + account.setId(1); - when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) .thenReturn(Optional.of(account)); - - final Optional response = userService.createNewAccount(account); + final Optional response = userService.getAccountById(1); assertTrue(response.isPresent()); assertEquals(account, response.get()); } @Test - public void testUpdateAccount() throws ParseException { + public void testGetAccountByUsername(){ + final Account account = createAccount(); + final String username = account.getUsername(); + + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenReturn(Optional.of(account)); + final Optional response = userService.getAccountByUsername(username); + + assertTrue(response.isPresent()); + assertEquals(account, response.get()); + } + @Test + public void testCreateAccount(){ + final Account account = createAccount(); + + when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) + .thenReturn(Optional.of(account)); + final Optional response = userService.createAccount(account); + + assertTrue(response.isPresent()); + assertEquals(account, response.get()); + } + + @Test + public void testUpdateAccount(){ final Account account = createAccount(); account.setId(1); when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) .thenReturn(Optional.of(account)); - final Optional response = userService.updateAccount(account); assertTrue(response.isPresent()); @@ -51,14 +90,13 @@ public class UserServiceTest { } @Test - public void testDeleteAccount() throws ParseException { + public void testDeleteAccount(){ final boolean response= true; final Account account = createAccount(); account.setId(1); when(restService.delete(anyString(), anyInt(), anyInt(), any())) .thenReturn(response); - final boolean persistenceApiResponse = userService.deleteAccount(account); assertTrue(persistenceApiResponse ); diff --git a/src/main/java/edu/msudenver/tsp/website/controller/LogInController.java b/src/main/java/edu/msudenver/tsp/website/controller/LogInController.java new file mode 100644 index 0000000..70247ff --- /dev/null +++ b/src/main/java/edu/msudenver/tsp/website/controller/LogInController.java @@ -0,0 +1,35 @@ +package edu.msudenver.tsp.website.controller; + +import edu.msudenver.tsp.website.forms.TheoremForm; +import lombok.AllArgsConstructor; +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.servlet.ModelAndView; + + + @Slf4j + @Controller + @AllArgsConstructor + @RequestMapping("/login") + public class LogInController { + @GetMapping({"/",""}) + public ModelAndView enterTheoremPage() { + LOG.info("Received request to display the theorem entry page: returning model with name 'Theorem'"); + return new ModelAndView("Theorem"); + } + + @PostMapping({"/",""}) + public String saveTheorem(@Validated final TheoremForm theoremForm, final Model model) { + model.addAttribute("theoremName", theoremForm.getTheoremName()); + model.addAttribute("theorem", theoremForm.getTheorem()); + LOG.info("Saving theorem {}...", theoremForm); + + return "success"; + } + } +} From adbcd786f0cd20caca30f4621150678f769730c6 Mon Sep 17 00:00:00 2001 From: dantanxiaotian Date: Tue, 2 Apr 2019 16:38:54 -0600 Subject: [PATCH 52/53] PAN-15 fix the request changes --- .../msudenver/tsp/services/UserService.java | 8 +- .../tsp/services/UserServiceTest.java | 221 +++++++++++++++++- .../website/controller/LogInController.java | 35 --- 3 files changed, 216 insertions(+), 48 deletions(-) delete mode 100644 src/main/java/edu/msudenver/tsp/website/controller/LogInController.java diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index 593b0d9..d5333f0 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -27,7 +27,7 @@ public class UserService { } public Optional getListOfAccount(){ - final String auth = ""; + final String auth = null; final Instant start = Instant.now(); try { @@ -60,7 +60,7 @@ public class UserService { return Optional.empty(); } - final String auth = ""; + final String auth = null; final Instant start = Instant.now(); try { @@ -92,7 +92,7 @@ public class UserService { return Optional.empty(); } - final String auth = ""; + final String auth = null; final Instant start = Instant.now(); try { @@ -208,7 +208,7 @@ public class UserService { LOG.info("Returning {}", persistenceApiResponse); } else { - LOG.info("Unable to delete user {}", account.toString()); + LOG.info("Unable to delete user {}"); } return persistenceApiResponse; diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java index 4a478d9..6debc4a 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -13,10 +13,8 @@ import java.util.Date; import java.util.List; import java.util.Optional; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.mockito.Matchers.*; -import static org.mockito.Mockito.when; +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; @RunWith(MockitoJUnitRunner.class) public class UserServiceTest { @@ -39,10 +37,41 @@ public class UserServiceTest { assertEquals(accountList, response.get()); } + @Test + public void testGetListOfAccounts_persistenceApiResponseIsNotPresent(){ + final Account account1 = createAccount(); + final Account account2 = createAccount(); + final List accountList = new ArrayList<>(); + accountList.add(account1); + accountList.add(account2); + + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenReturn(Optional.empty()); + final Optional response = userService.getListOfAccount(); + + assertFalse(response.isPresent()); + } + + @Test + public void testGetListOfAccounts_catchException(){ + final Account account1 = createAccount(); + final Account account2 = createAccount(); + final List accountList = new ArrayList<>(); + accountList.add(account1); + accountList.add(account2); + final Exception e = new Exception(); + + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenThrow(Exception.class); + final Optional response = userService.getListOfAccount(); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + } + @Test public void testGetAccountById(){ final Account account = createAccount(); - account.setId(1); when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) .thenReturn(Optional.of(account)); @@ -50,20 +79,74 @@ public class UserServiceTest { assertTrue(response.isPresent()); assertEquals(account, response.get()); + verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString()); + } + + @Test + public void testGetAccountById_nullId() { + final Optional response = userService.getAccountById(0); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + verifyZeroInteractions(restService); + } + + @Test + public void testGetAccountById_persistenceApiResponseIsNotPresent(){ + + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenReturn(Optional.empty()); + final Optional response = userService.getAccountById(1); + + assertFalse(response.isPresent()); + verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString()); + } + + @Test + public void testGetAccountById_catchException(){ + + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenThrow(Exception.class); + final Optional response = userService.getAccountById(1); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); } @Test public void testGetAccountByUsername(){ final Account account = createAccount(); - final String username = account.getUsername(); when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) .thenReturn(Optional.of(account)); - final Optional response = userService.getAccountByUsername(username); + final Optional response = userService.getAccountByUsername(account.getUsername()); assertTrue(response.isPresent()); assertEquals(account, response.get()); + verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString()); } + + @Test + public void testGetAccountByUsername_nullUsername(){ + final Optional response = userService.getAccountByUsername(null); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + verifyZeroInteractions(restService); + } + + @Test + public void testGetAccountByUsername_persistenceApiResponseIsNotPresent(){ + final Account account = createAccount(); + + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) + .thenReturn(Optional.empty()); + final Optional response = userService.getAccountByUsername(account.getUsername()); + + assertFalse(response.isPresent()); + verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString()); + } + @Test public void testCreateAccount(){ final Account account = createAccount(); @@ -74,6 +157,27 @@ public class UserServiceTest { assertTrue(response.isPresent()); assertEquals(account, response.get()); + verify(restService).post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + } + + @Test + public void testCreateAccount_NoAccountFound() { + final Optional response = userService.createAccount(null); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + verify(restService, times(0)).post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + } + + @Test + public void testCreateAccount_catchException(){ + final Account account = createAccount(); + + when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenThrow(Exception.class); + final Optional response = userService.createAccount(account); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); } @Test @@ -87,6 +191,54 @@ public class UserServiceTest { assertTrue(response.isPresent()); assertEquals(account, response.get()); + verify(restService).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + } + + @Test + public void testUpdateAccount_nullAccount(){ + final Optional response = userService.updateAccount(null); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + verify(restService, times(0)).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + } + + @Test + public void testUpdateAccount_nullId(){ + final Account account = createAccount(); + account.setId(0); + + final Optional response = userService.updateAccount(account); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + verify(restService, times(0)).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + } + + @Test + public void testUpdateAccount_PersistenceApiResponseIsNotPresent(){ + final Account account = createAccount(); + account.setId(1); + + when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) + .thenReturn(Optional.empty()); + final Optional response = userService.updateAccount(account); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); + } + + @Test + public void testUpdateAccount_catchException(){ + final Account account = createAccount(); + account.setId(1); + + when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) + .thenThrow(Exception.class); + final Optional response = userService.updateAccount(account); + + assertFalse(response.isPresent()); + assertEquals(Optional.empty(), response); } @Test @@ -99,8 +251,59 @@ public class UserServiceTest { .thenReturn(response); final boolean persistenceApiResponse = userService.deleteAccount(account); - assertTrue(persistenceApiResponse ); - assertEquals(response, persistenceApiResponse ); + assertNotNull(persistenceApiResponse); + assertTrue(persistenceApiResponse); + assertEquals(response, persistenceApiResponse); + verify(restService).delete(anyString(), anyInt(), anyInt(), any()); + } + + @Test + public void testDeleteAccount_nullAccount(){ + final boolean persistenceApiResponse = userService.deleteAccount(null); + + assertNotNull(persistenceApiResponse); + assertFalse(persistenceApiResponse); + verify(restService, times(0)).delete(anyString(), anyInt(), anyInt(), any()); + } + + @Test + public void testDeleteAccount_nullId(){ + final Account account = createAccount(); + account.setId(0); + + final boolean persistenceApiResponse = userService.deleteAccount(account); + + assertNotNull(persistenceApiResponse); + assertFalse(persistenceApiResponse); + verify(restService, times(0)).delete(anyString(), anyInt(), anyInt(), any()); + } + + @Test + public void testDeleteAccount_persistenceApiResponseIsNotPresent(){ + final boolean response= false; + final Account account = createAccount(); + account.setId(1); + + when(restService.delete(anyString(), anyInt(), anyInt(), any())) + .thenReturn(response); + final boolean persistenceApiResponse = userService.deleteAccount(account); + + assertNotNull(persistenceApiResponse); + assertFalse(persistenceApiResponse); + assertEquals(response, persistenceApiResponse); + verify(restService).delete(anyString(), anyInt(), anyInt(), any()); + } + + @Test + public void testDeleteAccount_catchException(){ + final Account account = createAccount(); + account.setId(1); + + when(restService.delete(anyString(), anyInt(), anyInt(), any())).thenThrow(Exception.class); + final boolean persistenceApiResponse = userService.deleteAccount(account); + + assertNotNull(persistenceApiResponse); + assertFalse(persistenceApiResponse); } diff --git a/src/main/java/edu/msudenver/tsp/website/controller/LogInController.java b/src/main/java/edu/msudenver/tsp/website/controller/LogInController.java deleted file mode 100644 index 70247ff..0000000 --- a/src/main/java/edu/msudenver/tsp/website/controller/LogInController.java +++ /dev/null @@ -1,35 +0,0 @@ -package edu.msudenver.tsp.website.controller; - -import edu.msudenver.tsp.website.forms.TheoremForm; -import lombok.AllArgsConstructor; -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.servlet.ModelAndView; - - - @Slf4j - @Controller - @AllArgsConstructor - @RequestMapping("/login") - public class LogInController { - @GetMapping({"/",""}) - public ModelAndView enterTheoremPage() { - LOG.info("Received request to display the theorem entry page: returning model with name 'Theorem'"); - return new ModelAndView("Theorem"); - } - - @PostMapping({"/",""}) - public String saveTheorem(@Validated final TheoremForm theoremForm, final Model model) { - model.addAttribute("theoremName", theoremForm.getTheoremName()); - model.addAttribute("theorem", theoremForm.getTheorem()); - LOG.info("Saving theorem {}...", theoremForm); - - return "success"; - } - } -} From 36036b710de0ccc24e3977a11e1f677ce167231a Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 15:18:19 -0600 Subject: [PATCH 53/53] PAN-15 Finished Unit Tests --- .../services/UserServiceIntegrationTest.java | 6 +- .../msudenver/tsp/services/UserService.java | 63 +++--- .../tsp/services/UserServiceTest.java | 209 +++++++++--------- 3 files changed, 136 insertions(+), 142 deletions(-) diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java index b3a547d..be36c25 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -33,14 +33,14 @@ public class UserServiceIntegrationTest { assertEquals("test_password", returnedAccount.getPassword()); assertFalse(returnedAccount.isAdministratorStatus()); - final Optional getAccountById = userService.getAccountById(returnedAccount.getId()); + final Optional getAccountById = userService.findAccountById(returnedAccount.getId()); assertTrue(getAccountById.isPresent()); final Account returnedAccountById = getAccountById.get(); assertEquals("test_user", returnedAccountById.getUsername()); assertEquals("test_password", returnedAccountById.getPassword()); assertFalse(returnedAccountById.isAdministratorStatus()); - final Optional getAccountByUsername = userService.getAccountByUsername(returnedAccount.getUsername()); + final Optional getAccountByUsername = userService.findAccountByUsername(returnedAccount.getUsername()); assertTrue(getAccountByUsername.isPresent()); final Account returnedAccountByUsername = getAccountByUsername.get(); assertEquals("test_user", returnedAccountByUsername.getUsername()); @@ -61,7 +61,7 @@ public class UserServiceIntegrationTest { assertTrue(result); } - private Account createAccount(){ + private Account createAccount() { final Account testAccount = new Account(); testAccount.setUsername("test_user"); testAccount.setPassword("test_password"); diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index d5333f0..3125824 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -11,6 +11,7 @@ import org.springframework.stereotype.Service; import java.time.Duration; import java.time.Instant; +import java.util.List; import java.util.Optional; @Slf4j @@ -26,95 +27,92 @@ public class UserService { this.restService = restService; } - public Optional getListOfAccount(){ - final String auth = null; + public Optional> getListOfAccounts() { final Instant start = Instant.now(); try { - final TypeToken typeToken = new TypeToken() {}; - final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/", + final TypeToken> typeToken = new TypeToken>() {}; + final Optional> persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/", typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, - auth); + null); if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to get the list of accounts"); + LOG.warn("Unable to get the list of accounts"); } return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error getting the list of accounts {}", e); + LOG.error("Error getting the list of accounts", e); return Optional.empty(); } finally { - LOG.info("Getting the list of accounts request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Get the list of accounts request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } - public Optional getAccountById(final int id) { + public Optional findAccountById(final int id) { if (id == 0) { LOG.error("No user ID specified! Returning {}"); return Optional.empty(); } - final String auth = null; final Instant start = Instant.now(); try { final TypeToken typeToken = new TypeToken() {}; - final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/id?id="+id, + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/id?id=" + id, typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, - auth); + null); if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to find account with id {}", id); + LOG.warn("Unable to find account with id {}", id); } return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error getting account by id {}", e); + LOG.error("Error finding account by id", e); return Optional.empty(); } finally { - LOG.info("Getting account by ID request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Find account by ID request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } - public Optional getAccountByUsername(final String username) { + public Optional findAccountByUsername(final String username) { if (username == null) { LOG.error("No username specified! Returning {}"); return Optional.empty(); } - final String auth = null; final Instant start = Instant.now(); try { final TypeToken typeToken = new TypeToken() {}; - final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/username?username="+username, + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/username?username=" + username, typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, - auth); + null); if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to GET account with username{}", username); + LOG.warn("Unable to GET account with username {}", username); } return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error getting account by username {}", e); + LOG.error("Error finding account by username", e); return Optional.empty(); } finally { - LOG.info("Getting account by username request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Find account by username request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } @@ -136,15 +134,15 @@ public class UserService { if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to create new account {}", account.toString()); + LOG.warn("Unable to create new account {}", account.toString()); } return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error creating new account {}", 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()); + LOG.info("Create new account request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } @@ -173,15 +171,15 @@ public class UserService { if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to update user with id {}", account.getId()); + LOG.warn("Unable to update user with id {}", account.getId()); } return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error updating user {}", e); + LOG.error("Error updating user", e); return Optional.empty(); } finally { - LOG.info("Update user request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Update user request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } @@ -196,6 +194,7 @@ public class UserService { LOG.error("No user ID specified! Returning {}"); return false; } + final int id = account.getId(); final Instant start = Instant.now(); @@ -204,19 +203,19 @@ public class UserService { final boolean persistenceApiResponse = restService.delete(persistenceApiBaseUrl + "accounts/" + id, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, HttpStatus.NO_CONTENT); - if (persistenceApiResponse){ + if (persistenceApiResponse) { LOG.info("Returning {}", persistenceApiResponse); } else { - LOG.info("Unable to delete user {}"); + LOG.error("Unable to delete user {}", account); } return persistenceApiResponse; }catch (final Exception e) { - LOG.error("Error deleting user {}", e); + LOG.error("Error deleting user", e); return false; } finally { - LOG.info("Delete user request took {} ms", Duration.between(start, Instant.now()).toMillis()); + LOG.info("Delete user request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } } diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java index 6debc4a..1d42311 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -22,60 +22,47 @@ public class UserServiceTest { @InjectMocks private UserService userService; @Test - public void testGetListOfAccounts(){ - final Account account1 = createAccount(); - final Account account2 = createAccount(); + public void testGetListOfAccounts() { final List accountList = new ArrayList<>(); - accountList.add(account1); - accountList.add(account2); + accountList.add(createAccount()); + accountList.add(createAccount()); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenReturn(Optional.of(accountList)); - final Optional response = userService.getListOfAccount(); + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(), anyString())).thenReturn(Optional.of(accountList)); + + final Optional> response = userService.getListOfAccounts(); assertTrue(response.isPresent()); assertEquals(accountList, response.get()); + verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString()); } @Test - public void testGetListOfAccounts_persistenceApiResponseIsNotPresent(){ - final Account account1 = createAccount(); - final Account account2 = createAccount(); - final List accountList = new ArrayList<>(); - accountList.add(account1); - accountList.add(account2); + public void testGetListOfAccounts_PersistenceApiResponseIsEmpty() { + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.empty()); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenReturn(Optional.empty()); - final Optional response = userService.getListOfAccount(); + final Optional> response = userService.getListOfAccounts(); assertFalse(response.isPresent()); + verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString()); } @Test - public void testGetListOfAccounts_catchException(){ - final Account account1 = createAccount(); - final Account account2 = createAccount(); - final List accountList = new ArrayList<>(); - accountList.add(account1); - accountList.add(account2); - final Exception e = new Exception(); + public void testGetListOfAccounts_RestServiceThrowsException() { + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenThrow(Exception.class); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenThrow(Exception.class); - final Optional response = userService.getListOfAccount(); + final Optional> response = userService.getListOfAccounts(); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); + verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString()); } @Test - public void testGetAccountById(){ + public void testFindAccountById() { final Account account = createAccount(); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenReturn(Optional.of(account)); - final Optional response = userService.getAccountById(1); + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.of(account)); + + final Optional response = userService.findAccountById(1); assertTrue(response.isPresent()); assertEquals(account, response.get()); @@ -83,8 +70,8 @@ public class UserServiceTest { } @Test - public void testGetAccountById_nullId() { - final Optional response = userService.getAccountById(0); + public void testFindAccountById_IdEqualsZero() { + final Optional response = userService.findAccountById(0); assertFalse(response.isPresent()); assertEquals(Optional.empty(), response); @@ -92,34 +79,32 @@ public class UserServiceTest { } @Test - public void testGetAccountById_persistenceApiResponseIsNotPresent(){ + public void testFindAccountById_PersistenceApiResponseIsEmpty() { + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.empty()); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenReturn(Optional.empty()); - final Optional response = userService.getAccountById(1); + final Optional response = userService.findAccountById(1); assertFalse(response.isPresent()); verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString()); } @Test - public void testGetAccountById_catchException(){ + public void testFindAccountById_RestServiceThrowsException() { + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenThrow(Exception.class); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenThrow(Exception.class); - final Optional response = userService.getAccountById(1); + final Optional response = userService.findAccountById(1); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); + verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString()); } @Test - public void testGetAccountByUsername(){ + public void testFindAccountByUsername() { final Account account = createAccount(); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenReturn(Optional.of(account)); - final Optional response = userService.getAccountByUsername(account.getUsername()); + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.of(account)); + + final Optional response = userService.findAccountByUsername(account.getUsername()); assertTrue(response.isPresent()); assertEquals(account, response.get()); @@ -127,8 +112,8 @@ public class UserServiceTest { } @Test - public void testGetAccountByUsername_nullUsername(){ - final Optional response = userService.getAccountByUsername(null); + public void testFindAccountByUsername_NullUsername() { + final Optional response = userService.findAccountByUsername(null); assertFalse(response.isPresent()); assertEquals(Optional.empty(), response); @@ -136,23 +121,33 @@ public class UserServiceTest { } @Test - public void testGetAccountByUsername_persistenceApiResponseIsNotPresent(){ + public void testFindAccountByUsername_PersistenceApiResponseIsEmpty() { final Account account = createAccount(); - when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())) - .thenReturn(Optional.empty()); - final Optional response = userService.getAccountByUsername(account.getUsername()); + when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.empty()); + + final Optional response = userService.findAccountByUsername(account.getUsername()); assertFalse(response.isPresent()); verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString()); } @Test - public void testCreateAccount(){ + public void testFindAccountByUsername_RestServiceThrowsException() { + when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())).thenThrow(Exception.class); + + final Optional response = userService.findAccountByUsername("test"); + + assertFalse(response.isPresent()); + verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString()); + } + + @Test + public void testCreateAccount() { final Account account = createAccount(); - when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) - .thenReturn(Optional.of(account)); + when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenReturn(Optional.of(account)); + final Optional response = userService.createAccount(account); assertTrue(response.isPresent()); @@ -161,7 +156,7 @@ public class UserServiceTest { } @Test - public void testCreateAccount_NoAccountFound() { + public void testCreateAccount_NullAccount() { final Optional response = userService.createAccount(null); assertFalse(response.isPresent()); @@ -170,23 +165,32 @@ public class UserServiceTest { } @Test - public void testCreateAccount_catchException(){ - final Account account = createAccount(); + public void testCreateAccount_AccountCouldNotBeCreated() { + when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenReturn(Optional.empty()); - when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenThrow(Exception.class); - final Optional response = userService.createAccount(account); + final Optional response = userService.createAccount(createAccount()); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); + verify(restService).post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); } @Test - public void testUpdateAccount(){ + public void testCreateAccount_RestServiceThrowsException() { + when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenThrow(Exception.class); + + final Optional response = userService.createAccount(createAccount()); + + assertFalse(response.isPresent()); + verify(restService).post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + } + + @Test + public void testUpdateAccount() { final Account account = createAccount(); account.setId(1); - when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) - .thenReturn(Optional.of(account)); + when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenReturn(Optional.of(account)); + final Optional response = userService.updateAccount(account); assertTrue(response.isPresent()); @@ -195,115 +199,106 @@ public class UserServiceTest { } @Test - public void testUpdateAccount_nullAccount(){ + public void testUpdateAccount_NullAccount() { final Optional response = userService.updateAccount(null); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); - verify(restService, times(0)).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + verifyZeroInteractions(restService); } @Test - public void testUpdateAccount_nullId(){ + public void testUpdateAccount_IdEqualsZero() { final Account account = createAccount(); account.setId(0); final Optional response = userService.updateAccount(account); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); - verify(restService, times(0)).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); + verifyZeroInteractions(restService); } @Test - public void testUpdateAccount_PersistenceApiResponseIsNotPresent(){ + public void testUpdateAccount_PersistenceApiResponseIsEmpty() { final Account account = createAccount(); account.setId(1); - when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) - .thenReturn(Optional.empty()); + when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenReturn(Optional.empty()); + final Optional response = userService.updateAccount(account); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); + verify(restService).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); } @Test - public void testUpdateAccount_catchException(){ + public void testUpdateAccount_RestServiceThrowsException() { final Account account = createAccount(); account.setId(1); - when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())) - .thenThrow(Exception.class); + when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenThrow(Exception.class); + final Optional response = userService.updateAccount(account); assertFalse(response.isPresent()); - assertEquals(Optional.empty(), response); + verify(restService).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt()); } @Test - public void testDeleteAccount(){ - final boolean response= true; + public void testDeleteAccount() { final Account account = createAccount(); account.setId(1); - when(restService.delete(anyString(), anyInt(), anyInt(), any())) - .thenReturn(response); - final boolean persistenceApiResponse = userService.deleteAccount(account); + when(restService.delete(anyString(), anyInt(), anyInt(), any())).thenReturn(true); - assertNotNull(persistenceApiResponse); - assertTrue(persistenceApiResponse); - assertEquals(response, persistenceApiResponse); + final boolean isDeleteSuccessful = userService.deleteAccount(account); + + assertTrue(isDeleteSuccessful); verify(restService).delete(anyString(), anyInt(), anyInt(), any()); } @Test - public void testDeleteAccount_nullAccount(){ - final boolean persistenceApiResponse = userService.deleteAccount(null); + public void testDeleteAccount_NullAccount() { + final boolean isDeleteSuccessful = userService.deleteAccount(null); - assertNotNull(persistenceApiResponse); - assertFalse(persistenceApiResponse); - verify(restService, times(0)).delete(anyString(), anyInt(), anyInt(), any()); + assertFalse(isDeleteSuccessful); + verifyZeroInteractions(restService); } @Test - public void testDeleteAccount_nullId(){ + public void testDeleteAccount_IdEqualsZero() { final Account account = createAccount(); account.setId(0); - final boolean persistenceApiResponse = userService.deleteAccount(account); + final boolean isDeleteSuccessful = userService.deleteAccount(account); - assertNotNull(persistenceApiResponse); - assertFalse(persistenceApiResponse); - verify(restService, times(0)).delete(anyString(), anyInt(), anyInt(), any()); + assertFalse(isDeleteSuccessful); + verifyZeroInteractions(restService); } @Test - public void testDeleteAccount_persistenceApiResponseIsNotPresent(){ - final boolean response= false; + public void testDeleteAccount_PersistenceApiResponseIsEmpty() { final Account account = createAccount(); account.setId(1); - when(restService.delete(anyString(), anyInt(), anyInt(), any())) - .thenReturn(response); - final boolean persistenceApiResponse = userService.deleteAccount(account); + when(restService.delete(anyString(), anyInt(), anyInt(), any())).thenReturn(false); - assertNotNull(persistenceApiResponse); - assertFalse(persistenceApiResponse); - assertEquals(response, persistenceApiResponse); + final boolean isDeleteSuccessful = userService.deleteAccount(account); + + assertFalse(isDeleteSuccessful); verify(restService).delete(anyString(), anyInt(), anyInt(), any()); } @Test - public void testDeleteAccount_catchException(){ + public void testDeleteAccount_RestServiceThrowsException() { final Account account = createAccount(); account.setId(1); when(restService.delete(anyString(), anyInt(), anyInt(), any())).thenThrow(Exception.class); + final boolean persistenceApiResponse = userService.deleteAccount(account); - assertNotNull(persistenceApiResponse); assertFalse(persistenceApiResponse); + verify(restService).delete(anyString(), anyInt(), anyInt(), any()); }