Archives/Athou_commafeed
1
0
Fork 1
mirror of https://github.com/Athou/commafeed.git synced 2026-03-21 21:37:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

use java8 optional

Browse Source
This commit is contained in:
Athou
2014-12-12 10:18:59 +01:00
parent 6c67e6363a
commit db03dd12a0
12 changed files with 151 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
src/test/java/com/commafeed/backend/service/UserServiceTest.java
View File

@@ -9,6 +9,8 @@ import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
@@ -20,161 +22,167 @@ import com.commafeed.backend.dao.UserDAO;
import com.commafeed.backend.dao.UserSettingsDAO;
import com.commafeed.backend.model.User;
import com.commafeed.backend.service.internal.PostLoginActivities;
import com.google.common.base.Optional;
public class UserServiceTest {
private static final byte[] SALT = new byte[]{1,2,3};
private static final byte[] ENCRYPTED_PASSWORD = new byte[]{5,6,7};
@Mock private CommaFeedConfiguration commaFeedConfiguration;
@Mock private FeedCategoryDAO feedCategoryDAO;
@Mock private UserDAO userDAO;
@Mock private UserSettingsDAO userSettingsDAO;
@Mock private PasswordEncryptionService passwordEncryptionService;
@Mock private PostLoginActivities postLoginActivities;
private static final byte[] SALT = new byte[] { 1, 2, 3 };
private static final byte[] ENCRYPTED_PASSWORD = new byte[] { 5, 6, 7 };
@Mock
private CommaFeedConfiguration commaFeedConfiguration;
@Mock
private FeedCategoryDAO feedCategoryDAO;
@Mock
private UserDAO userDAO;
@Mock
private UserSettingsDAO userSettingsDAO;
@Mock
private PasswordEncryptionService passwordEncryptionService;
@Mock
private PostLoginActivities postLoginActivities;
private User disabledUser;
private User normalUser;
private UserService userService;
@Before public void
before_each_test() {
@Before
public void before_each_test() {
MockitoAnnotations.initMocks(this);
userService = new UserService(feedCategoryDAO, userDAO, userSettingsDAO, passwordEncryptionService, commaFeedConfiguration, postLoginActivities);
userService = new UserService(feedCategoryDAO, userDAO, userSettingsDAO, passwordEncryptionService, commaFeedConfiguration,
postLoginActivities);
disabledUser = new User();
disabledUser.setDisabled(true);
normalUser = new User();
normalUser.setDisabled(false);
normalUser.setSalt(SALT);
normalUser.setPassword(ENCRYPTED_PASSWORD);
}
@Test public void
calling_login_should_not_return_user_object_when_given_null_nameOrEmail() {
@Test
public void calling_login_should_not_return_user_object_when_given_null_nameOrEmail() {
Optional<User> user = userService.login(null, "password");
assertFalse(user.isPresent());
}
@Test public void
calling_login_should_not_return_user_object_when_given_null_password() {
@Test
public void calling_login_should_not_return_user_object_when_given_null_password() {
Optional<User> user = userService.login("testusername", null);
assertFalse(user.isPresent());
}
@Test public void
calling_login_should_lookup_user_by_name() {
@Test
public void calling_login_should_lookup_user_by_name() {
userService.login("test", "password");
verify(userDAO).findByName("test");
}
@Test public void
calling_login_should_lookup_user_by_email_if_lookup_by_name_failed() {
@Test
public void calling_login_should_lookup_user_by_email_if_lookup_by_name_failed() {
when(userDAO.findByName("test@test.com")).thenReturn(null);
userService.login("test@test.com", "password");
verify(userDAO).findByEmail("test@test.com");
}
@Test public void
calling_login_should_not_return_user_object_if_could_not_find_user_by_name_or_email() {
@Test
public void calling_login_should_not_return_user_object_if_could_not_find_user_by_name_or_email() {
when(userDAO.findByName("test@test.com")).thenReturn(null);
when(userDAO.findByEmail("test@test.com")).thenReturn(null);
Optional<User> user = userService.login("test@test.com", "password");
assertFalse(user.isPresent());
}
@Test public void
calling_login_should_not_return_user_object_if_user_is_disabled() {
@Test
public void calling_login_should_not_return_user_object_if_user_is_disabled() {
when(userDAO.findByName("test")).thenReturn(disabledUser);
Optional<User> user = userService.login("test", "password");
assertFalse(user.isPresent());
}
@Test public void
calling_login_should_try_to_authenticate_user_who_is_not_disabled() {
@Test
public void calling_login_should_try_to_authenticate_user_who_is_not_disabled() {
when(userDAO.findByName("test")).thenReturn(normalUser);
when(passwordEncryptionService.authenticate(anyString(), any(byte[].class), any(byte[].class))).thenReturn(false);
userService.login("test", "password");
verify(passwordEncryptionService).authenticate("password", ENCRYPTED_PASSWORD, SALT);
}
@Test public void
calling_login_should_not_return_user_object_on_unsuccessful_authentication() {
@Test
public void calling_login_should_not_return_user_object_on_unsuccessful_authentication() {
when(userDAO.findByName("test")).thenReturn(normalUser);
when(passwordEncryptionService.authenticate(anyString(), any(byte[].class), any(byte[].class))).thenReturn(false);
Optional<User> authenticatedUser = userService.login("test", "password");
assertFalse(authenticatedUser.isPresent());
}
@Test public void
calling_login_should_execute_post_login_activities_for_user_on_successful_authentication() {
@Test
public void calling_login_should_execute_post_login_activities_for_user_on_successful_authentication() {
when(userDAO.findByName("test")).thenReturn(normalUser);
when(passwordEncryptionService.authenticate(anyString(), any(byte[].class), any(byte[].class))).thenReturn(true);
doNothing().when(postLoginActivities).executeFor(any(User.class));
userService.login("test", "password");
verify(postLoginActivities).executeFor(normalUser);
}
@Test public void
calling_login_should_return_user_object_on_successful_authentication() {
@Test
public void calling_login_should_return_user_object_on_successful_authentication() {
when(userDAO.findByName("test")).thenReturn(normalUser);
when(passwordEncryptionService.authenticate(anyString(), any(byte[].class), any(byte[].class))).thenReturn(true);
doNothing().when(postLoginActivities).executeFor(any(User.class));
Optional<User> authenticatedUser = userService.login("test", "password");
assertTrue(authenticatedUser.isPresent());
assertEquals(normalUser, authenticatedUser.get());
}
@Test public void
api_login_should_not_return_user_if_apikey_null() {
@Test
public void api_login_should_not_return_user_if_apikey_null() {
Optional<User> user = userService.login(null);
assertFalse(user.isPresent());
}
@Test public void
api_login_should_lookup_user_by_apikey() {
@Test
public void api_login_should_lookup_user_by_apikey() {
when(userDAO.findByApiKey("apikey")).thenReturn(null);
userService.login("apikey");
verify(userDAO).findByApiKey("apikey");
}
@Test public void
api_login_should_not_return_user_if_user_not_found_from_lookup_by_apikey() {
@Test
public void api_login_should_not_return_user_if_user_not_found_from_lookup_by_apikey() {
when(userDAO.findByApiKey("apikey")).thenReturn(null);
Optional<User> user = userService.login("apikey");
assertFalse(user.isPresent());
}
@Test public void
api_login_should_not_return_user_if_user_found_from_apikey_lookup_is_disabled() {
@Test
public void api_login_should_not_return_user_if_user_found_from_apikey_lookup_is_disabled() {
when(userDAO.findByApiKey("apikey")).thenReturn(disabledUser);
Optional<User> user = userService.login("apikey");
assertFalse(user.isPresent());
}
@Test public void
api_login_should_perform_post_login_activities_if_user_found_from_apikey_lookup_not_disabled() {
@Test
public void api_login_should_perform_post_login_activities_if_user_found_from_apikey_lookup_not_disabled() {
when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
userService.login("apikey");
verify(postLoginActivities).executeFor(normalUser);
}
@Test public void
api_login_should_return_user_if_user_found_from_apikey_lookup_not_disabled() {
@Test
public void api_login_should_return_user_if_user_found_from_apikey_lookup_not_disabled() {
when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
Optional<User> returnedUser = userService.login("apikey");
assertEquals(normalUser, returnedUser.get());

3
src/test/java/com/commafeed/frontend/auth/SecurityCheckFactoryTest.java
View File

@@ -4,13 +4,14 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Optional;
import org.junit.Test;
import com.commafeed.backend.model.User;
import com.commafeed.backend.service.UserService;
import com.commafeed.backend.service.internal.PostLoginActivities;
import com.commafeed.frontend.session.SessionHelper;
import com.google.common.base.Optional;
public class SecurityCheckFactoryTest {

68
src/test/java/com/commafeed/frontend/resource/UserRestTest.java
View File

@@ -8,6 +8,7 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Optional;
import org.junit.Test;
import org.mockito.InOrder;
@@ -19,93 +20,92 @@ import com.commafeed.backend.service.UserService;
import com.commafeed.frontend.model.request.LoginRequest;
import com.commafeed.frontend.model.request.RegistrationRequest;
import com.commafeed.frontend.session.SessionHelper;
import com.google.common.base.Optional;
public class UserRestTest {
@Test public void
login_should_not_populate_http_session_if_unsuccessfull() {
@Test
public void login_should_not_populate_http_session_if_unsuccessfull() {
// Absent user
Optional<User> absentUser = Optional.absent();
Optional<User> absentUser = Optional.empty();
// Create UserService partial mock
UserService service = mock(UserService.class);
when(service.login("user", "password")).thenReturn(absentUser);
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
SessionHelper sessionHelper = mock(SessionHelper.class);
LoginRequest req = new LoginRequest();
req.setName("user");
req.setPassword("password");
userREST.login(req, sessionHelper);
verify(sessionHelper, never()).setLoggedInUser(any(User.class));
}
@Test public void
login_should_populate_http_session_if_successfull() {
@Test
public void login_should_populate_http_session_if_successfull() {
// Create a user
User user = new User();
// Create UserService mock
UserService service = mock(UserService.class);
when(service.login("user", "password")).thenReturn(Optional.of(user));
LoginRequest req = new LoginRequest();
req.setName("user");
req.setPassword("password");
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
SessionHelper sessionHelper = mock(SessionHelper.class);
userREST.login(req, sessionHelper);
verify(sessionHelper).setLoggedInUser(user);
}
@Test public void
register_should_register_and_then_login() {
@Test
public void register_should_register_and_then_login() {
// Create UserService mock
UserService service = mock(UserService.class);
RegistrationRequest req = new RegistrationRequest();
req.setName("user");
req.setPassword("password");
req.setEmail("test@test.com");
InOrder inOrder = inOrder(service);
SessionHelper sessionHelper = mock(SessionHelper.class);
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
userREST.register(req, sessionHelper);
inOrder.verify(service).register("user", "password", "test@test.com", Arrays.asList(Role.USER));
inOrder.verify(service).login("user", "password");
}
@Test public void
register_should_populate_http_session() {
@Test
public void register_should_populate_http_session() {
// Create a user
User user = new User();
// Create UserService mock
UserService service = mock(UserService.class);
when(service.register(any(String.class), any(String.class), any(String.class), Matchers.anyListOf(Role.class))).thenReturn(user);
when(service.login(any(String.class), any(String.class))).thenReturn(Optional.of(user));
RegistrationRequest req = new RegistrationRequest();
req.setName("user");
req.setPassword("password");
req.setEmail("test@test.com");
SessionHelper sessionHelper = mock(SessionHelper.class);
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
userREST.register(req, sessionHelper);
verify(sessionHelper).setLoggedInUser(user);
}

3
src/test/java/com/commafeed/frontend/session/SessionHelperTest.java
View File

@@ -4,6 +4,8 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Optional;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
@@ -11,7 +13,6 @@ import org.junit.Assert;
import org.junit.Test;
import com.commafeed.backend.model.User;
import com.google.common.base.Optional;
public class SessionHelperTest {