Merge branches 'PAN-64' and 'master' of https://github.com/atusa17/ptp into PAN-64
This commit is contained in:
BrittanyBi
+85
@@ -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<Definition> 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<Definition> 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<Definition> 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<Definition> deletedDefinitionFoundById = definitionService.findById(createdDefinition.get().getId());
|
||||
|
||||
assertFalse(deletedDefinitionFoundById.isPresent());
|
||||
}
|
||||
|
||||
private Definition createDefinition() {
|
||||
final List<String> definitionList = new ArrayList<>();
|
||||
definitionList.add("Test definition 1");
|
||||
|
||||
final List<String> notationList = new ArrayList<>();
|
||||
notationList.add("\\testLaTeX");
|
||||
|
||||
final Definition definition = new Definition();
|
||||
definition.setName("Test Name");
|
||||
definition.setDefinition(definitionList);
|
||||
definition.setNotation(notationList);
|
||||
|
||||
return definition;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
+74
@@ -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 testCRUD() {
|
||||
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.isAdministrator());
|
||||
|
||||
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.isAdministrator());
|
||||
|
||||
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.isAdministrator());
|
||||
|
||||
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.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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
persistence.api.connection.timeout.milliseconds=5000
|
||||
persistence.api.socket.timeout.milliseconds=10000
|
||||
persistence.api.base.url=http://localhost:8090/
|
||||
@@ -0,0 +1,186 @@
|
||||
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.http.HttpStatus;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
@Slf4j
|
||||
@Service
|
||||
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<List<Definition>> getAllDefinitions() {
|
||||
final Instant start = Instant.now();
|
||||
|
||||
try {
|
||||
final TypeToken<List<Definition>> typeToken = new TypeToken<List<Definition>>(){};
|
||||
final Optional<List<Definition>> 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<Definition> 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<Definition> typeToken = new TypeToken<Definition>(){};
|
||||
final Optional<Definition> persistenceApiResponse = restService.get(persistenceApiBaseUrl + "definitions/" + 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<Definition> 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<Definition> typeToken = new TypeToken<Definition>() {};
|
||||
final Optional<Definition> persistenceApiResponse = restService.post(persistenceApiBaseUrl + "definitions/",
|
||||
new GsonBuilder().create().toJson(definition),
|
||||
typeToken,
|
||||
connectionTimeoutMilliseconds,
|
||||
socketTimeoutMilliseconds);
|
||||
|
||||
if (persistenceApiResponse.isPresent()) {
|
||||
LOG.info("Creation successful. Returning {}", persistenceApiResponse.get());
|
||||
} else {
|
||||
LOG.info("Unable to create new definition {}", definition);
|
||||
}
|
||||
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
public Optional<Definition> updateDefinition(final Definition definition) {
|
||||
if (definition == null) {
|
||||
LOG.error("Given null definition, returning {}");
|
||||
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();
|
||||
|
||||
try {
|
||||
final TypeToken<Definition> typeToken = new TypeToken<Definition>(){};
|
||||
final Optional<Definition> persistenceApiResponse = restService.patch(persistenceApiBaseUrl + "definitions/" + definition.getId(),
|
||||
new GsonBuilder().create().toJson(definition),
|
||||
typeToken,
|
||||
connectionTimeoutMilliseconds,
|
||||
socketTimeoutMilliseconds);
|
||||
|
||||
if (persistenceApiResponse.isPresent()) {
|
||||
LOG.info("Update successful. Returning {}", persistenceApiResponse.get());
|
||||
} else {
|
||||
LOG.info("Unable to update definition {}", definition);
|
||||
}
|
||||
|
||||
return persistenceApiResponse;
|
||||
} 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());
|
||||
}
|
||||
}
|
||||
|
||||
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 + "definitions/" + 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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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 {
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
@NotNull @SerializedName("administrator_status") private boolean administratorStatus;
|
||||
@Size(max = 50) private String username;
|
||||
@Size(max = 256) private String password;
|
||||
@NotNull private boolean administrator;
|
||||
@Temporal(TemporalType.DATE) @SerializedName("last_login") private Date lastLogin;
|
||||
|
||||
private static final long serialVersionUID = 7095627971593953734L;
|
||||
|
||||
}
|
||||
|
||||
@@ -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<String> definition;
|
||||
private List<String> notation;
|
||||
|
||||
private static final long serialVersionUID = 3412178112996807691L;
|
||||
|
||||
public interface Insert {}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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/
|
||||
@@ -0,0 +1,290 @@
|
||||
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.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.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class DefinitionServiceTest {
|
||||
@Mock private RestService restService;
|
||||
@InjectMocks private DefinitionService definitionService;
|
||||
|
||||
@Test
|
||||
public void testGetAllDefinitions() {
|
||||
final List<Definition> definitionList = new ArrayList<>();
|
||||
final Definition testDefinition = createDefinition();
|
||||
definitionList.add(testDefinition);
|
||||
definitionList.add(testDefinition);
|
||||
|
||||
when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString()))
|
||||
.thenReturn(Optional.of(definitionList));
|
||||
|
||||
final Optional<List<Definition>> listOfDefinitions = definitionService.getAllDefinitions();
|
||||
|
||||
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_RequestReturnsEmptyOptional() {
|
||||
when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString()))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
final Optional<List<Definition>> listOfDefinitions = definitionService.getAllDefinitions();
|
||||
|
||||
assertFalse(listOfDefinitions.isPresent());
|
||||
verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAllDefinitions_ExceptionThrownWhenSendingRequest() {
|
||||
when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString()))
|
||||
.thenThrow(new UnsupportedOperationException("Test exception"));
|
||||
|
||||
final Optional<List<Definition>> 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<Definition> 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_RequestReturnsEmptyOptional() {
|
||||
when(restService.get(anyString(), any(), anyInt(), anyInt(), anyString()))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
final Optional<Definition> 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<Definition> exceptionThrowingDefinition = definitionService.findById(1);
|
||||
|
||||
assertFalse(exceptionThrowingDefinition.isPresent());
|
||||
verify(restService).get(anyString(), any(), anyInt(), anyInt(), anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindById_IdIsZero() {
|
||||
final Optional<Definition> impossibleDefinition = definitionService.findById(0);
|
||||
|
||||
assertFalse(impossibleDefinition.isPresent());
|
||||
verifyZeroInteractions(restService);
|
||||
}
|
||||
|
||||
@Test
|
||||
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<Definition> createdDefinition = definitionService.createDefinition(testDefinition);
|
||||
|
||||
assertNotNull(createdDefinition);
|
||||
assertTrue(createdDefinition.isPresent());
|
||||
assertEquals(testDefinition, createdDefinition.get());
|
||||
verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateDefinition_NullDefinition() {
|
||||
final Optional<Definition> nullDefinition = definitionService.createDefinition(null);
|
||||
|
||||
assertFalse(nullDefinition.isPresent());
|
||||
verifyZeroInteractions(restService);
|
||||
}
|
||||
|
||||
@Test
|
||||
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<Definition> createdDefinition = definitionService.createDefinition(testDefinition);
|
||||
|
||||
assertNotNull(createdDefinition);
|
||||
assertFalse(createdDefinition.isPresent());
|
||||
verify(restService).post(anyString(), eq(testDefinitionJson), any(), anyInt(), anyInt());
|
||||
}
|
||||
|
||||
@Test
|
||||
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<Definition> createdDefinition = definitionService.createDefinition(testDefinition);
|
||||
|
||||
assertNotNull(createdDefinition);
|
||||
assertFalse(createdDefinition.isPresent());
|
||||
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<Definition> 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<Definition> testUpdate = definitionService.updateDefinition(null);
|
||||
|
||||
assertFalse(testUpdate.isPresent());
|
||||
verifyZeroInteractions(restService);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateDefinition_IdIsZero() {
|
||||
final Definition impossibleDefinition = createDefinition();
|
||||
impossibleDefinition.setId(0);
|
||||
|
||||
final Optional<Definition> 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<Definition> 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<Definition> exceptionThrowingDefinition = definitionService.updateDefinition(createDefinition());
|
||||
|
||||
assertFalse(exceptionThrowingDefinition.isPresent());
|
||||
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<String> definitionList = new ArrayList<>();
|
||||
definitionList.add("Test definition 1");
|
||||
|
||||
final List<String> notationList = new ArrayList<>();
|
||||
notationList.add("\\testLaTeX");
|
||||
|
||||
final Definition definition = new Definition();
|
||||
definition.setName("Test Name");
|
||||
definition.setDefinition(definitionList);
|
||||
definition.setNotation(notationList);
|
||||
definition.setId(1);
|
||||
|
||||
return definition;
|
||||
}
|
||||
}
|
||||
@@ -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.setAdministrator(true);
|
||||
account.setLastLogin(new Date());
|
||||
return account;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user