From 3853911b3c54cb5790e0979a1a35303e78e17225 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 21:09:07 -0600 Subject: [PATCH 01/17] PAN-11 corrected build.gradle inter-project dependencies --- services/build.gradle | 4 +- .../DefinitionServiceIntegrationTest.java | 55 ++++++++++++ .../tsp/services/ServiceTestConfig.java | 21 +++++ .../integrationTest/resources/test.properties | 3 + .../tsp/services/DefinitionService.java | 59 +++++++++++++ .../msudenver/tsp/services/ServiceConfig.java | 9 ++ .../tsp/services/dto/Definition.java | 24 ++++++ .../tsp/services/DefinitionServiceTest.java | 86 +++++++++++++++++++ 8 files changed, 260 insertions(+), 1 deletion(-) create mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java create mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java create mode 100644 services/src/integrationTest/resources/test.properties create mode 100644 services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java create mode 100644 services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java create mode 100644 services/src/main/java/edu/msudenver/tsp/services/dto/Definition.java create mode 100644 services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java diff --git a/services/build.gradle b/services/build.gradle index 551f2b2..2d22968 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -18,12 +18,14 @@ 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: 'com.google.code.gson', name: 'gson', version: '2.7' + compile group: 'org.springframework.boot', name: 'spring-boot-devtools', version: '2.0.5.RELEASE' + compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' compile fileTree(dir: 'lib', include: '**/*.jar') testCompile "org.springframework:spring-test:5.0.9.RELEASE" + testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.2.RELEASE' testCompile group: 'junit', name: 'junit', version: '4.12' } diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java new file mode 100644 index 0000000..f7e2d59 --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java @@ -0,0 +1,55 @@ +package edu.msudenver.tsp.services; + +import edu.msudenver.tsp.services.dto.Definition; +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.SpringRunner; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.*; +import static org.mockito.AdditionalMatchers.not; + +@RunWith(SpringRunner.class) +@ContextConfiguration(classes = ServiceTestConfig.class) +public class DefinitionServiceIntegrationTest { + @Autowired private DefinitionService definitionService; + + @Test + public void testCreateNewDefinition() { + final Definition testDefinition = createDefinition(); + final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + + assertNotNull(createdDefinition); + assertTrue(createdDefinition.isPresent()); + assertThat(createdDefinition.get().getId(), is(not(0))); + assertThat(createdDefinition.get().getVersion(), is(0)); + assertThat(createdDefinition.get().getName(), is("Test Name")); + assertNotNull(createdDefinition.get().getDefinition()); + assertThat(createdDefinition.get().getDefinition().size(), is(1)); + assertThat(createdDefinition.get().getDefinition().get(0), is("Test definition 1")); + assertNotNull(createdDefinition.get().getNotation()); + assertThat(createdDefinition.get().getNotation().size(), is(1)); + assertThat(createdDefinition.get().getNotation().get(0), is("\\testLaTeX")); + } + + private Definition createDefinition() { + final List definitionList = new ArrayList<>(); + definitionList.add("Test definition 1"); + + final List notationList = new ArrayList<>(); + notationList.add("\\testLaTeX"); + + final Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); + + return definition; + } +} diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java new file mode 100644 index 0000000..724e5c8 --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java @@ -0,0 +1,21 @@ +package edu.msudenver.tsp.services; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.TestPropertySource; + +@Configuration +@ComponentScan +@EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class) +@TestPropertySource("classpath:test.properties") +public class ServiceTestConfig { + + @Bean + @Autowired public DefinitionService definitionService(final RestService restService) { + return new DefinitionService(restService); + } +} diff --git a/services/src/integrationTest/resources/test.properties b/services/src/integrationTest/resources/test.properties new file mode 100644 index 0000000..ff86c7e --- /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/ \ No newline at end of file diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java new file mode 100644 index 0000000..425d329 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -0,0 +1,59 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.GsonBuilder; +import com.google.gson.reflect.TypeToken; +import edu.msudenver.tsp.services.dto.Definition; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.PropertySource; +import org.springframework.stereotype.Service; + +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; + +@Slf4j +@Service +@PropertySource(value = "classpath:application.properties", ignoreResourceNotFound = true) +public class DefinitionService { + private final RestService restService; + @Value("${persistence.api.connection.timeout.milliseconds}") private int connectionTimeoutMilliseconds; + @Value("${persistence.api.socket.timeout.milliseconds}") private int socketTimeoutMilliseconds; + @Value("${persistence.api.base.url}") private String persistenceApiBaseUrl; + + @Autowired + public DefinitionService(final RestService restService) { + this.restService = restService; + } + + public Optional createNewDefinition(final Definition definition) { + if (definition == null) { + LOG.error("Given null definition, returning {}"); + return Optional.empty(); + } + final Instant start = Instant.now(); + + try { + final TypeToken definitionTypeToken = new TypeToken() {}; + final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/", + new GsonBuilder().create().toJson(definition), + definitionTypeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if(persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to create new definition {}", definition.toString()); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error creating new definition {}", e); + return Optional.empty(); + } finally { + LOG.info("Create new definition request took {}ms", Duration.between(start, Instant.now()).toMillis()); + } + } +} 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..b80e2da --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java @@ -0,0 +1,9 @@ +package edu.msudenver.tsp.services; + +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.context.annotation.Configuration; + +@Configuration +@EnableAutoConfiguration +public class ServiceConfig { +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/dto/Definition.java b/services/src/main/java/edu/msudenver/tsp/services/dto/Definition.java new file mode 100644 index 0000000..a208e83 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/dto/Definition.java @@ -0,0 +1,24 @@ +package edu.msudenver.tsp.services.dto; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.List; + +@Data +@EqualsAndHashCode(callSuper = true) +public class Definition extends BaseDto implements Serializable { + @NotBlank(groups = Insert.class, message = "A name must be specified") + @Size(min = 1, max = 200, message = "Must be between 1 and 200 characters") + private String name; + @NotBlank(groups = Insert.class, message = "At least one (1) definition must be specified") + private List definition; + private List notation; + + private static final long serialVersionUID = 3412178112996807691L; + + public interface Insert {} +} diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java new file mode 100644 index 0000000..b712ccd --- /dev/null +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -0,0 +1,86 @@ +package edu.msudenver.tsp.services; + +import com.google.gson.GsonBuilder; +import edu.msudenver.tsp.services.dto.Definition; +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; +import java.util.List; +import java.util.Optional; + +import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.*; +import static org.mockito.Matchers.*; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class DefinitionServiceTest { + @Mock private RestService restService; + @InjectMocks private DefinitionService definitionService; + + @Test + public void testCreateNewDefinition() { + final Definition testDefinition = createDefinition(); + final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); + + when(restService.post(anyString(), anyString(), any(), anyInt(), anyInt())) + .thenReturn(Optional.of(testDefinition)); + + final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + + assertNotNull(createdDefinition); + assertTrue(createdDefinition.isPresent()); + assertEquals(testDefinition, createdDefinition.get()); + verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt()); + } + + @Test + public void testCreateNewDefinition_unableToCreateNewDefinition() { + final Definition testDefinition = createDefinition(); + final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); + + when(restService.post(anyString(), anyString(), any(), anyInt(), anyInt())) + .thenReturn(Optional.empty()); + + final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + + assertNotNull(createdDefinition); + assertFalse(createdDefinition.isPresent()); + verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt()); + } + + @Test + public void testCreateNewDefinition_restServiceThrowsException() { + final Definition testDefinition = createDefinition(); + final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); + + when(restService.post(anyString(), anyString(), any(), anyInt(), anyInt())) + .thenThrow(new UnsupportedOperationException("test exception")); + + final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + + assertNotNull(createdDefinition); + assertFalse(createdDefinition.isPresent()); + verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt()); + } + + private Definition createDefinition() { + final List definitionList = new ArrayList<>(); + definitionList.add("Test definition 1"); + + final List notationList = new ArrayList<>(); + notationList.add("\\testLaTeX"); + + final Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); + + return definition; + } +} \ No newline at end of file From b48094ba26642e359232e1f924fd074a8b947ad5 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 17 Mar 2019 22:02:00 -0600 Subject: [PATCH 02/17] PAN-11 Stuck trying to get the integration tests to be configured correctly --- .../tsp/services/DefinitionServiceIntegrationTest.java | 2 ++ .../edu/msudenver/tsp/services/ServiceTestConfig.java | 9 ++++----- .../edu/msudenver/tsp/services/DefinitionService.java | 2 -- .../java/edu/msudenver/tsp/services/dto/Account.java | 9 ++++----- 4 files changed, 10 insertions(+), 12 deletions(-) diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java index f7e2d59..3e4bc99 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java @@ -5,6 +5,7 @@ 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.TestPropertySource; import org.springframework.test.context.junit4.SpringRunner; import java.util.ArrayList; @@ -17,6 +18,7 @@ import static org.mockito.AdditionalMatchers.not; @RunWith(SpringRunner.class) @ContextConfiguration(classes = ServiceTestConfig.class) +@TestPropertySource(locations = "classpath:test.properties") public class DefinitionServiceIntegrationTest { @Autowired private DefinitionService definitionService; diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java index 724e5c8..93ae8e1 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java @@ -1,17 +1,16 @@ package edu.msudenver.tsp.services; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.CommandLineRunner; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; -import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; -import org.springframework.test.context.TestPropertySource; +import org.springframework.context.annotation.FilterType; @Configuration -@ComponentScan -@EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class) -@TestPropertySource("classpath:test.properties") +@ComponentScan(excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = CommandLineRunner.class)) +@EnableAutoConfiguration public class ServiceTestConfig { @Bean diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index 425d329..23b177a 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -6,7 +6,6 @@ import edu.msudenver.tsp.services.dto.Definition; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; -import org.springframework.context.annotation.PropertySource; import org.springframework.stereotype.Service; import java.time.Duration; @@ -15,7 +14,6 @@ import java.util.Optional; @Slf4j @Service -@PropertySource(value = "classpath:application.properties", ignoreResourceNotFound = true) public class DefinitionService { private final RestService restService; @Value("${persistence.api.connection.timeout.milliseconds}") private int connectionTimeoutMilliseconds; 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 139cd41..99ca0cd 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 @@ -4,8 +4,6 @@ import com.google.gson.annotations.SerializedName; import lombok.Data; import lombok.EqualsAndHashCode; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; @@ -15,11 +13,12 @@ import java.util.Date; @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; + @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 @SerializedName("administrator_status") private boolean administratorStatus; - @Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin; + @SerializedName("last_login") private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; + public interface Insert {} } From 978b58fe2cf5991ebb5ce6b2f1465d2705ca3519 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 20:48:25 -0600 Subject: [PATCH 03/17] PAN-11 wrote the GetAllDefinitions() method --- .../scripts/mysql/local_development.sql | 23 ++++++------ .../persistence/ProofsIntegrationTest.java | 3 +- .../DefinitionServiceIntegrationTest.java | 8 ++--- .../tsp/services/ServiceTestConfig.java | 9 ++--- .../tsp/services/DefinitionService.java | 35 ++++++++++++++++--- .../tsp/services/DefinitionServiceTest.java | 12 +++---- 6 files changed, 56 insertions(+), 34 deletions(-) diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index 27005d4..fbd9dac 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -34,17 +34,16 @@ referenced_theorems json, proven_status boolean default false, version int default 1 ); -CREATE TABLE proofs +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, - referenced_definitions JSON, - referenced_theorems JSON, - date_added DATE, - last_updated DATE, - version INT DEFAULT 1, - PRIMARY KEY (id) + id int not null auto_increment primary key unique, + theorem_name varchar(512) not null, + proof varchar(4096) not null, + branch varchar(512) not null, + theorem int not null, + referenced_definitions json, + referenced_theorems json, + date_added date, + last_updated date, + version int default 1 ); \ No newline at end of file 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 b18c47d..9fa7edb 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/ProofsIntegrationTest.java @@ -18,8 +18,7 @@ import static org.junit.Assert.*; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = PersistenceTestConfig.class) public class ProofsIntegrationTest { - @Autowired - private ProofRepository proofRepository; + @Autowired private ProofRepository proofRepository; @Test public void testCRUDFunctionality() { diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java index 3e4bc99..7f424e3 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java @@ -6,7 +6,7 @@ import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestPropertySource; -import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import java.util.ArrayList; import java.util.List; @@ -16,16 +16,16 @@ import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.*; import static org.mockito.AdditionalMatchers.not; -@RunWith(SpringRunner.class) +@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = ServiceTestConfig.class) @TestPropertySource(locations = "classpath:test.properties") public class DefinitionServiceIntegrationTest { @Autowired private DefinitionService definitionService; @Test - public void testCreateNewDefinition() { + public void testCreateDefinition() { final Definition testDefinition = createDefinition(); - final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + final Optional createdDefinition = definitionService.createDefinition(testDefinition); assertNotNull(createdDefinition); assertTrue(createdDefinition.isPresent()); diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java index 93ae8e1..1d9d54e 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java @@ -1,20 +1,17 @@ package edu.msudenver.tsp.services; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.CommandLineRunner; -import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; -import org.springframework.context.annotation.FilterType; @Configuration -@ComponentScan(excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = CommandLineRunner.class)) -@EnableAutoConfiguration +@ComponentScan public class ServiceTestConfig { @Bean - @Autowired public DefinitionService definitionService(final RestService restService) { + @Autowired + public DefinitionService definitionService(final RestService restService) { return new DefinitionService(restService); } } diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index 23b177a..f4bd91a 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -10,6 +10,7 @@ import org.springframework.stereotype.Service; import java.time.Duration; import java.time.Instant; +import java.util.List; import java.util.Optional; @Slf4j @@ -25,25 +26,51 @@ public class DefinitionService { this.restService = restService; } - public Optional createNewDefinition(final Definition definition) { + public Optional> getAllDefinitions() { + final Instant start = Instant.now(); + + try { + final TypeToken> typeToken = new TypeToken>(){}; + final Optional> persistenceApiResponse = + restService.get(persistenceApiBaseUrl + "definitions/", + typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, null); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to get list of definitions"); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error getting list of definitions! {}", e); + return Optional.empty(); + } finally { + LOG.info("Get all definitions request took {}ms", Duration.between(start, Instant.now()).toMillis()); + } + } + + public Optional createDefinition(final Definition definition) { if (definition == null) { LOG.error("Given null definition, returning {}"); return Optional.empty(); } + + LOG.info("Sending request to insert definition {}", definition); final Instant start = Instant.now(); try { final TypeToken definitionTypeToken = new TypeToken() {}; - final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/", + final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "definitions/", new GsonBuilder().create().toJson(definition), definitionTypeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds); - if(persistenceApiResponse.isPresent()) { + if (persistenceApiResponse.isPresent()) { LOG.info("Returning {}", persistenceApiResponse.get()); } else { - LOG.info("Unable to create new definition {}", definition.toString()); + LOG.info("Unable to create new definition {}", definition); } return persistenceApiResponse; diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index b712ccd..673affd 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -24,14 +24,14 @@ public class DefinitionServiceTest { @InjectMocks private DefinitionService definitionService; @Test - public void testCreateNewDefinition() { + public void testCreateDefinition() { final Definition testDefinition = createDefinition(); final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); when(restService.post(anyString(), anyString(), any(), anyInt(), anyInt())) .thenReturn(Optional.of(testDefinition)); - final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + final Optional createdDefinition = definitionService.createDefinition(testDefinition); assertNotNull(createdDefinition); assertTrue(createdDefinition.isPresent()); @@ -40,14 +40,14 @@ public class DefinitionServiceTest { } @Test - public void testCreateNewDefinition_unableToCreateNewDefinition() { + public void testCreateDefinition_unableToCreateDefinition() { final Definition testDefinition = createDefinition(); final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); when(restService.post(anyString(), anyString(), any(), anyInt(), anyInt())) .thenReturn(Optional.empty()); - final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + final Optional createdDefinition = definitionService.createDefinition(testDefinition); assertNotNull(createdDefinition); assertFalse(createdDefinition.isPresent()); @@ -55,14 +55,14 @@ public class DefinitionServiceTest { } @Test - public void testCreateNewDefinition_restServiceThrowsException() { + public void testCreateDefinition_restServiceThrowsException() { final Definition testDefinition = createDefinition(); final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); when(restService.post(anyString(), anyString(), any(), anyInt(), anyInt())) .thenThrow(new UnsupportedOperationException("test exception")); - final Optional createdDefinition = definitionService.createNewDefinition(testDefinition); + final Optional createdDefinition = definitionService.createDefinition(testDefinition); assertNotNull(createdDefinition); assertFalse(createdDefinition.isPresent()); From 92bea81ae5ac0f3b0a247d3ababd9a0baafff7f5 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 21:23:03 -0600 Subject: [PATCH 04/17] PAN-11 Wrote unit tests for getAllDefinitions() --- .../msudenver/tsp/services/ServiceConfig.java | 7 +++- .../tsp/services/DefinitionServiceTest.java | 40 +++++++++++++++++++ 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java index b80e2da..db65cc6 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java +++ b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java @@ -1,9 +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 +@EnableAutoConfiguration(exclude = {DevToolsDataSourceAutoConfiguration.class, + HibernateJpaAutoConfiguration.class, + DataSourceAutoConfiguration.class}) public class ServiceConfig { } diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index 673affd..23cd626 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -1,6 +1,7 @@ package edu.msudenver.tsp.services; import com.google.gson.GsonBuilder; +import com.google.gson.reflect.TypeToken; import edu.msudenver.tsp.services.dto.Definition; import org.junit.Test; import org.junit.runner.RunWith; @@ -13,6 +14,8 @@ import java.util.List; import java.util.Optional; import static junit.framework.TestCase.assertTrue; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; import static org.junit.Assert.*; import static org.mockito.Matchers.*; import static org.mockito.Mockito.verify; @@ -23,6 +26,43 @@ public class DefinitionServiceTest { @Mock private RestService restService; @InjectMocks private DefinitionService definitionService; + @Test + public void testGetAllDefinitions() { + final List definitionList = new ArrayList<>(); + final Definition testDefinition = createDefinition(); + definitionList.add(testDefinition); + definitionList.add(testDefinition); + + when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())) + .thenReturn(Optional.of(definitionList)); + + final Optional> listOfDefinitions = definitionService.getAllDefinitions(); + + assertTrue(listOfDefinitions.isPresent()); + assertThat(listOfDefinitions.get().size(), is(2)); + listOfDefinitions.get().forEach(definition -> assertThat(definition, equalTo(testDefinition))); + } + + @Test + public void testGetAllDefinitions_ReturnsEmptyOptional() { + when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())) + .thenReturn(Optional.empty()); + + final Optional> listOfDefinitions = definitionService.getAllDefinitions(); + + assertFalse(listOfDefinitions.isPresent()); + } + + @Test + public void testGetAllDefinitions_ExceptionThrown() { + when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())) + .thenThrow(new UnsupportedOperationException("Test exception")); + + final Optional> listOfDefinitions = definitionService.getAllDefinitions(); + + assertFalse(listOfDefinitions.isPresent()); + } + @Test public void testCreateDefinition() { final Definition testDefinition = createDefinition(); From bc0d631e6c4c496fb97baac10ba1fe31517f987a Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 21:29:49 -0600 Subject: [PATCH 05/17] PAN-11 Wrote the findById method --- .../tsp/services/DefinitionService.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index f4bd91a..7279ccd 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -50,6 +50,35 @@ public class DefinitionService { } } + public Optional findById(final int id) { + if (id == 0) { + LOG.error("Null id specified; returning {}"); + return Optional.empty(); + } + + LOG.info("Sending request to find definition by id {}", id); + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken(){}; + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "/" + id, + typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, null); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.info("Unable to find definition with id {}", id); + } + + return persistenceApiResponse; + } catch (final Exception e) { + LOG.error("Error finding definition by id", e); + return Optional.empty(); + } finally { + LOG.info("Find by id request took {}ms", Duration.between(start, Instant.now()).toMillis()); + } + } + public Optional createDefinition(final Definition definition) { if (definition == null) { LOG.error("Given null definition, returning {}"); From ae88fd356d607878b192ce1ae535b7ef42479bf8 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 21:41:16 -0600 Subject: [PATCH 06/17] PAN-11 Wrote unit tests for the findById method --- .../tsp/services/DefinitionServiceTest.java | 60 ++++++++++++++++--- 1 file changed, 53 insertions(+), 7 deletions(-) diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index 23cd626..0631854 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -1,7 +1,6 @@ package edu.msudenver.tsp.services; import com.google.gson.GsonBuilder; -import com.google.gson.reflect.TypeToken; import edu.msudenver.tsp.services.dto.Definition; import org.junit.Test; import org.junit.runner.RunWith; @@ -18,8 +17,7 @@ import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.is; import static org.junit.Assert.*; import static org.mockito.Matchers.*; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; +import static org.mockito.Mockito.*; @RunWith(MockitoJUnitRunner.class) public class DefinitionServiceTest { @@ -33,7 +31,7 @@ public class DefinitionServiceTest { definitionList.add(testDefinition); definitionList.add(testDefinition); - when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())) + when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) .thenReturn(Optional.of(definitionList)); final Optional> listOfDefinitions = definitionService.getAllDefinitions(); @@ -41,26 +39,73 @@ public class DefinitionServiceTest { assertTrue(listOfDefinitions.isPresent()); assertThat(listOfDefinitions.get().size(), is(2)); listOfDefinitions.get().forEach(definition -> assertThat(definition, equalTo(testDefinition))); + verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString()); } @Test public void testGetAllDefinitions_ReturnsEmptyOptional() { - when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())) + when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) .thenReturn(Optional.empty()); final Optional> listOfDefinitions = definitionService.getAllDefinitions(); assertFalse(listOfDefinitions.isPresent()); + verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString()); } @Test - public void testGetAllDefinitions_ExceptionThrown() { - when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())) + public void testGetAllDefinitions_ExceptionThrownWhenSendingRequest() { + when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) .thenThrow(new UnsupportedOperationException("Test exception")); final Optional> listOfDefinitions = definitionService.getAllDefinitions(); assertFalse(listOfDefinitions.isPresent()); + verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString()); + } + + @Test + public void testFindById() { + final Definition testDefinition = createDefinition(); + when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) + .thenReturn(Optional.of(testDefinition)); + + final Optional foundDefinition = definitionService.findById(testDefinition.getId()); + + assertTrue(foundDefinition.isPresent()); + assertThat(foundDefinition.get().getId(), is(1)); + assertThat(foundDefinition.get(), is(equalTo(testDefinition))); + verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString()); + } + + @Test + public void testFindById_ReturnsEmptyOptional() { + when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) + .thenReturn(Optional.empty()); + + final Optional nonExistentDefinition = definitionService.findById(1); + + assertFalse(nonExistentDefinition.isPresent()); + verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString()); + } + + @Test + public void testFindById_ExceptionThrownWhenSendingRequest() { + when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) + .thenThrow(new UnsupportedOperationException("test exception")); + + final Optional exceptionThrowingDefinition = definitionService.findById(1); + + assertFalse(exceptionThrowingDefinition.isPresent()); + verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString()); + } + + @Test + public void testFindById_IdIsZero() { + final Optional impossibleDefinition = definitionService.findById(0); + + assertFalse(impossibleDefinition.isPresent()); + verifyZeroInteractions(restService); } @Test @@ -120,6 +165,7 @@ public class DefinitionServiceTest { definition.setName("Test Name"); definition.setDefinition(definitionList); definition.setNotation(notationList); + definition.setId(1); return definition; } From 69726a46a4305bd76c6bd87c220289d22a36e778 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 21:51:10 -0600 Subject: [PATCH 07/17] PAN-11 created the updateDefinition method --- .../tsp/services/DefinitionService.java | 36 +++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index 7279ccd..dec86a3 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -89,10 +89,10 @@ public class DefinitionService { final Instant start = Instant.now(); try { - final TypeToken definitionTypeToken = new TypeToken() {}; + final TypeToken typeToken = new TypeToken() {}; final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "definitions/", new GsonBuilder().create().toJson(definition), - definitionTypeToken, + typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds); @@ -110,4 +110,36 @@ public class DefinitionService { LOG.info("Create new definition request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } + + public Optional updateDefinition(final Definition definition) { + if (definition == null) { + LOG.error("Given null definition, returning {}"); + return Optional.empty(); + } + + LOG.info("Sending request to update definition {}", definition); + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken(){}; + final Optional persistenceApiResposne = restService.patch(persistenceApiBaseUrl + "/" + definition.getId(), + new GsonBuilder().create().toJson(definition), + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if (persistenceApiResposne.isPresent()) { + LOG.info("Returning {}", persistenceApiResposne.get()); + } else { + LOG.info("Unable to update definition {}", definition); + } + + return persistenceApiResposne; + } catch (final Exception e) { + LOG.error("Error updating definition {}", e); + return Optional.empty(); + } finally { + LOG.info("Update definition request took {}ms", Duration.between(start, Instant.now()).toMillis()); + } + } } From 6d1db048c8d84c7f695c455f08440453185f39c6 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 21:51:36 -0600 Subject: [PATCH 08/17] PAN-11 created the updateDefinition method --- .../edu/msudenver/tsp/services/DefinitionService.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index dec86a3..6ffa013 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -122,19 +122,19 @@ public class DefinitionService { try { final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResposne = restService.patch(persistenceApiBaseUrl + "/" + definition.getId(), + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "/" + definition.getId(), new GsonBuilder().create().toJson(definition), typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds); - if (persistenceApiResposne.isPresent()) { - LOG.info("Returning {}", persistenceApiResposne.get()); + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); } else { LOG.info("Unable to update definition {}", definition); } - return persistenceApiResposne; + return persistenceApiResponse; } catch (final Exception e) { LOG.error("Error updating definition {}", e); return Optional.empty(); From 5a44b5b79300e56a054a0d526e1cfef09363be40 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 22:12:34 -0600 Subject: [PATCH 09/17] PAN-11 wrote unit tests for the updateDefinition method --- .../tsp/services/DefinitionService.java | 5 ++ .../tsp/services/DefinitionServiceTest.java | 66 +++++++++++++++++-- 2 files changed, 67 insertions(+), 4 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index 6ffa013..e8ec3a2 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -117,6 +117,11 @@ public class DefinitionService { return Optional.empty(); } + if (definition.getId() == 0) { + LOG.error("Given invalid id 0, returning {}"); + return Optional.empty(); + } + LOG.info("Sending request to update definition {}", definition); final Instant start = Instant.now(); diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index 0631854..e7b423f 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -43,7 +43,7 @@ public class DefinitionServiceTest { } @Test - public void testGetAllDefinitions_ReturnsEmptyOptional() { + public void testGetAllDefinitions_RequestReturnsEmptyOptional() { when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) .thenReturn(Optional.empty()); @@ -79,7 +79,7 @@ public class DefinitionServiceTest { } @Test - public void testFindById_ReturnsEmptyOptional() { + public void testFindById_RequestReturnsEmptyOptional() { when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString())) .thenReturn(Optional.empty()); @@ -125,7 +125,7 @@ public class DefinitionServiceTest { } @Test - public void testCreateDefinition_unableToCreateDefinition() { + public void testCreateDefinition_UnableToCreateDefinition() { final Definition testDefinition = createDefinition(); final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); @@ -140,7 +140,7 @@ public class DefinitionServiceTest { } @Test - public void testCreateDefinition_restServiceThrowsException() { + public void testCreateDefinition_RestServiceThrowsException() { final Definition testDefinition = createDefinition(); final String testDefinitionJson = new GsonBuilder().create().toJson(testDefinition); @@ -154,6 +154,64 @@ public class DefinitionServiceTest { verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt()); } + @Test + public void testUpdateDefinition() { + when(restService.patch(anyString(), anyString(), any(), anyInt(), anyInt())) + .thenReturn(Optional.of(createDefinition().setName("Test update"))); + + final Definition testDefinition = new Definition(); + testDefinition.setName("Test update"); + testDefinition.setId(1); + + final Optional updatedDefinition = definitionService.updateDefinition(testDefinition); + + assertTrue(updatedDefinition.isPresent()); + assertThat(updatedDefinition.get().getId(), is(1)); + assertThat(updatedDefinition.get().getName(), is(equalTo("Test update"))); + verify(restService).patch(anyString(), anyString(), any(), anyInt(), anyInt()); + } + + @Test + public void testUpdateDefinition_nullDefinition() { + final Optional testUpdate = definitionService.updateDefinition(null); + + assertFalse(testUpdate.isPresent()); + verifyZeroInteractions(restService); + } + + @Test + public void testUpdateDefinition_IdIsZero() { + final Definition impossibleDefinition = createDefinition(); + impossibleDefinition.setId(0); + + final Optional testUpdate = definitionService.updateDefinition(impossibleDefinition); + + assertFalse(testUpdate.isPresent()); + verifyZeroInteractions(restService); + } + + @Test + public void testUpdateDefinition_RequestReturnsEmptyOptional() { + when(restService.patch(anyString(), anyString(), any(), anyInt(), anyInt())) + .thenReturn(Optional.empty()); + + final Optional nonExistentDefinition = definitionService.updateDefinition(createDefinition()); + + assertFalse(nonExistentDefinition.isPresent()); + verify(restService).patch(anyString(), anyString(), any(), anyInt(), anyInt()); + } + + @Test + public void testUpdateDefinition_ExceptionThrownWhenSendingRequest() { + when(restService.patch(anyString(), anyString(), any(), anyInt(), anyInt())) + .thenThrow(new UnsupportedOperationException("test exception")); + + final Optional exceptionThrowingDefinition = definitionService.updateDefinition(createDefinition()); + + assertFalse(exceptionThrowingDefinition.isPresent()); + verify(restService).patch(anyString(), anyString(), any(), anyInt(), anyInt()); + } + private Definition createDefinition() { final List definitionList = new ArrayList<>(); definitionList.add("Test definition 1"); From 8724d6c2f83cabca8ae0e44f75adab4403918add Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 22:27:27 -0600 Subject: [PATCH 10/17] PAN-11 created the deleteDefinition method --- .../tsp/services/DefinitionService.java | 40 ++++++++++++++++++- .../tsp/services/DefinitionServiceTest.java | 8 ++++ 2 files changed, 46 insertions(+), 2 deletions(-) diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index e8ec3a2..eec2324 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -6,6 +6,7 @@ import edu.msudenver.tsp.services.dto.Definition; 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; @@ -97,7 +98,7 @@ public class DefinitionService { socketTimeoutMilliseconds); if (persistenceApiResponse.isPresent()) { - LOG.info("Returning {}", persistenceApiResponse.get()); + LOG.info("Creation successful. Returning {}", persistenceApiResponse.get()); } else { LOG.info("Unable to create new definition {}", definition); } @@ -134,7 +135,7 @@ public class DefinitionService { socketTimeoutMilliseconds); if (persistenceApiResponse.isPresent()) { - LOG.info("Returning {}", persistenceApiResponse.get()); + LOG.info("Update successful. Returning {}", persistenceApiResponse.get()); } else { LOG.info("Unable to update definition {}", definition); } @@ -147,4 +148,39 @@ public class DefinitionService { LOG.info("Update definition request took {}ms", Duration.between(start, Instant.now()).toMillis()); } } + + public boolean deleteDefinition(final Definition definition) { + if (definition == null) { + LOG.error("Given null definition, returning false"); + return false; + } + + if (definition.getId() == 0) { + LOG.error("Given invalid id 0, returning false"); + return false; + } + + LOG.info("Sending request to delete definition {}", definition); + final Instant start = Instant.now(); + + try { + final boolean deleteIsSuccessful = restService.delete(persistenceApiBaseUrl + "/" + definition.getId(), + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds, + HttpStatus.NO_CONTENT); + + if (deleteIsSuccessful) { + LOG.info("Deletion successful. Returning true"); + } else { + LOG.info("Unable to delete definition {}", definition); + } + + return deleteIsSuccessful; + } catch (final Exception e) { + LOG.error("Error when deleting definition {}", e); + return false; + } finally { + LOG.info("Delete definition request took {}ms", Duration.between(start, Instant.now()).toMillis()); + } + } } diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index e7b423f..e18e54a 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -124,6 +124,14 @@ public class DefinitionServiceTest { verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt()); } + @Test + public void testCreateDefinition_NullDefinition() { + final Optional nullDefinition = definitionService.createDefinition(null); + + assertFalse(nullDefinition.isPresent()); + verifyZeroInteractions(restService); + } + @Test public void testCreateDefinition_UnableToCreateDefinition() { final Definition testDefinition = createDefinition(); From 765d8283d97e7273f9c924a95217aeb193d5034e Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 24 Mar 2019 22:36:10 -0600 Subject: [PATCH 11/17] PAN-11 wrote unit tests for deleteDefinition --- .../tsp/services/DefinitionServiceTest.java | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index e18e54a..38597d8 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -220,6 +220,58 @@ public class DefinitionServiceTest { verify(restService).patch(anyString(), anyString(), any(), anyInt(), anyInt()); } + @Test + public void testDeleteDefinition() { + when(restService.delete(anyString(), anyInt(), anyInt(), any())) + .thenReturn(true); + + final boolean deleteIsSuccessful = definitionService.deleteDefinition(createDefinition()); + + assertTrue(deleteIsSuccessful); + verify(restService).delete(anyString(), anyInt(), anyInt(), any()); + } + + @Test + public void testDeleteDefinition_NullDefinition() { + final boolean deleteIsSuccessful = definitionService.deleteDefinition(null); + + assertFalse(deleteIsSuccessful); + verifyZeroInteractions(restService); + } + + @Test + public void testDeleteDefinition_IdIsZero() { + final Definition testDefinition = createDefinition(); + testDefinition.setId(0); + + final boolean deleteIsSuccessful = definitionService.deleteDefinition(testDefinition); + + assertFalse(deleteIsSuccessful); + verifyZeroInteractions(restService); + } + + @Test + public void testDeleteDefinition_RequestReturnsFalse() { + when(restService.delete(anyString(), anyInt(), anyInt(), any())) + .thenReturn(false); + + final boolean deleteIsSuccessful = definitionService.deleteDefinition(createDefinition()); + + assertFalse(deleteIsSuccessful); + verify(restService).delete(anyString(), anyInt(), anyInt(), any()); + } + + @Test + public void testDeleteDefinition_ExceptionThrownWhenSendingRequest() { + when(restService.delete(anyString(), anyInt(), anyInt(), any())) + .thenThrow(new UnsupportedOperationException("test exception")); + + final boolean deleteIsSuccessful = definitionService.deleteDefinition(createDefinition()); + + assertFalse(deleteIsSuccessful); + verify(restService).delete(anyString(), anyInt(), anyInt(), any()); + } + private Definition createDefinition() { final List definitionList = new ArrayList<>(); definitionList.add("Test definition 1"); From 609f018f9f8c9f1837d2610dbb9346320df3d569 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 16:21:18 -0600 Subject: [PATCH 12/17] PAN-11 Fixed integration tests --- .../tsp/persistence/AccountsIntegrationTest.java | 4 ++-- .../edu/msudenver/tsp/persistence/dto/Account.java | 12 +----------- .../controller/AccountControllerTest.java | 6 ++---- 3 files changed, 5 insertions(+), 17 deletions(-) diff --git a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java index fbb3a21..7cd5abd 100644 --- a/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java +++ b/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/AccountsIntegrationTest.java @@ -29,7 +29,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("test password", savedAccount.getPassword()); - assertTrue(savedAccount.getAdministrator()); + assertTrue(savedAccount.isAdministrator()); savedAccount.setPassword("Test Update"); @@ -37,7 +37,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); - assertTrue(savedAccount.getAdministrator()); + assertTrue(savedAccount.isAdministrator()); assertEquals(updatedAccount.getId(), id); accountsRepository.delete(account); diff --git a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java index 14141f1..674d83b 100644 --- a/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java +++ b/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Account.java @@ -19,21 +19,11 @@ import java.util.Date; 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") private boolean administrator; + @NotNull private boolean administrator; @Temporal(TemporalType.DATE) @Column(name = "last_login") private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; - @JsonProperty("administrator_status") - public boolean getAdministrator() { - return administrator; - } - - @JsonProperty("administrator_status") - public void setAdministrator(final boolean administrator) { - this.administrator = administrator; - } - @JsonProperty("last_login") public Date getLastLogin() { return lastLogin; 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 446e10b..4ffd766 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 @@ -25,10 +25,8 @@ import static org.mockito.Mockito.*; @RunWith(MockitoJUnitRunner.class) @WebMvcTest(controllers = AccountController.class) public class AccountControllerTest { - @Mock - private AccountsRepository accountsRepository; - @InjectMocks - private AccountController accountController; + @Mock private AccountsRepository accountsRepository; + @InjectMocks private AccountController accountController; @Mock private BindingResult bindingResult; @Test From c75b243df89e6ce2567ffce44f0079929f235f4a Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 16:51:36 -0600 Subject: [PATCH 13/17] PAN-11 Fixed integration tests --- .../DefinitionServiceIntegrationTest.java | 2 +- .../tsp/services/ServiceTestConfig.java | 17 ----------------- .../tsp/services/ServicesTestConfig.java | 6 ++++++ .../services/UserServiceIntegrationTest.java | 2 +- 4 files changed, 8 insertions(+), 19 deletions(-) delete mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java index a8a137f..5bd042d 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java @@ -18,7 +18,7 @@ import static org.junit.Assert.*; import static org.mockito.AdditionalMatchers.not; @RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = ServiceTestConfig.class) +@ContextConfiguration(classes = ServicesTestConfig.class) @TestPropertySource(locations = "classpath:test.properties") public class DefinitionServiceIntegrationTest { @Autowired private DefinitionService definitionService; diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java deleted file mode 100644 index 1d9d54e..0000000 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServiceTestConfig.java +++ /dev/null @@ -1,17 +0,0 @@ -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 ServiceTestConfig { - - @Bean - @Autowired - public DefinitionService definitionService(final RestService restService) { - return new DefinitionService(restService); - } -} diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java index 4c9e2b4..40fd162 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java @@ -14,4 +14,10 @@ public class ServicesTestConfig { public UserService userService(final RestService restService) { return new UserService(restService); } + + @Bean + @Autowired + public DefinitionService definitionService(final RestService restService) { + return new DefinitionService(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 index bb7a4e8..64fd7ad 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -23,7 +23,7 @@ public class UserServiceIntegrationTest { private UserService userService; @Test - public void testUserService(){ + public void testCRUD() { final Account testAccount = createAccount(); final Optional testCreatedAccount = userService.createAccount(testAccount); From 67f77d6c9ede188ff556ff1b781cbda182c32b38 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 17:06:43 -0600 Subject: [PATCH 14/17] PAN-11 Fixed integration tests --- .../DefinitionServiceIntegrationTest.java | 86 ------------------- 1 file changed, 86 deletions(-) delete mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java deleted file mode 100644 index 5bd042d..0000000 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java +++ /dev/null @@ -1,86 +0,0 @@ -package edu.msudenver.tsp.services; - -import edu.msudenver.tsp.services.dto.Definition; -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.TestPropertySource; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.*; -import static org.mockito.AdditionalMatchers.not; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = ServicesTestConfig.class) -@TestPropertySource(locations = "classpath:test.properties") -public class DefinitionServiceIntegrationTest { - @Autowired private DefinitionService definitionService; - - @Test - public void testCRUD() { - final Definition testDefinition = createDefinition(); - final Optional createdDefinition = definitionService.createDefinition(testDefinition); - - assertTrue(createdDefinition.isPresent()); - assertThat(createdDefinition.get().getId(), is(not(0))); - assertThat(createdDefinition.get().getVersion(), is(0)); - assertThat(createdDefinition.get().getName(), is("Test Name")); - assertNotNull(createdDefinition.get().getDefinition()); - assertThat(createdDefinition.get().getDefinition().size(), is(1)); - assertThat(createdDefinition.get().getDefinition().get(0), is("Test definition 1")); - assertNotNull(createdDefinition.get().getNotation()); - assertThat(createdDefinition.get().getNotation().size(), is(1)); - assertThat(createdDefinition.get().getNotation().get(0), is("\\testLaTeX")); - - final Optional definitionFoundById = definitionService.findById(createdDefinition.get().getId()); - - assertThat(definitionFoundById.get(), is(equalTo(createdDefinition.get()))); - - final Definition definitionUpdate = new Definition(); - definitionUpdate.setId(createdDefinition.get().getId()); - definitionUpdate.setName("Test Update"); - - final Optional updatedDefinition = definitionService.updateDefinition(definitionUpdate); - - assertTrue(updatedDefinition.isPresent()); - assertThat(updatedDefinition.get().getId(), is(not(0))); - assertThat(updatedDefinition.get().getVersion(), is(1)); - assertThat(updatedDefinition.get().getName(), is("Test Update")); - assertNotNull(updatedDefinition.get().getDefinition()); - assertThat(updatedDefinition.get().getDefinition().size(), is(1)); - assertThat(updatedDefinition.get().getDefinition().get(0), is("Test definition 1")); - assertNotNull(updatedDefinition.get().getNotation()); - assertThat(updatedDefinition.get().getNotation().size(), is(1)); - assertThat(updatedDefinition.get().getNotation().get(0), is("\\testLaTeX")); - - final boolean deletionWasSuccessful = definitionService.deleteDefinition(updatedDefinition.get()); - - assertThat(deletionWasSuccessful, is(true)); - - final Optional deletedDefinitionFoundById = definitionService.findById(createdDefinition.get().getId()); - - assertFalse(deletedDefinitionFoundById.isPresent()); - } - - private Definition createDefinition() { - final List definitionList = new ArrayList<>(); - definitionList.add("Test definition 1"); - - final List notationList = new ArrayList<>(); - notationList.add("\\testLaTeX"); - - final Definition definition = new Definition(); - definition.setName("Test Name"); - definition.setDefinition(definitionList); - definition.setNotation(notationList); - - return definition; - } -} From 091215f1eb617ac83a74a6a781334e32350ad27f Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 17:22:08 -0600 Subject: [PATCH 15/17] PAN-11 Fixed integration tests --- .../java/edu/msudenver/tsp/services/ServicesTestConfig.java | 6 ------ services/src/integrationTest/resources/test.properties | 6 +++--- .../main/java/edu/msudenver/tsp/services/dto/Account.java | 4 +++- 3 files changed, 6 insertions(+), 10 deletions(-) diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java index 40fd162..4c9e2b4 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java @@ -14,10 +14,4 @@ public class ServicesTestConfig { public UserService userService(final RestService restService) { return new UserService(restService); } - - @Bean - @Autowired - public DefinitionService definitionService(final RestService restService) { - return new DefinitionService(restService); - } } diff --git a/services/src/integrationTest/resources/test.properties b/services/src/integrationTest/resources/test.properties index ff86c7e..3690a57 100644 --- a/services/src/integrationTest/resources/test.properties +++ b/services/src/integrationTest/resources/test.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/ 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 54127ba..f04a108 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 @@ -4,6 +4,8 @@ import com.google.gson.annotations.SerializedName; import lombok.Data; import lombok.EqualsAndHashCode; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; import java.io.Serializable; @@ -15,7 +17,7 @@ public class Account extends BaseDto implements Serializable { @Size(max = 50) private String username; @Size(max = 256) private String password; @NotNull private boolean administrator; - @SerializedName("last_login") private Date lastLogin; + @Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; } From c8600b8bb45565693127e5cd254cae7f52c8405d Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 17:30:34 -0600 Subject: [PATCH 16/17] PAN-11 Fixed integration tests --- services/build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/services/build.gradle b/services/build.gradle index 2d22968..4b57a8d 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -23,6 +23,7 @@ dependencies { compile group: 'com.google.code.gson', name: 'gson', version: '2.7' compile group: 'org.springframework.boot', name: 'spring-boot-devtools', version: '2.0.5.RELEASE' compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' + compile group: 'javax.persistence', name: 'javax.persistence-api', version: '2.2' compile fileTree(dir: 'lib', include: '**/*.jar') testCompile "org.springframework:spring-test:5.0.9.RELEASE" From 12f7d7f35925a7167aa6ae8ac092b7b3bfd1c675 Mon Sep 17 00:00:00 2001 From: atusa17 Date: Sun, 7 Apr 2019 18:00:12 -0600 Subject: [PATCH 17/17] PAN-11 fixed all integration tests --- .../scripts/mysql/local_development.sql | 5 +- services/build.gradle | 2 +- .../DefinitionServiceIntegrationTest.java | 85 +++++++++++++++++++ .../tsp/services/DefinitionService.java | 6 +- .../tsp/services/DefinitionServiceTest.java | 4 +- 5 files changed, 94 insertions(+), 8 deletions(-) create mode 100644 services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index bfb1811..9650f22 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 primary key unique, + id int not null auto_increment, theorem_name varchar(512) not null, proof varchar(4096) not null, branch varchar(512) not null, @@ -45,5 +45,6 @@ create table proofs referenced_theorems json, date_added date, last_updated date, - version int default 1 + version int default 1, + primary key (id) ); \ No newline at end of file diff --git a/services/build.gradle b/services/build.gradle index 4b57a8d..0873510 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -27,6 +27,6 @@ dependencies { compile fileTree(dir: 'lib', include: '**/*.jar') testCompile "org.springframework:spring-test:5.0.9.RELEASE" - testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.2.RELEASE' 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/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java new file mode 100644 index 0000000..9aff2fc --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java @@ -0,0 +1,85 @@ +package edu.msudenver.tsp.services; + +import edu.msudenver.tsp.services.dto.Definition; +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.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = ServicesTestConfig.class) +@TestPropertySource(locations = "classpath:test.properties") +public class DefinitionServiceIntegrationTest { + @Autowired private DefinitionService definitionService; + + @Test + public void testCRUD() { + final Definition testDefinition = createDefinition(); + final Optional createdDefinition = definitionService.createDefinition(testDefinition); + + assertTrue(createdDefinition.isPresent()); + assertNotEquals(0, createdDefinition.get().getId()); + assertThat(createdDefinition.get().getVersion(), is(0)); + assertThat(createdDefinition.get().getName(), is("Test Name")); + assertNotNull(createdDefinition.get().getDefinition()); + assertThat(createdDefinition.get().getDefinition().size(), is(1)); + assertThat(createdDefinition.get().getDefinition().get(0), is("Test definition 1")); + assertNotNull(createdDefinition.get().getNotation()); + assertThat(createdDefinition.get().getNotation().size(), is(1)); + assertThat(createdDefinition.get().getNotation().get(0), is("\\testLaTeX")); + + final Optional definitionFoundById = definitionService.findById(createdDefinition.get().getId()); + + assertThat(definitionFoundById.get(), is(equalTo(createdDefinition.get()))); + + final Definition definitionUpdate = new Definition(); + definitionUpdate.setId(createdDefinition.get().getId()); + definitionUpdate.setName("Test Update"); + + final Optional updatedDefinition = definitionService.updateDefinition(definitionUpdate); + + assertTrue(updatedDefinition.isPresent()); + assertNotEquals(0, updatedDefinition.get().getId()); + assertThat(updatedDefinition.get().getVersion(), is(1)); + assertThat(updatedDefinition.get().getName(), is("Test Update")); + assertNotNull(updatedDefinition.get().getDefinition()); + assertThat(updatedDefinition.get().getDefinition().size(), is(1)); + assertThat(updatedDefinition.get().getDefinition().get(0), is("Test definition 1")); + assertNotNull(updatedDefinition.get().getNotation()); + assertThat(updatedDefinition.get().getNotation().size(), is(1)); + assertThat(updatedDefinition.get().getNotation().get(0), is("\\testLaTeX")); + + final boolean deletionWasSuccessful = definitionService.deleteDefinition(updatedDefinition.get()); + + assertThat(deletionWasSuccessful, is(true)); + + final Optional deletedDefinitionFoundById = definitionService.findById(createdDefinition.get().getId()); + + assertFalse(deletedDefinitionFoundById.isPresent()); + } + + private Definition createDefinition() { + final List definitionList = new ArrayList<>(); + definitionList.add("Test definition 1"); + + final List notationList = new ArrayList<>(); + notationList.add("\\testLaTeX"); + + final Definition definition = new Definition(); + definition.setName("Test Name"); + definition.setDefinition(definitionList); + definition.setNotation(notationList); + + return definition; + } +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java index 967e0c6..68472ea 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -62,7 +62,7 @@ public class DefinitionService { try { final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "/" + id, + final Optional persistenceApiResponse = restService.get(persistenceApiBaseUrl + "definitions/" + id, typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds, null); if (persistenceApiResponse.isPresent()) { @@ -128,7 +128,7 @@ public class DefinitionService { try { final TypeToken typeToken = new TypeToken(){}; - final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "/" + definition.getId(), + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "definitions/" + definition.getId(), new GsonBuilder().create().toJson(definition), typeToken, connectionTimeoutMilliseconds, @@ -164,7 +164,7 @@ public class DefinitionService { final Instant start = Instant.now(); try { - final boolean deleteIsSuccessful = restService.delete(persistenceApiBaseUrl + "/" + definition.getId(), + final boolean deleteIsSuccessful = restService.delete(persistenceApiBaseUrl + "definitions/" + definition.getId(), connectionTimeoutMilliseconds, socketTimeoutMilliseconds, HttpStatus.NO_CONTENT); diff --git a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java index 38597d8..c9c8f42 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/DefinitionServiceTest.java @@ -13,8 +13,8 @@ import java.util.List; import java.util.Optional; import static junit.framework.TestCase.assertTrue; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.is; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.core.IsEqual.equalTo; import static org.junit.Assert.*; import static org.mockito.Matchers.*; import static org.mockito.Mockito.*;