split client and server into maven modules

2026-03-21 21:37:29 +00:00 · 2022-08-13 10:34:59 +02:00
parent 4c4868a2b6
commit ac7b6eeb21
277 changed files with 645 additions and 521 deletions
--- a/commafeed-server/src/test/java/com/commafeed/backend/service/FeedEntryFilteringServiceTest.java
+++ b/commafeed-server/src/test/java/com/commafeed/backend/service/FeedEntryFilteringServiceTest.java
@@ -0,0 +1,86 @@
+package com.commafeed.backend.service;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.commafeed.backend.model.FeedEntry;
+import com.commafeed.backend.model.FeedEntryContent;
+import com.commafeed.backend.service.FeedEntryFilteringService.FeedEntryFilterException;
+
+class FeedEntryFilteringServiceTest {
+
+	private FeedEntryFilteringService service;
+
+	private FeedEntry entry;
+	private FeedEntryContent content;
+
+	@BeforeEach
+	public void init() {
+		service = new FeedEntryFilteringService();
+
+		entry = new FeedEntry();
+		entry.setUrl("https://github.com/Athou/commafeed");
+
+		content = new FeedEntryContent();
+		content.setAuthor("Athou");
+		content.setTitle("Merge pull request #662 from Athou/dw8");
+		content.setContent("Merge pull request #662 from Athou/dw8");
+		entry.setContent(content);
+
+	}
+
+	@Test
+	void emptyFilterMatchesFilter() throws FeedEntryFilterException {
+		Assertions.assertTrue(service.filterMatchesEntry(null, entry));
+	}
+
+	@Test
+	void blankFilterMatchesFilter() throws FeedEntryFilterException {
+		Assertions.assertTrue(service.filterMatchesEntry("", entry));
+	}
+
+	@Test
+	void simpleExpression() throws FeedEntryFilterException {
+		Assertions.assertTrue(service.filterMatchesEntry("author.toString() eq 'athou'", entry));
+	}
+
+	@Test
+	void newIsDisabled() throws FeedEntryFilterException {
+		Assertions.assertThrows(FeedEntryFilterException.class,
+				() -> service.filterMatchesEntry("null eq new ('java.lang.String', 'athou')", entry));
+	}
+
+	@Test
+	void getClassMethodIsDisabled() throws FeedEntryFilterException {
+		Assertions.assertThrows(FeedEntryFilterException.class, () -> service.filterMatchesEntry("null eq ''.getClass()", entry));
+	}
+
+	@Test
+	void dotClassIsDisabled() throws FeedEntryFilterException {
+		Assertions.assertTrue(service.filterMatchesEntry("null eq ''.class", entry));
+	}
+
+	@Test
+	void cannotLoopForever() throws FeedEntryFilterException {
+		Assertions.assertThrows(FeedEntryFilterException.class, () -> service.filterMatchesEntry("while(true) {}", entry));
+	}
+
+	@Test
+	void handlesNullCorrectly() throws FeedEntryFilterException {
+		entry.setUrl(null);
+		entry.setContent(new FeedEntryContent());
+		Assertions.assertDoesNotThrow(() -> service.filterMatchesEntry("author eq 'athou'", entry));
+	}
+
+	@Test
+	void incorrectScriptThrowsException() throws FeedEntryFilterException {
+		Assertions.assertThrows(FeedEntryFilterException.class, () -> service.filterMatchesEntry("aa eqz bb", entry));
+	}
+
+	@Test
+	void incorrectReturnTypeThrowsException() throws FeedEntryFilterException {
+		Assertions.assertThrows(FeedEntryFilterException.class, () -> service.filterMatchesEntry("1", entry));
+	}
+
+}
--- a/commafeed-server/src/test/java/com/commafeed/backend/service/PubSubServiceTest.java
+++ b/commafeed-server/src/test/java/com/commafeed/backend/service/PubSubServiceTest.java
@@ -0,0 +1,102 @@
+package com.commafeed.backend.service;
+
+import org.apache.http.HttpHeaders;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockserver.client.MockServerClient;
+import org.mockserver.junit.jupiter.MockServerExtension;
+import org.mockserver.model.HttpRequest;
+import org.mockserver.model.HttpResponse;
+import org.mockserver.model.MediaType;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.feed.FeedQueues;
+import com.commafeed.backend.model.Feed;
+
+@ExtendWith(MockServerExtension.class)
+class PubSubServiceTest {
+
+	@Mock(answer = Answers.RETURNS_DEEP_STUBS)
+	private CommaFeedConfiguration config;
+
+	@Mock
+	private FeedQueues queues;
+
+	@Mock
+	private Feed feed;
+
+	private MockServerClient client;
+	private PubSubService underTest;
+
+	@BeforeEach
+	public void init(MockServerClient client) {
+		MockitoAnnotations.openMocks(this);
+
+		this.client = client;
+		this.client.reset();
+
+		this.underTest = new PubSubService(config, queues);
+
+		Integer port = client.getPort();
+		String hubUrl = String.format("http://localhost:%s/hub", port);
+
+		// setup feed
+		feed = Mockito.mock(Feed.class);
+		Mockito.when(feed.getPushHub()).thenReturn(hubUrl);
+		Mockito.when(feed.getPushTopic()).thenReturn("foo");
+
+		// setup config
+		Mockito.when(config.getApplicationSettings().getPublicUrl()).thenReturn(hubUrl);
+	}
+
+	@Test
+	void subscribe200() {
+		// Arrange
+		client.when(HttpRequest.request().withMethod("POST")).respond(HttpResponse.response().withStatusCode(200));
+
+		// Act
+		underTest.subscribe(feed);
+
+		// Assert
+		client.verify(HttpRequest.request()
+				.withContentType(MediaType.APPLICATION_FORM_URLENCODED)
+				.withHeader(HttpHeaders.USER_AGENT, "CommaFeed")
+				.withMethod("POST")
+				.withPath("/hub"));
+		Mockito.verify(feed, Mockito.never()).setPushTopic(Mockito.anyString());
+		Mockito.verifyNoInteractions(queues);
+	}
+
+	@Test
+	void subscribe400WithPushpressError() {
+		// Arrange
+		client.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
+		Mockito.verify(feed).setPushTopic(Mockito.anyString());
+		Mockito.verify(queues).giveBack(feed);
+	}
+
+	@Test
+	void subscribe400WithoutPushpressError() {
+		// Arrange
+		client.when(HttpRequest.request().withMethod("POST")).respond(HttpResponse.response().withStatusCode(400));
+
+		// Act
+		underTest.subscribe(feed);
+
+		// Assert
+		Mockito.verify(feed, Mockito.never()).setPushTopic(Mockito.anyString());
+		Mockito.verifyNoInteractions(queues);
+	}
+
+}
--- a/commafeed-server/src/test/java/com/commafeed/backend/service/UserServiceTest.java
+++ b/commafeed-server/src/test/java/com/commafeed/backend/service/UserServiceTest.java
@@ -0,0 +1,194 @@
+package com.commafeed.backend.service;
+
+import java.util.Optional;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.dao.FeedCategoryDAO;
+import com.commafeed.backend.dao.FeedSubscriptionDAO;
+import com.commafeed.backend.dao.UserDAO;
+import com.commafeed.backend.dao.UserRoleDAO;
+import com.commafeed.backend.dao.UserSettingsDAO;
+import com.commafeed.backend.model.User;
+import com.commafeed.backend.service.internal.PostLoginActivities;
+
+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 FeedSubscriptionDAO feedSubscriptionDAO;
+	@Mock
+	private UserDAO userDAO;
+	@Mock
+	private UserSettingsDAO userSettingsDAO;
+	@Mock
+	private UserRoleDAO userRoleDAO;
+	@Mock
+	private PasswordEncryptionService passwordEncryptionService;
+	@Mock
+	private PostLoginActivities postLoginActivities;
+
+	private User disabledUser;
+	private User normalUser;
+
+	private UserService userService;
+
+	@BeforeEach
+	public void init() {
+		MockitoAnnotations.openMocks(this);
+
+		userService = new UserService(feedCategoryDAO, feedSubscriptionDAO, userDAO, userRoleDAO, userSettingsDAO,
+				passwordEncryptionService, commaFeedConfiguration, postLoginActivities);
+
+		disabledUser = new User();
+		disabledUser.setDisabled(true);
+
+		normalUser = new User();
+		normalUser.setDisabled(false);
+		normalUser.setSalt(SALT);
+		normalUser.setPassword(ENCRYPTED_PASSWORD);
+	}
+
+	@Test
+	void callingLoginShouldNotReturnUserObjectWhenGivenNullNameOrEmail() {
+		Optional<User> user = userService.login(null, "password");
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	void callingLoginShouldNotReturnUserObjectWhenGivenNullPassword() {
+		Optional<User> user = userService.login("testusername", null);
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	void callingLoginShouldLookupUserByName() {
+		userService.login("test", "password");
+		Mockito.verify(userDAO).findByName("test");
+	}
+
+	@Test
+	void callingLoginShouldLookupUserByEmailIfLookupByNameFailed() {
+		Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null);
+		userService.login("test@test.com", "password");
+		Mockito.verify(userDAO).findByEmail("test@test.com");
+	}
+
+	@Test
+	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");
+
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	void callingLoginShouldNotReturnUserObjectIfUserIsDisabled() {
+		Mockito.when(userDAO.findByName("test")).thenReturn(disabledUser);
+		Optional<User> user = userService.login("test", "password");
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	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");
+
+		Mockito.verify(passwordEncryptionService).authenticate("password", ENCRYPTED_PASSWORD, SALT);
+	}
+
+	@Test
+	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");
+
+		Assertions.assertFalse(authenticatedUser.isPresent());
+	}
+
+	@Test
+	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");
+
+		Mockito.verify(postLoginActivities).executeFor(normalUser);
+	}
+
+	@Test
+	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");
+
+		Assertions.assertTrue(authenticatedUser.isPresent());
+		Assertions.assertEquals(normalUser, authenticatedUser.get());
+	}
+
+	@Test
+	void apiLoginShouldNotReturnUserIfApikeyNull() {
+		Optional<User> user = userService.login(null);
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	void apiLoginShouldLookupUserByApikey() {
+		Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null);
+		userService.login("apikey");
+		Mockito.verify(userDAO).findByApiKey("apikey");
+	}
+
+	@Test
+	void apiLoginShouldNotReturnUserIfUserNotFoundFromLookupByApikey() {
+		Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null);
+		Optional<User> user = userService.login("apikey");
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	void apiLoginShouldNotReturnUserIfUserFoundFromApikeyLookupIsDisabled() {
+		Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(disabledUser);
+		Optional<User> user = userService.login("apikey");
+		Assertions.assertFalse(user.isPresent());
+	}
+
+	@Test
+	void apiLoginShouldPerformPostLoginActivitiesIfUserFoundFromApikeyLookupNotDisabled() {
+		Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
+		userService.login("apikey");
+		Mockito.verify(postLoginActivities).executeFor(normalUser);
+	}
+
+	@Test
+	void apiLoginShouldReturnUserIfUserFoundFromApikeyLookupNotDisabled() {
+		Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
+		Optional<User> returnedUser = userService.login("apikey");
+		Assertions.assertEquals(normalUser, returnedUser.get());
+	}
+
+}