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 21:32:40 +01:00
parent b132178228
commit 78b637c83b
15 changed files with 642 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/com/commafeed/CommaFeedApplication.java
View File

@@ -141,7 +141,9 @@ public class CommaFeedApplication extends Application<CommaFeedConfiguration> {
// Scheduled tasks // Scheduled tasks
Set<ScheduledTask> tasks = injector.getInstance(Key.get(new TypeLiteral<Set<ScheduledTask>>() { Set<ScheduledTask> tasks = injector.getInstance(Key.get(new TypeLiteral<Set<ScheduledTask>>() {
})); }));
ScheduledExecutorService executor = environment.lifecycle().scheduledExecutorService("task-scheduler", true).threads(tasks.size()) ScheduledExecutorService executor = environment.lifecycle()
.scheduledExecutorService("task-scheduler", true)
.threads(tasks.size())
.build(); .build();
for (ScheduledTask task : tasks) { for (ScheduledTask task : tasks) {
task.register(executor); task.register(executor);

120
src/main/java/com/commafeed/backend/ContentEncodingInterceptor.java
View File

@@ -1,60 +1,60 @@
package com.commafeed.backend; package com.commafeed.backend;
import java.io.IOException; import java.io.IOException;
import java.util.Arrays; import java.util.Arrays;
import java.util.HashSet; import java.util.HashSet;
import java.util.Locale; import java.util.Locale;
import java.util.Set; import java.util.Set;
import org.apache.http.Header; import org.apache.http.Header;
import org.apache.http.HeaderElement; import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity; import org.apache.http.HttpEntity;
import org.apache.http.HttpException; import org.apache.http.HttpException;
import org.apache.http.HttpResponse; import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor; import org.apache.http.HttpResponseInterceptor;
import org.apache.http.entity.HttpEntityWrapper; import org.apache.http.entity.HttpEntityWrapper;
import org.apache.http.protocol.HttpContext; import org.apache.http.protocol.HttpContext;
class ContentEncodingInterceptor implements HttpResponseInterceptor { class ContentEncodingInterceptor implements HttpResponseInterceptor {
private static final Set<String> ALLOWED_CONTENT_ENCODINGS = new HashSet<>(Arrays.asList("gzip", "x-gzip", "deflate", "identity")); private static final Set<String> ALLOWED_CONTENT_ENCODINGS = new HashSet<>(Arrays.asList("gzip", "x-gzip", "deflate", "identity"));
@Override @Override
public void process(HttpResponse response, HttpContext context) throws HttpException, IOException { public void process(HttpResponse response, HttpContext context) throws HttpException, IOException {
if (hasContent(response)) { if (hasContent(response)) {
Header contentEncodingHeader = response.getEntity().getContentEncoding(); Header contentEncodingHeader = response.getEntity().getContentEncoding();
if (contentEncodingHeader != null && containsUnsupportedEncodings(contentEncodingHeader)) { if (contentEncodingHeader != null && containsUnsupportedEncodings(contentEncodingHeader)) {
overrideContentEncoding(response); overrideContentEncoding(response);
} }
} }
} }
private boolean containsUnsupportedEncodings(Header contentEncodingHeader) { private boolean containsUnsupportedEncodings(Header contentEncodingHeader) {
HeaderElement[] codecs = contentEncodingHeader.getElements(); HeaderElement[] codecs = contentEncodingHeader.getElements();
for (final HeaderElement codec : codecs) { for (final HeaderElement codec : codecs) {
String codecName = codec.getName().toLowerCase(Locale.US); String codecName = codec.getName().toLowerCase(Locale.US);
if (!ALLOWED_CONTENT_ENCODINGS.contains(codecName)) { if (!ALLOWED_CONTENT_ENCODINGS.contains(codecName)) {
return true; return true;
} }
} }
return false; return false;
} }
private void overrideContentEncoding(HttpResponse response) { private void overrideContentEncoding(HttpResponse response) {
HttpEntity wrapped = new HttpEntityWrapper(response.getEntity()) { HttpEntity wrapped = new HttpEntityWrapper(response.getEntity()) {
@Override @Override
public Header getContentEncoding() { public Header getContentEncoding() {
return null; return null;
} }
}; };
response.setEntity(wrapped); response.setEntity(wrapped);
} }
private boolean hasContent(HttpResponse response) { private boolean hasContent(HttpResponse response) {
return response.getEntity() != null && response.getEntity().getContentLength() != 0; return response.getEntity() != null && response.getEntity().getContentLength() != 0;
} }
} }

8
src/main/java/com/commafeed/backend/dao/FeedEntryContentDAO.java
View File

@@ -16,8 +16,8 @@ import com.querydsl.jpa.JPQLQuery;
@Singleton @Singleton
public class FeedEntryContentDAO extends GenericDAO<FeedEntryContent> { public class FeedEntryContentDAO extends GenericDAO<FeedEntryContent> {
private QFeedEntryContent content = QFeedEntryContent.feedEntryContent; private final QFeedEntryContent content = QFeedEntryContent.feedEntryContent;
private QFeedEntry entry = QFeedEntry.feedEntry; private final QFeedEntry entry = QFeedEntry.feedEntry;
@Inject @Inject
public FeedEntryContentDAO(SessionFactory sessionFactory) { public FeedEntryContentDAO(SessionFactory sessionFactory) {
@@ -25,7 +25,9 @@ public class FeedEntryContentDAO extends GenericDAO<FeedEntryContent> {
} }
public Long findExisting(String contentHash, String titleHash) { public Long findExisting(String contentHash, String titleHash) {
return query().select(content.id).from(content).where(content.contentHash.eq(contentHash), content.titleHash.eq(titleHash)) return query().select(content.id)
.from(content)
.where(content.contentHash.eq(contentHash), content.titleHash.eq(titleHash))
.fetchFirst(); .fetchFirst();
} }

11
src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java
View File

@@ -29,13 +29,20 @@ public class FeedEntryDAO extends GenericDAO<FeedEntry> {
} }
public Long findExisting(String guid, Feed feed) { public Long findExisting(String guid, Feed feed) {
return query().select(entry.id).from(entry).where(entry.guidHash.eq(DigestUtils.sha1Hex(guid)), entry.feed.eq(feed)).limit(1) return query().select(entry.id)
.from(entry)
.where(entry.guidHash.eq(DigestUtils.sha1Hex(guid)), entry.feed.eq(feed))
.limit(1)
.fetchOne(); .fetchOne();
} }
public List<FeedCapacity> findFeedsExceedingCapacity(long maxCapacity, long max) { public List<FeedCapacity> findFeedsExceedingCapacity(long maxCapacity, long max) {
NumberExpression<Long> count = entry.id.count(); NumberExpression<Long> count = entry.id.count();
List<Tuple> tuples = query().select(entry.feed.id, count).from(entry).groupBy(entry.feed).having(count.gt(maxCapacity)).limit(max) List<Tuple> tuples = query().select(entry.feed.id, count)
.from(entry)
.groupBy(entry.feed)
.having(count.gt(maxCapacity))
.limit(max)
.fetch(); .fetch();
return tuples.stream().map(t -> new FeedCapacity(t.get(entry.feed.id), t.get(count))).collect(Collectors.toList()); return tuples.stream().map(t -> new FeedCapacity(t.get(entry.feed.id), t.get(count))).collect(Collectors.toList());
} }

21
src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java
View File

@@ -29,8 +29,13 @@ public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
} }
public FeedSubscription findById(User user, Long id) { public FeedSubscription findById(User user, Long id) {
List<FeedSubscription> subs = query().selectFrom(sub).where(sub.user.eq(user), sub.id.eq(id)).leftJoin(sub.feed).fetchJoin() List<FeedSubscription> subs = query().selectFrom(sub)
.leftJoin(sub.category).fetchJoin().fetch(); .where(sub.user.eq(user), sub.id.eq(id))
.leftJoin(sub.feed)
.fetchJoin()
.leftJoin(sub.category)
.fetchJoin()
.fetch();
return initRelations(Iterables.getFirst(subs, null)); return initRelations(Iterables.getFirst(subs, null));
} }
@@ -44,8 +49,13 @@ public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
} }
public List<FeedSubscription> findAll(User user) { public List<FeedSubscription> findAll(User user) {
List<FeedSubscription> subs = query().selectFrom(sub).where(sub.user.eq(user)).leftJoin(sub.feed).fetchJoin().leftJoin(sub.category) List<FeedSubscription> subs = query().selectFrom(sub)
.fetchJoin().fetch(); .where(sub.user.eq(user))
.leftJoin(sub.feed)
.fetchJoin()
.leftJoin(sub.category)
.fetchJoin()
.fetch();
return initRelations(subs); return initRelations(subs);
} }
@@ -61,7 +71,8 @@ public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
public List<FeedSubscription> findByCategories(User user, List<FeedCategory> categories) { public List<FeedSubscription> findByCategories(User user, List<FeedCategory> categories) {
Set<Long> categoryIds = categories.stream().map(c -> c.getId()).collect(Collectors.toSet()); Set<Long> categoryIds = categories.stream().map(c -> c.getId()).collect(Collectors.toSet());
return findAll(user).stream().filter(s -> s.getCategory() != null && categoryIds.contains(s.getCategory().getId())) return findAll(user).stream()
.filter(s -> s.getCategory() != null && categoryIds.contains(s.getCategory().getId()))
.collect(Collectors.toList()); .collect(Collectors.toList());
} }

6
src/main/java/com/commafeed/backend/opml/OPMLExporter.java
View File

@@ -61,13 +61,15 @@ public class OPMLExporter {
outline.setText(cat.getName()); outline.setText(cat.getName());
outline.setTitle(cat.getName()); outline.setTitle(cat.getName());
for (FeedCategory child : categories.stream().filter(c -> c.getParent() != null && c.getParent().getId().equals(cat.getId())) for (FeedCategory child : categories.stream()
.filter(c -> c.getParent() != null && c.getParent().getId().equals(cat.getId()))
.collect(Collectors.toList())) { .collect(Collectors.toList())) {
outline.getChildren().add(buildCategoryOutline(child, categories, subscriptions)); outline.getChildren().add(buildCategoryOutline(child, categories, subscriptions));
} }
for (FeedSubscription sub : subscriptions.stream() for (FeedSubscription sub : subscriptions.stream()
.filter(s -> s.getCategory() != null && s.getCategory().getId().equals(cat.getId())).collect(Collectors.toList())) { .filter(s -> s.getCategory() != null && s.getCategory().getId().equals(cat.getId()))
.collect(Collectors.toList())) {
outline.getChildren().add(buildSubscriptionOutline(sub)); outline.getChildren().add(buildSubscriptionOutline(sub));
} }
return outline; return outline;

92
src/main/java/com/commafeed/backend/service/internal/PostLoginActivities.java
View File

@@ -1,46 +1,46 @@
package com.commafeed.backend.service.internal; package com.commafeed.backend.service.internal;
import java.util.Date; import java.util.Date;
import javax.inject.Inject; import javax.inject.Inject;
import javax.inject.Singleton; import javax.inject.Singleton;
import org.apache.commons.lang3.time.DateUtils; import org.apache.commons.lang3.time.DateUtils;
import com.commafeed.CommaFeedConfiguration; import com.commafeed.CommaFeedConfiguration;
import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.dao.UserDAO;
import com.commafeed.backend.model.User; import com.commafeed.backend.model.User;
import com.commafeed.backend.service.FeedSubscriptionService; import com.commafeed.backend.service.FeedSubscriptionService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor(onConstructor = @__({ @Inject })) @RequiredArgsConstructor(onConstructor = @__({ @Inject }))
@Singleton @Singleton
public class PostLoginActivities { public class PostLoginActivities {
private final UserDAO userDAO; private final UserDAO userDAO;
private final FeedSubscriptionService feedSubscriptionService; private final FeedSubscriptionService feedSubscriptionService;
private final CommaFeedConfiguration config; private final CommaFeedConfiguration config;
public void executeFor(User user) { public void executeFor(User user) {
Date lastLogin = user.getLastLogin(); Date lastLogin = user.getLastLogin();
Date now = new Date(); Date now = new Date();
boolean saveUser = false; boolean saveUser = false;
// only update lastLogin field every hour in order to not // only update lastLogin field every hour in order to not
// invalidate the cache every time someone logs in // invalidate the cache every time someone logs in
if (lastLogin == null || lastLogin.before(DateUtils.addHours(now, -1))) { if (lastLogin == null || lastLogin.before(DateUtils.addHours(now, -1))) {
user.setLastLogin(now); user.setLastLogin(now);
saveUser = true; saveUser = true;
} }
if (config.getApplicationSettings().getHeavyLoad() && user.shouldRefreshFeedsAt(now)) { if (config.getApplicationSettings().getHeavyLoad() && user.shouldRefreshFeedsAt(now)) {
feedSubscriptionService.refreshAll(user); feedSubscriptionService.refreshAll(user);
user.setLastFullRefresh(now); user.setLastFullRefresh(now);
saveUser = true; saveUser = true;
} }
if (saveUser) { if (saveUser) {
userDAO.saveOrUpdate(user); userDAO.saveOrUpdate(user);
} }
} }
} }

4
src/main/java/com/commafeed/backend/task/ScheduledTask.java
View File

@@ -26,8 +26,8 @@ public abstract class ScheduledTask {
} }
} }
}; };
log.info("registering task {} for execution every {} {}, starting in {} {}", getClass().getSimpleName(), getPeriod(), log.info("registering task {} for execution every {} {}, starting in {} {}", getClass().getSimpleName(), getPeriod(), getTimeUnit(),
getTimeUnit(), getInitialDelay(), getTimeUnit()); getInitialDelay(), getTimeUnit());
executor.scheduleWithFixedDelay(runnable, getInitialDelay(), getPeriod(), getTimeUnit()); executor.scheduleWithFixedDelay(runnable, getInitialDelay(), getPeriod(), getTimeUnit());
} }
} }

