diff --git a/services/build.gradle b/services/build.gradle index 551f2b2..95d21d7 100644 --- a/services/build.gradle +++ b/services/build.gradle @@ -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' } 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..be36c25 --- /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.isAdministratorStatus()); + + final Optional getAccountById = userService.findAccountById(returnedAccount.getId()); + assertTrue(getAccountById.isPresent()); + final Account returnedAccountById = getAccountById.get(); + assertEquals("test_user", returnedAccountById.getUsername()); + assertEquals("test_password", returnedAccountById.getPassword()); + assertFalse(returnedAccountById.isAdministratorStatus()); + + final Optional getAccountByUsername = userService.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 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; + } + +} diff --git a/services/src/integrationTest/resources/test.properties b/services/src/integrationTest/resources/test.properties new file mode 100644 index 0000000..3690a57 --- /dev/null +++ b/services/src/integrationTest/resources/test.properties @@ -0,0 +1,3 @@ +persistence.api.connection.timeout.milliseconds=5000 +persistence.api.socket.timeout.milliseconds=10000 +persistence.api.base.url=http://localhost:8090/ diff --git a/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java new file mode 100644 index 0000000..db65cc6 --- /dev/null +++ b/services/src/main/java/edu/msudenver/tsp/services/ServiceConfig.java @@ -0,0 +1,14 @@ +package edu.msudenver.tsp.services; + +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration; +import org.springframework.boot.devtools.autoconfigure.DevToolsDataSourceAutoConfiguration; +import org.springframework.context.annotation.Configuration; + +@Configuration +@EnableAutoConfiguration(exclude = {DevToolsDataSourceAutoConfiguration.class, + HibernateJpaAutoConfiguration.class, + DataSourceAutoConfiguration.class}) +public class ServiceConfig { +} diff --git a/services/src/main/java/edu/msudenver/tsp/services/UserService.java b/services/src/main/java/edu/msudenver/tsp/services/UserService.java index f119441..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 139cd41..05872fc 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 @@ -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; - } 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..1d42311 --- /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.setAdministratorStatus(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 40afbe4..f3607b3 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