Dark-Alex-17/ptp
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #24 from atusa17/PAN-15

Browse Source 
Pan 15
This commit is contained in:
Alex Tusa
2019-04-07 15:33:49 -06:00
committed by GitHub
parent c715e98e81 36036b710d
commit 1bddb2d646
11 changed files with 598 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
services/build.gradle
+1
View File
@@ -26,4 +26,5 @@ dependencies {
testCompile "org.springframework:spring-test:5.0.9.RELEASE"
testCompile group: 'junit', name: 'junit', version: '4.12'
testCompile group: 'org.springframework', name: 'spring-test', version: '5.1.5.RELEASE'
}
services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java
+17
View File
@@ -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);
}
}
services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java
+74
View File
@@ -0,0 +1,74 @@
package edu.msudenver.tsp.services;
import edu.msudenver.tsp.services.dto.Account;
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.util.Date;
import java.util.Optional;
import static org.junit.Assert.*;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ServicesTestConfig.class)
@TestPropertySource("classpath:test.properties")
public class UserServiceIntegrationTest {
@Autowired
@Qualifier("userService")
private UserService userService;
@Test
public void testUserService(){
final Account testAccount = createAccount();
final Optional<Account> testCreatedAccount = userService.createAccount(testAccount);
assertTrue(testCreatedAccount.isPresent());
final Account returnedAccount = testCreatedAccount.get();
assertEquals("test_user", returnedAccount.getUsername());
assertEquals("test_password", returnedAccount.getPassword());
assertFalse(returnedAccount.isAdministratorStatus());
final Optional<Account> 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<Account> getAccountByUsername = userService.findAccountByUsername(returnedAccount.getUsername());
assertTrue(getAccountByUsername.isPresent());
final Account returnedAccountByUsername = getAccountByUsername.get();
assertEquals("test_user", returnedAccountByUsername.getUsername());
assertEquals("test_password", returnedAccountByUsername.getPassword());
assertFalse(returnedAccountById.isAdministratorStatus());
returnedAccount.setUsername("test_updatedUser");
returnedAccount.setPassword("test_updatedPassword");
final Optional<Account> 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 createAccount() {
final Account testAccount = new Account();
testAccount.setUsername("test_user");
testAccount.setPassword("test_password");
testAccount.setAdministratorStatus(false);
testAccount.setLastLogin(new Date());
return testAccount;
}
}
services/src/integrationTest/resources/test.properties
+3
View File
@@ -0,0 +1,3 @@
persistence.api.connection.timeout.milliseconds=5000
persistence.api.socket.timeout.milliseconds=10000
persistence.api.base.url=http://localhost:8090/
services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java
+14
View File
@@ -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 {
}
services/src/main/java/edu/msudenver/tsp/services/UserService.java
+170 -6
View File
@@ -6,10 +6,12 @@ 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;
import java.time.Instant;
import java.util.List;
import java.util.Optional;
@Slf4j
@@ -25,7 +27,96 @@ public class UserService {
this.restService = restService;
}
public Optional<Account> createNewAccount(final Account account) {
public Optional<List<Account>> getListOfAccounts() {
final Instant start = Instant.now();
try {
final TypeToken<List<Account>> typeToken = new TypeToken<List<Account>>() {};
final Optional<List<Account>> persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/",
typeToken,
connectionTimeoutMilliseconds,
socketTimeoutMilliseconds,
null);
if (persistenceApiResponse.isPresent()) {
LOG.info("Returning {}", persistenceApiResponse.get());
} else {
LOG.warn("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("Get the list of accounts request took {}ms", Duration.between(start, Instant.now()).toMillis());
}
}
public Optional<Account> findAccountById(final int id) {
if (id == 0) {
LOG.error("No user ID specified! Returning {}");
return Optional.empty();
}
final Instant start = Instant.now();
try {
final TypeToken<Account> typeToken = new TypeToken<Account>() {};
final Optional<Account> persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/id?id=" + id,
typeToken,
connectionTimeoutMilliseconds,
socketTimeoutMilliseconds,
null);
if (persistenceApiResponse.isPresent()) {
LOG.info("Returning {}", persistenceApiResponse.get());
} else {
LOG.warn("Unable to find account with id {}", id);
}
return persistenceApiResponse;
} catch (final Exception e) {
LOG.error("Error finding account by id", e);
return Optional.empty();
} finally {
LOG.info("Find account by ID request took {}ms", Duration.between(start, Instant.now()).toMillis());
}
}
public Optional<Account> findAccountByUsername(final String username) {
if (username == null) {
LOG.error("No username specified! Returning {}");
return Optional.empty();
}
final Instant start = Instant.now();
try {
final TypeToken<Account> typeToken = new TypeToken<Account>() {};
final Optional<Account> persistenceApiResponse = restService.get(persistenceApiBaseUrl + "accounts/username?username=" + username,
typeToken,
connectionTimeoutMilliseconds,
socketTimeoutMilliseconds,
null);
if (persistenceApiResponse.isPresent()) {
LOG.info("Returning {}", persistenceApiResponse.get());
} else {
LOG.warn("Unable to GET account with username {}", username);
}
return persistenceApiResponse;
} catch (final Exception e) {
LOG.error("Error finding account by username", e);
return Optional.empty();
} finally {
LOG.info("Find account by username request took {}ms", Duration.between(start, Instant.now()).toMillis());
}
}
public Optional<Account> createAccount(final Account account) {
if (account == null) {
LOG.error("Given null account, returning {}");
return Optional.empty();
@@ -34,8 +125,8 @@ public class UserService {
try {
final TypeToken<Account> typeToken = new TypeToken<Account>() {};
final Optional<Account> persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/accounts/",
new GsonBuilder().create().toJson(account),
final Optional<Account> persistenceApiResponse = restService.post(persistenceApiBaseUrl + "accounts/",
new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account),
typeToken,
connectionTimeoutMilliseconds,
socketTimeoutMilliseconds);
@@ -43,15 +134,88 @@ 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());
}
}
public Optional<Account> updateAccount(final Account account) {
if (account == null) {
LOG.error("Specified account is null; returning {}");
return Optional.empty();
}
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 TypeToken<Account> typeToken = new TypeToken<Account>(){};
final Optional<Account> 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.warn("Unable to update user with id {}", account.getId());
}
return persistenceApiResponse;
} catch (final Exception e) {
LOG.error("Error updating user", e);
return Optional.empty();
} finally {
LOG.info("Update user request took {}ms", Duration.between(start, Instant.now()).toMillis());
}
}
public boolean deleteAccount(final Account account) {
if (account == null){
LOG.error("Specified account is null; returning {}");
return false;
}
if (account.getId() == 0) {
LOG.error("No user ID specified! Returning {}");
return false;
}
final int 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("Returning {}", persistenceApiResponse);
}
else {
LOG.error("Unable to delete user {}", account);
}
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());
}
}
}
services/src/main/java/edu/msudenver/tsp/services/dto/Account.java
+2 -4
View File
@@ -6,7 +6,6 @@ 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;
import java.io.Serializable;
@@ -15,11 +14,10 @@ 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;
@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;
private static final long serialVersionUID = 7095627971593953734L;
}
services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java
+1 -1
View File
@@ -24,6 +24,6 @@ public class RequestFactory {
}
public Request patch(final String uri, final String requestJson) {
return StringUtils.isNotBlank(requestJson) ? Request.Put(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Patch(uri);
return StringUtils.isNotBlank(requestJson) ? Request.Patch(uri).bodyString(requestJson, ContentType.APPLICATION_JSON) : Request.Patch(uri);
}
}
services/src/main/resources/application.properties
+3 -3
View File
@@ -1,3 +1,3 @@
persistence.api.connection.timeout.milliseconds = 5000
persistence.api.socket.timeout.milliseconds = 10000
persistence.api.base.url = http://localhost:8090/
persistence.api.connection.timeout.milliseconds=5000
persistence.api.socket.timeout.milliseconds=10000
persistence.api.base.url=http://localhost:8090/
services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java
+313
View File
@@ -0,0 +1,313 @@
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.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
@Mock private RestService restService;
@InjectMocks private UserService userService;
@Test
public void testGetListOfAccounts() {
final List<Account> accountList = new ArrayList<>();
accountList.add(createAccount());
accountList.add(createAccount());
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(), anyString())).thenReturn(Optional.of(accountList));
final Optional<List<Account>> response = userService.getListOfAccounts();
assertTrue(response.isPresent());
assertEquals(accountList, response.get());
verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString());
}
@Test
public void testGetListOfAccounts_PersistenceApiResponseIsEmpty() {
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.empty());
final Optional<List<Account>> response = userService.getListOfAccounts();
assertFalse(response.isPresent());
verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString());
}
@Test
public void testGetListOfAccounts_RestServiceThrowsException() {
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenThrow(Exception.class);
final Optional<List<Account>> response = userService.getListOfAccounts();
assertFalse(response.isPresent());
verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString());
}
@Test
public void testFindAccountById() {
final Account account = createAccount();
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.of(account));
final Optional<Account> response = userService.findAccountById(1);
assertTrue(response.isPresent());
assertEquals(account, response.get());
verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString());
}
@Test
public void testFindAccountById_IdEqualsZero() {
final Optional<Account> response = userService.findAccountById(0);
assertFalse(response.isPresent());
assertEquals(Optional.empty(), response);
verifyZeroInteractions(restService);
}
@Test
public void testFindAccountById_PersistenceApiResponseIsEmpty() {
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.empty());
final Optional<Account> response = userService.findAccountById(1);
assertFalse(response.isPresent());
verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString());
}
@Test
public void testFindAccountById_RestServiceThrowsException() {
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenThrow(Exception.class);
final Optional<Account> response = userService.findAccountById(1);
assertFalse(response.isPresent());
verify(restService).get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString());
}
@Test
public void testFindAccountByUsername() {
final Account account = createAccount();
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.of(account));
final Optional<Account> response = userService.findAccountByUsername(account.getUsername());
assertTrue(response.isPresent());
assertEquals(account, response.get());
verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString());
}
@Test
public void testFindAccountByUsername_NullUsername() {
final Optional<Account> response = userService.findAccountByUsername(null);
assertFalse(response.isPresent());
assertEquals(Optional.empty(), response);
verifyZeroInteractions(restService);
}
@Test
public void testFindAccountByUsername_PersistenceApiResponseIsEmpty() {
final Account account = createAccount();
when(restService.get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString())).thenReturn(Optional.empty());
final Optional<Account> response = userService.findAccountByUsername(account.getUsername());
assertFalse(response.isPresent());
verify(restService).get(anyString(),any(TypeToken.class), anyInt(), anyInt(),anyString());
}
@Test
public void testFindAccountByUsername_RestServiceThrowsException() {
when(restService.get(anyString(), any(TypeToken.class), anyInt(), anyInt(), anyString())).thenThrow(Exception.class);
final Optional<Account> 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));
final Optional<Account> response = userService.createAccount(account);
assertTrue(response.isPresent());
assertEquals(account, response.get());
verify(restService).post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt());
}
@Test
public void testCreateAccount_NullAccount() {
final Optional<Account> 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_AccountCouldNotBeCreated() {
when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenReturn(Optional.empty());
final Optional<Account> response = userService.createAccount(createAccount());
assertFalse(response.isPresent());
verify(restService).post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt());
}
@Test
public void testCreateAccount_RestServiceThrowsException() {
when(restService.post(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenThrow(Exception.class);
final Optional<Account> 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));
final Optional<Account> response = userService.updateAccount(account);
assertTrue(response.isPresent());
assertEquals(account, response.get());
verify(restService).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt());
}
@Test
public void testUpdateAccount_NullAccount() {
final Optional<Account> response = userService.updateAccount(null);
assertFalse(response.isPresent());
verifyZeroInteractions(restService);
}
@Test
public void testUpdateAccount_IdEqualsZero() {
final Account account = createAccount();
account.setId(0);
final Optional<Account> response = userService.updateAccount(account);
assertFalse(response.isPresent());
verifyZeroInteractions(restService);
}
@Test
public void testUpdateAccount_PersistenceApiResponseIsEmpty() {
final Account account = createAccount();
account.setId(1);
when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenReturn(Optional.empty());
final Optional<Account> response = userService.updateAccount(account);
assertFalse(response.isPresent());
verify(restService).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt());
}
@Test
public void testUpdateAccount_RestServiceThrowsException() {
final Account account = createAccount();
account.setId(1);
when(restService.patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt())).thenThrow(Exception.class);
final Optional<Account> response = userService.updateAccount(account);
assertFalse(response.isPresent());
verify(restService).patch(anyString(), anyString(), any(TypeToken.class), anyInt(), anyInt());
}
@Test
public void testDeleteAccount() {
final Account account = createAccount();
account.setId(1);
when(restService.delete(anyString(), anyInt(), anyInt(), any())).thenReturn(true);
final boolean isDeleteSuccessful = userService.deleteAccount(account);
assertTrue(isDeleteSuccessful);
verify(restService).delete(anyString(), anyInt(), anyInt(), any());
}
@Test
public void testDeleteAccount_NullAccount() {
final boolean isDeleteSuccessful = userService.deleteAccount(null);
assertFalse(isDeleteSuccessful);
verifyZeroInteractions(restService);
}
@Test
public void testDeleteAccount_IdEqualsZero() {
final Account account = createAccount();
account.setId(0);
final boolean isDeleteSuccessful = userService.deleteAccount(account);
assertFalse(isDeleteSuccessful);
verifyZeroInteractions(restService);
}
@Test
public void testDeleteAccount_PersistenceApiResponseIsEmpty() {
final Account account = createAccount();
account.setId(1);
when(restService.delete(anyString(), anyInt(), anyInt(), any())).thenReturn(false);
final boolean isDeleteSuccessful = userService.deleteAccount(account);
assertFalse(isDeleteSuccessful);
verify(restService).delete(anyString(), anyInt(), anyInt(), any());
}
@Test
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);
assertFalse(persistenceApiResponse);
verify(restService).delete(anyString(), anyInt(), anyInt(), any());
}
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;
}
}
services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java
-1
View File
@@ -18,7 +18,6 @@ import static org.mockito.Mockito.when;
public class ParserServiceTest {
@Mock private ParserService mockParserService;
@InjectMocks private ParserService parserService;
@Test