15
src/main/java/com/commafeed/frontend/resource/CategoryREST.java
View File

@@ -145,16 +145,18 @@ public class CategoryREST {
offset, limit + 1, order, true, onlyIds, tag); offset, limit + 1, order, true, onlyIds, tag);
for (FeedEntryStatus status : list) { for (FeedEntryStatus status : list) {
entries.getEntries().add(Entry.build(status, config.getApplicationSettings().getPublicUrl(), entries.getEntries()
config.getApplicationSettings().getImageProxyEnabled())); .add(Entry.build(status, config.getApplicationSettings().getPublicUrl(),
config.getApplicationSettings().getImageProxyEnabled()));
} }
} else if (STARRED.equals(id)) { } else if (STARRED.equals(id)) {
entries.setName("Starred"); entries.setName("Starred");
List<FeedEntryStatus> starred = feedEntryStatusDAO.findStarred(user, newerThanDate, offset, limit + 1, order, !onlyIds); List<FeedEntryStatus> starred = feedEntryStatusDAO.findStarred(user, newerThanDate, offset, limit + 1, order, !onlyIds);
for (FeedEntryStatus status : starred) { for (FeedEntryStatus status : starred) {
entries.getEntries().add(Entry.build(status, config.getApplicationSettings().getPublicUrl(), entries.getEntries()
config.getApplicationSettings().getImageProxyEnabled())); .add(Entry.build(status, config.getApplicationSettings().getPublicUrl(),
config.getApplicationSettings().getImageProxyEnabled()));
} }
} else { } else {
FeedCategory parent = feedCategoryDAO.findById(user, Long.valueOf(id)); FeedCategory parent = feedCategoryDAO.findById(user, Long.valueOf(id));
@@ -166,8 +168,9 @@ public class CategoryREST {
offset, limit + 1, order, true, onlyIds, tag); offset, limit + 1, order, true, onlyIds, tag);
for (FeedEntryStatus status : list) { for (FeedEntryStatus status : list) {
entries.getEntries().add(Entry.build(status, config.getApplicationSettings().getPublicUrl(), entries.getEntries()
config.getApplicationSettings().getImageProxyEnabled())); .add(Entry.build(status, config.getApplicationSettings().getPublicUrl(),
config.getApplicationSettings().getImageProxyEnabled()));
} }
entries.setName(parent.getName()); entries.setName(parent.getName());
} else { } else {

80
src/main/java/com/commafeed/frontend/session/SessionHelper.java
View File

@@ -1,40 +1,40 @@
package com.commafeed.frontend.session; package com.commafeed.frontend.session;
import java.util.Optional; import java.util.Optional;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession; import javax.servlet.http.HttpSession;
import com.commafeed.backend.model.User; import com.commafeed.backend.model.User;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor() @RequiredArgsConstructor()
public class SessionHelper { public class SessionHelper {
private static final String SESSION_KEY_USER = "user"; private static final String SESSION_KEY_USER = "user";
private final HttpServletRequest request; private final HttpServletRequest request;
public Optional<User> getLoggedInUser() { public Optional<User> getLoggedInUser() {
Optional<HttpSession> session = getSession(false); Optional<HttpSession> session = getSession(false);
if (session.isPresent()) { if (session.isPresent()) {
User user = (User) session.get().getAttribute(SESSION_KEY_USER); User user = (User) session.get().getAttribute(SESSION_KEY_USER);
return Optional.ofNullable(user); return Optional.ofNullable(user);
} }
return Optional.empty(); return Optional.empty();
} }
public void setLoggedInUser(User user) { public void setLoggedInUser(User user) {
Optional<HttpSession> session = getSession(true); Optional<HttpSession> session = getSession(true);
session.get().setAttribute(SESSION_KEY_USER, user); session.get().setAttribute(SESSION_KEY_USER, user);
} }
private Optional<HttpSession> getSession(boolean force) { private Optional<HttpSession> getSession(boolean force) {
HttpSession session = request.getSession(force); HttpSession session = request.getSession(force);
return Optional.ofNullable(session); return Optional.ofNullable(session);
} }
} }

32
src/main/java/com/commafeed/frontend/session/SessionHelperFactory.java
View File

@@ -1,17 +1,17 @@
package com.commafeed.frontend.session; package com.commafeed.frontend.session;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.core.Context; import javax.ws.rs.core.Context;
import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory; import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory;
public class SessionHelperFactory extends AbstractContainerRequestValueFactory<SessionHelper> { public class SessionHelperFactory extends AbstractContainerRequestValueFactory<SessionHelper> {
@Context @Context
HttpServletRequest request; HttpServletRequest request;
@Override @Override
public SessionHelper provide() { public SessionHelper provide() {
return new SessionHelper(request); return new SessionHelper(request);
} }
} }

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

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

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

@@ -1,194 +1,194 @@
package com.commafeed.backend.service; package com.commafeed.backend.service;
import java.util.Optional; import java.util.Optional;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import com.commafeed.CommaFeedConfiguration; import com.commafeed.CommaFeedConfiguration;
import com.commafeed.backend.dao.FeedCategoryDAO; import com.commafeed.backend.dao.FeedCategoryDAO;
import com.commafeed.backend.dao.FeedSubscriptionDAO; import com.commafeed.backend.dao.FeedSubscriptionDAO;
import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.dao.UserDAO;
import com.commafeed.backend.dao.UserRoleDAO; import com.commafeed.backend.dao.UserRoleDAO;
import com.commafeed.backend.dao.UserSettingsDAO; import com.commafeed.backend.dao.UserSettingsDAO;
import com.commafeed.backend.model.User; import com.commafeed.backend.model.User;
import com.commafeed.backend.service.internal.PostLoginActivities; import com.commafeed.backend.service.internal.PostLoginActivities;
public class UserServiceTest { public class UserServiceTest {
private static final byte[] SALT = new byte[] { 1, 2, 3 }; private static final byte[] SALT = new byte[] { 1, 2, 3 };
private static final byte[] ENCRYPTED_PASSWORD = new byte[] { 5, 6, 7 }; private static final byte[] ENCRYPTED_PASSWORD = new byte[] { 5, 6, 7 };
@Mock @Mock
private CommaFeedConfiguration commaFeedConfiguration; private CommaFeedConfiguration commaFeedConfiguration;
@Mock @Mock
private FeedCategoryDAO feedCategoryDAO; private FeedCategoryDAO feedCategoryDAO;
@Mock @Mock
private FeedSubscriptionDAO feedSubscriptionDAO; private FeedSubscriptionDAO feedSubscriptionDAO;
@Mock @Mock
private UserDAO userDAO; private UserDAO userDAO;
@Mock @Mock
private UserSettingsDAO userSettingsDAO; private UserSettingsDAO userSettingsDAO;
@Mock @Mock
private UserRoleDAO userRoleDAO; private UserRoleDAO userRoleDAO;
@Mock @Mock
private PasswordEncryptionService passwordEncryptionService; private PasswordEncryptionService passwordEncryptionService;
@Mock @Mock
private PostLoginActivities postLoginActivities; private PostLoginActivities postLoginActivities;
private User disabledUser; private User disabledUser;
private User normalUser; private User normalUser;
private UserService userService; private UserService userService;
@Before @Before
public void init() { public void init() {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
userService = new UserService(feedCategoryDAO, feedSubscriptionDAO, userDAO, userRoleDAO, userSettingsDAO, userService = new UserService(feedCategoryDAO, feedSubscriptionDAO, userDAO, userRoleDAO, userSettingsDAO,
passwordEncryptionService, commaFeedConfiguration, postLoginActivities); passwordEncryptionService, commaFeedConfiguration, postLoginActivities);
disabledUser = new User(); disabledUser = new User();
disabledUser.setDisabled(true); disabledUser.setDisabled(true);
normalUser = new User(); normalUser = new User();
normalUser.setDisabled(false); normalUser.setDisabled(false);
normalUser.setSalt(SALT); normalUser.setSalt(SALT);
normalUser.setPassword(ENCRYPTED_PASSWORD); normalUser.setPassword(ENCRYPTED_PASSWORD);
} }
@Test @Test
public void callingLoginShouldNotReturnUserObjectWhenGivenNullNameOrEmail() { public void callingLoginShouldNotReturnUserObjectWhenGivenNullNameOrEmail() {
Optional<User> user = userService.login(null, "password"); Optional<User> user = userService.login(null, "password");
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void callingLoginShouldNotReturnUserObjectWhenGivenNullPassword() { public void callingLoginShouldNotReturnUserObjectWhenGivenNullPassword() {
Optional<User> user = userService.login("testusername", null); Optional<User> user = userService.login("testusername", null);
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void callingLoginShouldLookupUserByName() { public void callingLoginShouldLookupUserByName() {
userService.login("test", "password"); userService.login("test", "password");
Mockito.verify(userDAO).findByName("test"); Mockito.verify(userDAO).findByName("test");
} }
@Test @Test
public void callingLoginShouldLookupUserByEmailIfLookupByNameFailed() { public void callingLoginShouldLookupUserByEmailIfLookupByNameFailed() {
Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null); Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null);
userService.login("test@test.com", "password"); userService.login("test@test.com", "password");
Mockito.verify(userDAO).findByEmail("test@test.com"); Mockito.verify(userDAO).findByEmail("test@test.com");
} }
@Test @Test
public void callingLoginShouldNotReturnUserObjectIfCouldNotFindUserByNameOrEmail() { public void callingLoginShouldNotReturnUserObjectIfCouldNotFindUserByNameOrEmail() {
Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null); Mockito.when(userDAO.findByName("test@test.com")).thenReturn(null);
Mockito.when(userDAO.findByEmail("test@test.com")).thenReturn(null); Mockito.when(userDAO.findByEmail("test@test.com")).thenReturn(null);
Optional<User> user = userService.login("test@test.com", "password"); Optional<User> user = userService.login("test@test.com", "password");
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void callingLoginShouldNotReturnUserObjectIfUserIsDisabled() { public void callingLoginShouldNotReturnUserObjectIfUserIsDisabled() {
Mockito.when(userDAO.findByName("test")).thenReturn(disabledUser); Mockito.when(userDAO.findByName("test")).thenReturn(disabledUser);
Optional<User> user = userService.login("test", "password"); Optional<User> user = userService.login("test", "password");
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void callingLoginShouldTryToAuthenticateUserWhoIsNotDisabled() { public void callingLoginShouldTryToAuthenticateUserWhoIsNotDisabled() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser); Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class))) Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(false); .thenReturn(false);
userService.login("test", "password"); userService.login("test", "password");
Mockito.verify(passwordEncryptionService).authenticate("password", ENCRYPTED_PASSWORD, SALT); Mockito.verify(passwordEncryptionService).authenticate("password", ENCRYPTED_PASSWORD, SALT);
} }
@Test @Test
public void callingLoginShouldNotReturnUserObjectOnUnsuccessfulAuthentication() { public void callingLoginShouldNotReturnUserObjectOnUnsuccessfulAuthentication() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser); Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class))) Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(false); .thenReturn(false);
Optional<User> authenticatedUser = userService.login("test", "password"); Optional<User> authenticatedUser = userService.login("test", "password");
Assert.assertFalse(authenticatedUser.isPresent()); Assert.assertFalse(authenticatedUser.isPresent());
} }
@Test @Test
public void callingLoginShouldExecutePostLoginActivitiesForUserOnSuccessfulAuthentication() { public void callingLoginShouldExecutePostLoginActivitiesForUserOnSuccessfulAuthentication() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser); Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class))) Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(true); .thenReturn(true);
Mockito.doNothing().when(postLoginActivities).executeFor(Mockito.any(User.class)); Mockito.doNothing().when(postLoginActivities).executeFor(Mockito.any(User.class));
userService.login("test", "password"); userService.login("test", "password");
Mockito.verify(postLoginActivities).executeFor(normalUser); Mockito.verify(postLoginActivities).executeFor(normalUser);
} }
@Test @Test
public void callingLoginShouldReturnUserObjectOnSuccessfulAuthentication() { public void callingLoginShouldReturnUserObjectOnSuccessfulAuthentication() {
Mockito.when(userDAO.findByName("test")).thenReturn(normalUser); Mockito.when(userDAO.findByName("test")).thenReturn(normalUser);
Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class))) Mockito.when(passwordEncryptionService.authenticate(Mockito.anyString(), Mockito.any(byte[].class), Mockito.any(byte[].class)))
.thenReturn(true); .thenReturn(true);
Mockito.doNothing().when(postLoginActivities).executeFor(Mockito.any(User.class)); Mockito.doNothing().when(postLoginActivities).executeFor(Mockito.any(User.class));
Optional<User> authenticatedUser = userService.login("test", "password"); Optional<User> authenticatedUser = userService.login("test", "password");
Assert.assertTrue(authenticatedUser.isPresent()); Assert.assertTrue(authenticatedUser.isPresent());
Assert.assertEquals(normalUser, authenticatedUser.get()); Assert.assertEquals(normalUser, authenticatedUser.get());
} }
@Test @Test
public void apiLoginShouldNotReturnUserIfApikeyNull() { public void apiLoginShouldNotReturnUserIfApikeyNull() {
Optional<User> user = userService.login(null); Optional<User> user = userService.login(null);
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void apiLoginShouldLookupUserByApikey() { public void apiLoginShouldLookupUserByApikey() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null); Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null);
userService.login("apikey"); userService.login("apikey");
Mockito.verify(userDAO).findByApiKey("apikey"); Mockito.verify(userDAO).findByApiKey("apikey");
} }
@Test @Test
public void apiLoginShouldNotReturnUserIfUserNotFoundFromLookupByApikey() { public void apiLoginShouldNotReturnUserIfUserNotFoundFromLookupByApikey() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null); Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(null);
Optional<User> user = userService.login("apikey"); Optional<User> user = userService.login("apikey");
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void apiLoginShouldNotReturnUserIfUserFoundFromApikeyLookupIsDisabled() { public void apiLoginShouldNotReturnUserIfUserFoundFromApikeyLookupIsDisabled() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(disabledUser); Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(disabledUser);
Optional<User> user = userService.login("apikey"); Optional<User> user = userService.login("apikey");
Assert.assertFalse(user.isPresent()); Assert.assertFalse(user.isPresent());
} }
@Test @Test
public void apiLoginShouldPerformPostLoginActivitiesIfUserFoundFromApikeyLookupNotDisabled() { public void apiLoginShouldPerformPostLoginActivitiesIfUserFoundFromApikeyLookupNotDisabled() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser); Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
userService.login("apikey"); userService.login("apikey");
Mockito.verify(postLoginActivities).executeFor(normalUser); Mockito.verify(postLoginActivities).executeFor(normalUser);
} }
@Test @Test
public void apiLoginShouldReturnUserIfUserFoundFromApikeyLookupNotDisabled() { public void apiLoginShouldReturnUserIfUserFoundFromApikeyLookupNotDisabled() {
Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser); Mockito.when(userDAO.findByApiKey("apikey")).thenReturn(normalUser);
Optional<User> returnedUser = userService.login("apikey"); Optional<User> returnedUser = userService.login("apikey");
Assert.assertEquals(normalUser, returnedUser.get()); Assert.assertEquals(normalUser, returnedUser.get());
} }
} }

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

