diff --git a/persistence/scripts/mysql/local_development.sql b/persistence/scripts/mysql/local_development.sql index fbd9dac..bfb1811 100644 --- a/persistence/scripts/mysql/local_development.sql +++ b/persistence/scripts/mysql/local_development.sql @@ -5,11 +5,11 @@ create table accounts ( id int not null auto_increment primary key unique, username varchar(50) not null unique, password varchar(256) not null, -administrator_status boolean default false, +administrator boolean default false, last_login date, version int default 1 ); -insert into accounts (username, password, administrator_status) +insert into accounts (username, password, administrator) values ('admin', 'secret', true), ('atusa', 'secret', true), ('dantanxiaotian', 'secret', true), 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 42cce04..fbb3a21 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.getAdministratorStatus()); + assertTrue(savedAccount.getAdministrator()); savedAccount.setPassword("Test Update"); @@ -37,7 +37,7 @@ public class AccountsIntegrationTest { assertEquals("Test username", savedAccount.getUsername()); assertEquals("Test Update", savedAccount.getPassword()); - assertTrue(savedAccount.getAdministratorStatus()); + assertTrue(savedAccount.getAdministrator()); assertEquals(updatedAccount.getId(), id); accountsRepository.delete(account); @@ -49,7 +49,7 @@ public class AccountsIntegrationTest { final Account account = new Account(); account.setUsername("Test username"); account.setPassword("test password"); - account.setAdministratorStatus(true); + account.setAdministrator(true); return 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 a8fa430..14141f1 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,19 +19,19 @@ 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_status") private boolean administratorStatus; + @NotNull @Column(name = "administrator") private boolean administrator; @Temporal(TemporalType.DATE) @Column(name = "last_login") private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; @JsonProperty("administrator_status") - public boolean getAdministratorStatus() { - return administratorStatus; + public boolean getAdministrator() { + return administrator; } @JsonProperty("administrator_status") - public void setAdministratorStatus(final boolean administratorStatus) { - this.administratorStatus = administratorStatus; + public void setAdministrator(final boolean administrator) { + this.administrator = administrator; } @JsonProperty("last_login") 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 503e2f6..446e10b 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 @@ -269,7 +269,7 @@ public class AccountControllerTest { final Account account = new Account(); account.setUsername("Test username"); account.setPassword("test password"); - account.setAdministratorStatus(true); + account.setAdministrator(true); return account; } 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 7f424e3..a8a137f 100644 --- a/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/DefinitionServiceIntegrationTest.java @@ -12,6 +12,7 @@ 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; @@ -23,11 +24,10 @@ public class DefinitionServiceIntegrationTest { @Autowired private DefinitionService definitionService; @Test - public void testCreateDefinition() { + public void testCRUD() { final Definition testDefinition = createDefinition(); final Optional createdDefinition = definitionService.createDefinition(testDefinition); - assertNotNull(createdDefinition); assertTrue(createdDefinition.isPresent()); assertThat(createdDefinition.get().getId(), is(not(0))); assertThat(createdDefinition.get().getVersion(), is(0)); @@ -38,6 +38,35 @@ public class DefinitionServiceIntegrationTest { 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() { diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java new file mode 100644 index 0000000..4c9e2b4 --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/ServicesTestConfig.java @@ -0,0 +1,17 @@ +package edu.msudenver.tsp.services; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; + +@Configuration +@ComponentScan +public class ServicesTestConfig { + + @Bean + @Autowired + public UserService userService(final RestService restService) { + return new UserService(restService); + } +} diff --git a/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java new file mode 100644 index 0000000..bb7a4e8 --- /dev/null +++ b/services/src/integrationTest/java/edu/msudenver/tsp/services/UserServiceIntegrationTest.java @@ -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 testCreatedAccount = userService.createAccount(testAccount); + assertTrue(testCreatedAccount.isPresent()); + final Account returnedAccount = testCreatedAccount.get(); + assertEquals("test_user", returnedAccount.getUsername()); + assertEquals("test_password", returnedAccount.getPassword()); + assertFalse(returnedAccount.isAdministrator()); + + final Optional getAccountById = userService.findAccountById(returnedAccount.getId()); + assertTrue(getAccountById.isPresent()); + final Account returnedAccountById = getAccountById.get(); + assertEquals("test_user", returnedAccountById.getUsername()); + assertEquals("test_password", returnedAccountById.getPassword()); + assertFalse(returnedAccountById.isAdministrator()); + + final Optional 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.isAdministrator()); + + returnedAccount.setUsername("test_updatedUser"); + returnedAccount.setPassword("test_updatedPassword"); + + final Optional updatedAccount = userService.updateAccount(returnedAccount); + assertTrue(updatedAccount .isPresent()); + final Account returnedUpdatedAccount = updatedAccount.get(); + assertEquals("test_updatedUser", returnedUpdatedAccount.getUsername()); + assertEquals("test_updatedPassword", returnedUpdatedAccount.getPassword()); + assertFalse(returnedUpdatedAccount.isAdministrator()); + + 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.setAdministrator(false); + testAccount.setLastLogin(new Date()); + + return testAccount; + } + +} 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 eec2324..967e0c6 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/DefinitionService.java @@ -44,7 +44,7 @@ public class DefinitionService { return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error getting list of definitions! {}", 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()); @@ -105,7 +105,7 @@ public class DefinitionService { return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error creating new definition {}", 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()); @@ -142,7 +142,7 @@ public class DefinitionService { return persistenceApiResponse; } catch (final Exception e) { - LOG.error("Error updating definition {}", e); + LOG.error("Error updating definition", e); return Optional.empty(); } finally { LOG.info("Update definition request took {}ms", Duration.between(start, Instant.now()).toMillis()); @@ -177,7 +177,7 @@ public class DefinitionService { return deleteIsSuccessful; } catch (final Exception e) { - LOG.error("Error when deleting definition {}", 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/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index f119441..3125824 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/UserService.java +++ b/services/src/main/java/edu/msudenver/tsp/services/UserService.java @@ -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 createNewAccount(final Account account) { + public Optional> getListOfAccounts() { + final Instant start = Instant.now(); + + try { + final TypeToken> typeToken = new TypeToken>() {}; + final Optional> 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 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 typeToken = new TypeToken() {}; + final Optional 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 findAccountByUsername(final String username) { + if (username == null) { + LOG.error("No username specified! Returning {}"); + return Optional.empty(); + } + + final Instant start = Instant.now(); + + try { + final TypeToken typeToken = new TypeToken() {}; + final Optional 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 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 typeToken = new TypeToken() {}; - final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "/accounts/", - new GsonBuilder().create().toJson(account), + final Optional persistenceApiResponse = restService.post(persistenceApiBaseUrl + "accounts/", + new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), typeToken, connectionTimeoutMilliseconds, socketTimeoutMilliseconds); @@ -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 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 typeToken = new TypeToken(){}; + final Optional persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "accounts/" + id, + new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create().toJson(account), + typeToken, + connectionTimeoutMilliseconds, + socketTimeoutMilliseconds); + + if (persistenceApiResponse.isPresent()) { + LOG.info("Returning {}", persistenceApiResponse.get()); + } else { + LOG.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()); } } } 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 99ca0cd..54127ba 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,7 +4,6 @@ import com.google.gson.annotations.SerializedName; import lombok.Data; import lombok.EqualsAndHashCode; -import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; import java.io.Serializable; @@ -13,12 +12,10 @@ import java.util.Date; @Data @EqualsAndHashCode(callSuper = true) 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 @SerializedName("administrator_status") private boolean administratorStatus; + @Size(max = 50) private String username; + @Size(max = 256) private String password; + @NotNull private boolean administrator; @SerializedName("last_login") private Date lastLogin; private static final long serialVersionUID = 7095627971593953734L; - - public interface Insert {} } diff --git a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java index eb4933d..e108cd1 100644 --- a/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java +++ b/services/src/main/java/edu/msudenver/tsp/services/factory/RequestFactory.java @@ -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); } } \ No newline at end of file diff --git a/services/src/main/resources/application.properties b/services/src/main/resources/application.properties index ff86c7e..710f97b 100644 --- a/services/src/main/resources/application.properties +++ b/services/src/main/resources/application.properties @@ -1,3 +1,3 @@ -persistence.api.connection.timeout.milliseconds = 5000 -persistence.api.socket.timeout.milliseconds = 10000 -persistence.api.base.url = http://localhost:8090/ \ No newline at end of file +persistence.api.connection.timeout.milliseconds=5000 +persistence.api.socket.timeout.milliseconds=10000 +persistence.api.base.url=http://localhost:8090/ \ No newline at end of file diff --git a/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java new file mode 100644 index 0000000..1f7812f --- /dev/null +++ b/services/src/test/java/edu/msudenver/tsp/services/UserServiceTest.java @@ -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 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> 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> 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> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 response = userService.updateAccount(null); + + assertFalse(response.isPresent()); + verifyZeroInteractions(restService); + } + + @Test + public void testUpdateAccount_IdEqualsZero() { + final Account account = createAccount(); + account.setId(0); + + final Optional 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 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 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.setAdministrator(true); + account.setLastLogin(new Date()); + return account; + } +} diff --git a/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java b/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java index fdfecf0..597fbc2 100644 --- a/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java +++ b/services/src/test/java/edu/msudenver/tsp/services/parser/ParserServiceTest.java @@ -18,7 +18,6 @@ import static org.mockito.Mockito.when; public class ParserServiceTest { @Mock private ParserService mockParserService; - @InjectMocks private ParserService parserService; @Test