fix formatting

src/test/java/com/commafeed/backend/service/PubSubServiceTest.java

@@ -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);
 	}
 
 }

src/test/java/com/commafeed/backend/service/UserServiceTest.java

@@ -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());
 	}
 
 }