@@ -1,33 +1,33 @@
package com.commafeed.frontend.auth; package com.commafeed.frontend.auth;
import java.util.Optional; import java.util.Optional;
import org.junit.Test; import org.junit.Test;
import org.mockito.Mockito; import org.mockito.Mockito;
import com.commafeed.backend.model.User; import com.commafeed.backend.model.User;
import com.commafeed.backend.service.UserService; import com.commafeed.backend.service.UserService;
import com.commafeed.backend.service.internal.PostLoginActivities; import com.commafeed.backend.service.internal.PostLoginActivities;
import com.commafeed.frontend.session.SessionHelper; import com.commafeed.frontend.session.SessionHelper;
public class SecurityCheckFactoryTest { public class SecurityCheckFactoryTest {
@Test @Test
public void cookieLoginShouldPerformPostLoginActivities() { public void cookieLoginShouldPerformPostLoginActivities() {
User userInSession = new User(); User userInSession = new User();
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class); SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
Mockito.when(sessionHelper.getLoggedInUser()).thenReturn(Optional.of(userInSession)); Mockito.when(sessionHelper.getLoggedInUser()).thenReturn(Optional.of(userInSession));
PostLoginActivities postLoginActivities = Mockito.mock(PostLoginActivities.class); PostLoginActivities postLoginActivities = Mockito.mock(PostLoginActivities.class);
UserService service = new UserService(null, null, null, null, null, null, null, postLoginActivities); UserService service = new UserService(null, null, null, null, null, null, null, postLoginActivities);
SecurityCheckFactory factory = new SecurityCheckFactory(null, false); SecurityCheckFactory factory = new SecurityCheckFactory(null, false);
factory.userService = service; factory.userService = service;
factory.cookieSessionLogin(sessionHelper); factory.cookieSessionLogin(sessionHelper);
Mockito.verify(postLoginActivities).executeFor(userInSession); Mockito.verify(postLoginActivities).executeFor(userInSession);
} }
} }

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

