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

fix formatting

Browse Source
This commit is contained in:
Athou
2022-01-02 20:55:46 +01:00
parent 089be99287
commit 4021389a4d
56 changed files with 563 additions and 562 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/test/java/com/commafeed/backend/FixedSizeSortedSetTest.java
View File

@@ -9,17 +9,18 @@ import org.junit.Test;
public class FixedSizeSortedSetTest {
private FixedSizeSortedSet<String> set;
private static Comparator<String> COMP = new Comparator<String>() {
private static final Comparator<String> COMP = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return ObjectUtils.compare(o1, o2);
}
};
private FixedSizeSortedSet<String> set;
@Before
public void init() {
set = new FixedSizeSortedSet<String>(3, COMP);
set = new FixedSizeSortedSet<>(3, COMP);
}
@Test

2
src/test/java/com/commafeed/backend/feed/FeedUtilsTest.java
View File

@@ -87,7 +87,7 @@ public class FeedUtilsTest {
}
@Test
public void testRemoveTrailingSlash_lastSlashOnly() {
public void testRemoveTrailingSlashLastSlashOnly() {
final String url = "http://localhost//";
final String result = FeedUtils.removeTrailingSlash(url);
Assert.assertEquals("http://localhost/", result);

74
src/test/java/com/commafeed/backend/opml/OPMLExporterTest.java
View File

@@ -1,16 +1,14 @@
package com.commafeed.backend.opml;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import com.commafeed.backend.dao.FeedCategoryDAO;
@@ -29,31 +27,31 @@ public class OPMLExporterTest {
@Mock
private FeedSubscriptionDAO feedSubscriptionDAO;
private User user = new User();
private final User user = new User();
private FeedCategory cat1 = new FeedCategory();
private FeedCategory cat2 = new FeedCategory();
private final FeedCategory cat1 = new FeedCategory();
private final FeedCategory cat2 = new FeedCategory();
private FeedSubscription rootFeed = newFeedSubscription("rootFeed", "rootFeed.com");
private FeedSubscription cat1Feed = newFeedSubscription("cat1Feed", "cat1Feed.com");
private FeedSubscription cat2Feed = newFeedSubscription("cat2Feed", "cat2Feed.com");
private final FeedSubscription rootFeed = newFeedSubscription("rootFeed", "rootFeed.com");
private final FeedSubscription cat1Feed = newFeedSubscription("cat1Feed", "cat1Feed.com");
private final FeedSubscription cat2Feed = newFeedSubscription("cat2Feed", "cat2Feed.com");
private List<FeedCategory> categories = new ArrayList<>();
private List<FeedSubscription> subscriptions = new ArrayList<>();
private final List<FeedCategory> categories = new ArrayList<>();
private final List<FeedSubscription> subscriptions = new ArrayList<>();
@Before
public void before_each_test() {
public void init() {
MockitoAnnotations.initMocks(this);
user.setName("John Doe");
cat1.setId(1l);
cat1.setId(1L);
cat1.setName("cat1");
cat1.setParent(null);
cat1.setChildren(new HashSet<FeedCategory>());
cat1.setSubscriptions(new HashSet<FeedSubscription>());
cat2.setId(2l);
cat2.setId(2L);
cat2.setName("cat2");
cat2.setParent(cat1);
cat2.setChildren(new HashSet<FeedCategory>());
@@ -90,51 +88,59 @@ public class OPMLExporterTest {
}
@Test
public void generates_OPML_correctly() {
when(feedCategoryDAO.findAll(user)).thenReturn(categories);
when(feedSubscriptionDAO.findAll(user)).thenReturn(subscriptions);
public void generatesOpmlCorrectly() {
Mockito.when(feedCategoryDAO.findAll(user)).thenReturn(categories);
Mockito.when(feedSubscriptionDAO.findAll(user)).thenReturn(subscriptions);
Opml opml = new OPMLExporter(feedCategoryDAO, feedSubscriptionDAO).export(user);
List<Outline> rootOutlines = opml.getOutlines();
assertEquals(2, rootOutlines.size());
assertTrue(containsCategory(rootOutlines, "cat1"));
assertTrue(containsFeed(rootOutlines, "rootFeed", "rootFeed.com"));
Assert.assertEquals(2, rootOutlines.size());
Assert.assertTrue(containsCategory(rootOutlines, "cat1"));
Assert.assertTrue(containsFeed(rootOutlines, "rootFeed", "rootFeed.com"));
Outline cat1Outline = getCategoryOutline(rootOutlines, "cat1");
List<Outline> cat1Children = cat1Outline.getChildren();
assertEquals(2, cat1Children.size());
assertTrue(containsCategory(cat1Children, "cat2"));
assertTrue(containsFeed(cat1Children, "cat1Feed", "cat1Feed.com"));
Assert.assertEquals(2, cat1Children.size());
Assert.assertTrue(containsCategory(cat1Children, "cat2"));
Assert.assertTrue(containsFeed(cat1Children, "cat1Feed", "cat1Feed.com"));
Outline cat2Outline = getCategoryOutline(cat1Children, "cat2");
List<Outline> cat2Children = cat2Outline.getChildren();
assertEquals(1, cat2Children.size());
assertTrue(containsFeed(cat2Children, "cat2Feed", "cat2Feed.com"));
Assert.assertEquals(1, cat2Children.size());
Assert.assertTrue(containsFeed(cat2Children, "cat2Feed", "cat2Feed.com"));
}
private boolean containsCategory(List<Outline> outlines, String category) {
for (Outline o : outlines)
if (!"rss".equals(o.getType()))
if (category.equals(o.getTitle()))
for (Outline o : outlines) {
if (!"rss".equals(o.getType())) {
if (category.equals(o.getTitle())) {
return true;
}
}
}
return false;
}
private boolean containsFeed(List<Outline> outlines, String title, String url) {
for (Outline o : outlines)
if ("rss".equals(o.getType()))
if (title.equals(o.getTitle()) && o.getAttributeValue("xmlUrl").equals(url))
for (Outline o : outlines) {
if ("rss".equals(o.getType())) {
if (title.equals(o.getTitle()) && o.getAttributeValue("xmlUrl").equals(url)) {
return true;
}
}
}
return false;
}
private Outline getCategoryOutline(List<Outline> outlines, String title) {
for (Outline o : outlines)
if (o.getTitle().equals(title))
for (Outline o : outlines) {
if (o.getTitle().equals(title)) {
return o;
}
}
return null;
}

62
src/test/java/com/commafeed/backend/service/PubSubServiceTest.java
View File

@@ -1,14 +1,5 @@
package com.commafeed.backend.service;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import static org.mockserver.model.HttpRequest.request;
import static org.mockserver.model.HttpResponse.response;
import org.apache.http.HttpHeaders;
import org.junit.Before;
import org.junit.Rule;
@@ -16,9 +7,12 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockserver.client.MockServerClient;
import org.mockserver.junit.MockServerRule;
import org.mockserver.model.HttpRequest;
import org.mockserver.model.HttpResponse;
import org.mockserver.model.MediaType;
import com.commafeed.CommaFeedConfiguration;
@@ -28,76 +22,78 @@ import com.commafeed.backend.model.Feed;
@RunWith(MockitoJUnitRunner.class)
public class PubSubServiceTest {
PubSubService underTest;
private PubSubService underTest;
@Rule
public MockServerRule mockServerRule = new MockServerRule(this, 22441);
public MockServerClient mockServerClient;
private final MockServerRule mockServerRule = new MockServerRule(this, 22441);
private MockServerClient mockServerClient;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
CommaFeedConfiguration config;
private CommaFeedConfiguration config;
@Mock
FeedQueues queues;
private FeedQueues queues;
@Mock
Feed feed;
private Feed feed;
@Before
public void init() {
underTest = new PubSubService(config, queues);
// setup feed
feed = mock(Feed.class);
when(feed.getPushHub()).thenReturn("http://localhost:22441/hub");
when(feed.getPushTopic()).thenReturn("foo");
feed = Mockito.mock(Feed.class);
Mockito.when(feed.getPushHub()).thenReturn("http://localhost:22441/hub");
Mockito.when(feed.getPushTopic()).thenReturn("foo");
// setup config
when(config.getApplicationSettings().getPublicUrl()).thenReturn("http://localhost:22441/hub");
Mockito.when(config.getApplicationSettings().getPublicUrl()).thenReturn("http://localhost:22441/hub");
}
@Test
public void subscribe_200() {
public void subscribe200() {
// Arrange
mockServerClient.when(request().withMethod("POST")).respond(response().withStatusCode(200));
mockServerClient.when(HttpRequest.request().withMethod("POST")).respond(HttpResponse.response().withStatusCode(200));
// Act
underTest.subscribe(feed);
// Assert
mockServerClient.verify(request().withContentType(MediaType.APPLICATION_FORM_URLENCODED)
mockServerClient.verify(HttpRequest.request()
.withContentType(MediaType.APPLICATION_FORM_URLENCODED)
.withHeader(HttpHeaders.USER_AGENT, "CommaFeed")
.withMethod("POST")
.withPath("/hub"));
verify(feed, never()).setPushTopic(anyString());
verifyZeroInteractions(queues);
Mockito.verify(feed, Mockito.never()).setPushTopic(Mockito.anyString());
Mockito.verifyZeroInteractions(queues);
}
@Test
public void subscribe_400_withPushpressError() {
public void subscribe400WithPushpressError() {
// Arrange
mockServerClient.when(request().withMethod("POST"))
.respond(response().withStatusCode(400).withBody(" is value is not allowed. You may only subscribe to"));
mockServerClient.when(HttpRequest.request().withMethod("POST"))
.respond(HttpResponse.response().withStatusCode(400).withBody(" is value is not allowed. You may only subscribe to"));
// Act
underTest.subscribe(feed);
// Assert
verify(feed).setPushTopic(anyString());
verify(queues).giveBack(feed);
Mockito.verify(feed).setPushTopic(Mockito.anyString());
Mockito.verify(queues).giveBack(feed);
}
@Test
public void subscribe_400_withoutPushpressError() {
public void subscribe400WithoutPushpressError() {
// Arrange
mockServerClient.when(request().withMethod("POST")).respond(response().withStatusCode(400));
mockServerClient.when(HttpRequest.request().withMethod("POST")).respond(HttpResponse.response().withStatusCode(400));
// Act
underTest.subscribe(feed);
// Assert
verify(feed, never()).setPushTopic(anyString());
verifyZeroInteractions(queues);
Mockito.verify(feed, Mockito.never()).setPushTopic(Mockito.anyString());
Mockito.verifyZeroInteractions(queues);
}
}

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

@@ -1,19 +1,12 @@
package com.commafeed.backend.service;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
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.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import com.commafeed.CommaFeedConfiguration;
@@ -53,7 +46,7 @@ public class UserServiceTest {
private UserService userService;
@Before
public void before_each_test() {
public void init() {
MockitoAnnotations.initMocks(this);
userService = new UserService(feedCategoryDAO, feedSubscriptionDAO, userDAO, userRoleDAO, userSettingsDAO,
@@ -69,129 +62,133 @@ public class UserServiceTest {
}
@Test
public void calling_login_should_not_return_user_object_when_given_null_nameOrEmail() {
public void callingLoginShouldNotReturnUserObjectWhenGivenNullNameOrEmail() {
Optional<User> user = userService.login(null, "password");
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@Test
public void calling_login_should_not_return_user_object_when_given_null_password() {
public void callingLoginShouldNotReturnUserObjectWhenGivenNullPassword() {
Optional<User> user = userService.login("testusername", null);
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@Test
public void calling_login_should_lookup_user_by_name() {
public void callingLoginShouldLookupUserByName() {
userService.login("test", "password");
verify(userDAO).findByName("test");
Mockito.verify(userDAO).findByName("test");
}
@Test
public void calling_login_should_lookup_user_by_email_if_lookup_by_name_failed() {
when(userDAO.findByName("test@test.com")).thenReturn(null);
public void callingLoginShouldLookupUserByEmailIfLookupByNameFailed() {
Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null);
userService.login("test@test.com", "password");
verify(userDAO).findByEmail("test@test.com");
Mockito.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() {
when(userDAO.findByName("test@test.com")).thenReturn(null);
when(userDAO.findByEmail("test@test.com")).thenReturn(null);
public void callingLoginShouldNotReturnUserObjectIfCouldNotFindUserByNameOrEmail() {
Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null);
Mockito.when(userDAO.findByEmail("test@test.com")).thenReturn(null);
Optional<User> user = userService.login("test@test.com", "password");
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@Test
public void calling_login_should_not_return_user_object_if_user_is_disabled() {
when(userDAO.findByName("test")).thenReturn(disabledUser);
public void callingLoginShouldNotReturnUserObjectIfUserIsDisabled() {
Mockito.when(userDAO.findByName("test")).thenReturn(disabledUser);
Optional<User> user = userService.login("test", "password");
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@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);
public void callingLoginShouldTryToAuthenticateUserWhoIsNotDisabled() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(false);
userService.login("test", "password");
verify(passwordEncryptionService).authenticate("password", ENCRYPTED_PASSWORD, SALT);
Mockito.verify(passwordEncryptionService).authenticate("password", ENCRYPTED_PASSWORD, SALT);
}
@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);
public void callingLoginShouldNotReturnUserObjectOnUnsuccessfulAuthentication() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(false);
Optional<User> authenticatedUser = userService.login("test", "password");
assertFalse(authenticatedUser.isPresent());
Assert.assertFalse(authenticatedUser.isPresent());
}
@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));
public void callingLoginShouldExecutePostLoginActivitiesForUserOnSuccessfulAuthentication() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(true);
Mockito.doNothing().when(postLoginActivities).executeFor(Mockito.any(User.class));
userService.login("test", "password");
verify(postLoginActivities).executeFor(normalUser);
Mockito.verify(postLoginActivities).executeFor(normalUser);
}
@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));
public void callingLoginShouldReturnUserObjectOnSuccessfulAuthentication() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(true);
Mockito.doNothing().when(postLoginActivities).executeFor(Mockito.any(User.class));
Optional<User> authenticatedUser = userService.login("test", "password");
assertTrue(authenticatedUser.isPresent());
assertEquals(normalUser, authenticatedUser.get());
Assert.assertTrue(authenticatedUser.isPresent());
Assert.assertEquals(normalUser, authenticatedUser.get());
}
@Test
public void api_login_should_not_return_user_if_apikey_null() {
public void apiLoginShouldNotReturnUserIfApikeyNull() {
Optional<User> user = userService.login(null);
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@Test
public void api_login_should_lookup_user_by_apikey() {
when(userDAO.findByApiKey("apikey")).thenReturn(null);
public void apiLoginShouldLookupUserByApikey() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null);
userService.login("apikey");
verify(userDAO).findByApiKey("apikey");
Mockito.verify(userDAO).findByApiKey("apikey");
}
@Test
public void api_login_should_not_return_user_if_user_not_found_from_lookup_by_apikey() {
when(userDAO.findByApiKey("apikey")).thenReturn(null);
public void apiLoginShouldNotReturnUserIfUserNotFoundFromLookupByApikey() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null);
Optional<User> user = userService.login("apikey");
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@Test
public void api_login_should_not_return_user_if_user_found_from_apikey_lookup_is_disabled() {
when(userDAO.findByApiKey("apikey")).thenReturn(disabledUser);
public void apiLoginShouldNotReturnUserIfUserFoundFromApikeyLookupIsDisabled() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(disabledUser);
Optional<User> user = userService.login("apikey");
assertFalse(user.isPresent());
Assert.assertFalse(user.isPresent());
}
@Test
public void api_login_should_perform_post_login_activities_if_user_found_from_apikey_lookup_not_disabled() {
when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
public void apiLoginShouldPerformPostLoginActivitiesIfUserFoundFromApikeyLookupNotDisabled() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
userService.login("apikey");
verify(postLoginActivities).executeFor(normalUser);
Mockito.verify(postLoginActivities).executeFor(normalUser);
}
@Test
public void api_login_should_return_user_if_user_found_from_apikey_lookup_not_disabled() {
when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
public void apiLoginShouldReturnUserIfUserFoundFromApikeyLookupNotDisabled() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
Optional<User> returnedUser = userService.login("apikey");
assertEquals(normalUser, returnedUser.get());
Assert.assertEquals(normalUser, returnedUser.get());
}
}

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

@@ -1,12 +1,9 @@
package com.commafeed.frontend.auth;
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 org.mockito.Mockito;
import com.commafeed.backend.model.User;
import com.commafeed.backend.service.UserService;
@@ -16,13 +13,13 @@ import com.commafeed.frontend.session.SessionHelper;
public class SecurityCheckFactoryTest {
@Test
public void cookie_login_should_perform_post_login_activities_if_user_is_logged_in() {
public void cookieLoginShouldPerformPostLoginActivities() {
User userInSession = new User();
SessionHelper sessionHelper = mock(SessionHelper.class);
when(sessionHelper.getLoggedInUser()).thenReturn(Optional.of(userInSession));
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
Mockito.when(sessionHelper.getLoggedInUser()).thenReturn(Optional.of(userInSession));
PostLoginActivities postLoginActivities = mock(PostLoginActivities.class);
PostLoginActivities postLoginActivities = Mockito.mock(PostLoginActivities.class);
UserService service = new UserService(null, null, null, null, null, null, null, postLoginActivities);
@@ -30,7 +27,7 @@ public class SecurityCheckFactoryTest {
factory.userService = service;
factory.cookieSessionLogin(sessionHelper);
verify(postLoginActivities).executeFor(userInSession);
Mockito.verify(postLoginActivities).executeFor(userInSession);
}
}

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

@@ -1,18 +1,12 @@
package com.commafeed.frontend.resource;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
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.ArgumentMatchers;
import org.mockito.InOrder;
import org.mockito.Matchers;
import org.mockito.Mockito;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.UserRole.Role;
@@ -24,16 +18,16 @@ import com.commafeed.frontend.session.SessionHelper;
public class UserRestTest {
@Test
public void login_should_not_populate_http_session_if_unsuccessfull() {
public void loginShouldNotPopulateHttpSessionIfUnsuccessfull() {
// Absent user
Optional<User> absentUser = Optional.empty();
// Create UserService partial mock
UserService service = mock(UserService.class);
when(service.login("user", "password")).thenReturn(absentUser);
UserService service = Mockito.mock(UserService.class);
Mockito.when(service.login("user", "password")).thenReturn(absentUser);
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
SessionHelper sessionHelper = mock(SessionHelper.class);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
LoginRequest req = new LoginRequest();
req.setName("user");
@@ -41,43 +35,43 @@ public class UserRestTest {
userREST.login(req, sessionHelper);
verify(sessionHelper, never()).setLoggedInUser(any(User.class));
Mockito.verify(sessionHelper, Mockito.never()).setLoggedInUser(Mockito.any(User.class));
}
@Test
public void login_should_populate_http_session_if_successfull() {
public void loginShouldPopulateHttpSessionIfSuccessfull() {
// Create a user
User user = new User();
// Create UserService mock
UserService service = mock(UserService.class);
when(service.login("user", "password")).thenReturn(Optional.of(user));
UserService service = Mockito.mock(UserService.class);
Mockito.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);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
userREST.login(req, sessionHelper);
verify(sessionHelper).setLoggedInUser(user);
Mockito.verify(sessionHelper).setLoggedInUser(user);
}
@Test
public void register_should_register_and_then_login() {
public void registerShouldRegisterAndThenLogin() {
// Create UserService mock
UserService service = mock(UserService.class);
UserService service = Mockito.mock(UserService.class);
RegistrationRequest req = new RegistrationRequest();
req.setName("user");
req.setPassword("password");
req.setEmail("test@test.com");
InOrder inOrder = inOrder(service);
InOrder inOrder = Mockito.inOrder(service);
SessionHelper sessionHelper = mock(SessionHelper.class);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
userREST.registerUser(req, sessionHelper);
@@ -87,26 +81,27 @@ public class UserRestTest {
}
@Test
public void register_should_populate_http_session() {
public void registerShouldPopulateHttpSession() {
// 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));
UserService service = Mockito.mock(UserService.class);
Mockito.when(service.register(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class),
ArgumentMatchers.anyList())).thenReturn(user);
Mockito.when(service.login(Mockito.any(String.class), Mockito.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);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
UserREST userREST = new UserREST(null, null, null, service, null, null, null);
userREST.registerUser(req, sessionHelper);
verify(sessionHelper).setLoggedInUser(user);
Mockito.verify(sessionHelper).setLoggedInUser(user);
}
}

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

@@ -1,9 +1,5 @@
package com.commafeed.frontend.session;
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;
@@ -11,27 +7,28 @@ import javax.servlet.http.HttpSession;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
import com.commafeed.backend.model.User;
public class SessionHelperTest {
private static String SESSION_KEY_USER = "user";
private static final String SESSION_KEY_USER = "user";
@Test
public void getting_user_does_not_create_a_session_if_not_present() {
HttpServletRequest request = mock(HttpServletRequest.class);
public void gettingUserDoesNotCreateSession() {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SessionHelper sessionHelper = new SessionHelper(request);
sessionHelper.getLoggedInUser();
verify(request).getSession(false);
Mockito.verify(request).getSession(false);
}
@Test
public void getting_user_should_not_return_user_if_there_is_no_preexisting_http_session() {
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getSession(false)).thenReturn(null);
public void gettingUserShouldNotReturnUserIfThereIsNoPreexistingHttpSession() {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
Mockito.when(request.getSession(false)).thenReturn(null);
SessionHelper sessionHelper = new SessionHelper(request);
Optional<User> user = sessionHelper.getLoggedInUser();
@@ -40,12 +37,12 @@ public class SessionHelperTest {
}
@Test
public void getting_user_should_not_return_user_if_user_not_present_in_http_session() {
HttpSession session = mock(HttpSession.class);
when(session.getAttribute(SESSION_KEY_USER)).thenReturn(null);
public void gettingUserShouldNotReturnUserIfUserNotPresentInHttpSession() {
HttpSession session = Mockito.mock(HttpSession.class);
Mockito.when(session.getAttribute(SESSION_KEY_USER)).thenReturn(null);
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getSession(false)).thenReturn(session);
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
Mockito.when(request.getSession(false)).thenReturn(session);
SessionHelper sessionHelper = new SessionHelper(request);
Optional<User> user = sessionHelper.getLoggedInUser();
@@ -54,14 +51,14 @@ public class SessionHelperTest {
}
@Test
public void getting_user_should_return_user_if_user_present_in_http_session() {
public void gettingUserShouldReturnUserIfUserPresentInHttpSession() {
User userInSession = new User();
HttpSession session = mock(HttpSession.class);
when(session.getAttribute(SESSION_KEY_USER)).thenReturn(userInSession);
HttpSession session = Mockito.mock(HttpSession.class);
Mockito.when(session.getAttribute(SESSION_KEY_USER)).thenReturn(userInSession);
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getSession(false)).thenReturn(session);
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
Mockito.when(request.getSession(false)).thenReturn(session);
SessionHelper sessionHelper = new SessionHelper(request);
Optional<User> user = sessionHelper.getLoggedInUser();