@@ -1,107 +1,107 @@
package com.commafeed.frontend.resource; package com.commafeed.frontend.resource;
import java.util.Arrays; import java.util.Arrays;
import java.util.Optional; import java.util.Optional;
import org.junit.Test; import org.junit.Test;
import org.mockito.ArgumentMatchers; import org.mockito.ArgumentMatchers;
import org.mockito.InOrder; import org.mockito.InOrder;
import org.mockito.Mockito; import org.mockito.Mockito;
import com.commafeed.backend.model.User; import com.commafeed.backend.model.User;
import com.commafeed.backend.model.UserRole.Role; import com.commafeed.backend.model.UserRole.Role;
import com.commafeed.backend.service.UserService; import com.commafeed.backend.service.UserService;
import com.commafeed.frontend.model.request.LoginRequest; import com.commafeed.frontend.model.request.LoginRequest;
import com.commafeed.frontend.model.request.RegistrationRequest; import com.commafeed.frontend.model.request.RegistrationRequest;
import com.commafeed.frontend.session.SessionHelper; import com.commafeed.frontend.session.SessionHelper;
public class UserRestTest { public class UserRestTest {
@Test @Test
public void loginShouldNotPopulateHttpSessionIfUnsuccessfull() { public void loginShouldNotPopulateHttpSessionIfUnsuccessfull() {
// Absent user // Absent user
Optional<User> absentUser = Optional.empty(); Optional<User> absentUser = Optional.empty();
// Create UserService partial mock // Create UserService partial mock
UserService service = Mockito.mock(UserService.class); UserService service = Mockito.mock(UserService.class);
Mockito.when(service.login("user", "password")).thenReturn(absentUser); Mockito.when(service.login("user", "password")).thenReturn(absentUser);
UserREST userREST = new UserREST(null, null, null, service, null, null, null); UserREST userREST = new UserREST(null, null, null, service, null, null, null);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class); SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
LoginRequest req = new LoginRequest(); LoginRequest req = new LoginRequest();
req.setName("user"); req.setName("user");
req.setPassword("password"); req.setPassword("password");
userREST.login(req, sessionHelper); userREST.login(req, sessionHelper);
Mockito.verify(sessionHelper, Mockito.never()).setLoggedInUser(Mockito.any(User.class)); Mockito.verify(sessionHelper, Mockito.never()).setLoggedInUser(Mockito.any(User.class));
} }
@Test @Test
public void loginShouldPopulateHttpSessionIfSuccessfull() { public void loginShouldPopulateHttpSessionIfSuccessfull() {
// Create a user // Create a user
User user = new User(); User user = new User();
// Create UserService mock // Create UserService mock
UserService service = Mockito.mock(UserService.class); UserService service = Mockito.mock(UserService.class);
Mockito.when(service.login("user", "password")).thenReturn(Optional.of(user)); Mockito.when(service.login("user", "password")).thenReturn(Optional.of(user));
LoginRequest req = new LoginRequest(); LoginRequest req = new LoginRequest();
req.setName("user"); req.setName("user");
req.setPassword("password"); req.setPassword("password");
UserREST userREST = new UserREST(null, null, null, service, null, null, null); UserREST userREST = new UserREST(null, null, null, service, null, null, null);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class); SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
userREST.login(req, sessionHelper); userREST.login(req, sessionHelper);
Mockito.verify(sessionHelper).setLoggedInUser(user); Mockito.verify(sessionHelper).setLoggedInUser(user);
} }
@Test @Test
public void registerShouldRegisterAndThenLogin() { public void registerShouldRegisterAndThenLogin() {
// Create UserService mock // Create UserService mock
UserService service = Mockito.mock(UserService.class); UserService service = Mockito.mock(UserService.class);
RegistrationRequest req = new RegistrationRequest(); RegistrationRequest req = new RegistrationRequest();
req.setName("user"); req.setName("user");
req.setPassword("password"); req.setPassword("password");
req.setEmail("test@test.com"); req.setEmail("test@test.com");
InOrder inOrder = Mockito.inOrder(service); InOrder inOrder = Mockito.inOrder(service);
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class); SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
UserREST userREST = new UserREST(null, null, null, service, null, null, null); UserREST userREST = new UserREST(null, null, null, service, null, null, null);
userREST.registerUser(req, sessionHelper); userREST.registerUser(req, sessionHelper);
inOrder.verify(service).register("user", "password", "test@test.com", Arrays.asList(Role.USER)); inOrder.verify(service).register("user", "password", "test@test.com", Arrays.asList(Role.USER));
inOrder.verify(service).login("user", "password"); inOrder.verify(service).login("user", "password");
} }
@Test @Test
public void registerShouldPopulateHttpSession() { public void registerShouldPopulateHttpSession() {
// Create a user // Create a user
User user = new User(); User user = new User();
// Create UserService mock // Create UserService mock
UserService service = Mockito.mock(UserService.class); UserService service = Mockito.mock(UserService.class);
Mockito.when(service.register(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.when(service.register(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class),
ArgumentMatchers.anyList())).thenReturn(user); ArgumentMatchers.anyList())).thenReturn(user);
Mockito.when(service.login(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(Optional.of(user)); Mockito.when(service.login(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(Optional.of(user));
RegistrationRequest req = new RegistrationRequest(); RegistrationRequest req = new RegistrationRequest();
req.setName("user"); req.setName("user");
req.setPassword("password"); req.setPassword("password");
req.setEmail("test@test.com"); req.setEmail("test@test.com");
SessionHelper sessionHelper = Mockito.mock(SessionHelper.class); SessionHelper sessionHelper = Mockito.mock(SessionHelper.class);
UserREST userREST = new UserREST(null, null, null, service, null, null, null); UserREST userREST = new UserREST(null, null, null, service, null, null, null);
userREST.registerUser(req, sessionHelper); userREST.registerUser(req, sessionHelper);
Mockito.verify(sessionHelper).setLoggedInUser(user); Mockito.verify(sessionHelper).setLoggedInUser(user);
} }
} }