/* ********************************************************************** **
** Copyright notice **
** **
** (c) 2005-2006 RSSOwl Development Team **
** http://www.rssowl.org/ **
** **
** All rights reserved **
** **
** This program and the accompanying materials are made available under **
** the terms of the Eclipse Public License v1.0 which accompanies this **
** distribution, and is available at: **
** http://www.rssowl.org/legal/epl-v10.html **
** **
** A copy is found in the file epl-v10.html and important notices to the **
** license from the team is found in the textfile LICENSE.txt distributed **
** in this package. **
** **
** This copyright notice MUST APPEAR in all copies of the file! **
** **
** Contributors: **
** RSSOwl Development Team - initial API and implementation **
** **
** ********************************************************************** */
package org.rssowl.core.tests.model;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import org.junit.Before;
import org.junit.Test;
import org.rssowl.core.model.NewsModel;
import org.rssowl.core.model.dao.IApplicationLayer;
import org.rssowl.core.model.dao.IModelDAO;
import org.rssowl.core.model.dao.PersistenceException;
import org.rssowl.core.model.events.BookMarkEvent;
import org.rssowl.core.model.events.BookMarkListener;
import org.rssowl.core.model.events.FolderEvent;
import org.rssowl.core.model.events.FolderListener;
import org.rssowl.core.model.events.NewsAdapter;
import org.rssowl.core.model.events.NewsEvent;
import org.rssowl.core.model.events.NewsListener;
import org.rssowl.core.model.events.SearchMarkEvent;
import org.rssowl.core.model.events.SearchMarkListener;
import org.rssowl.core.model.internal.types.Feed;
import org.rssowl.core.model.reference.BookMarkReference;
import org.rssowl.core.model.reference.FeedReference;
import org.rssowl.core.model.reference.FolderReference;
import org.rssowl.core.model.reference.NewsReference;
import org.rssowl.core.model.types.IBookMark;
import org.rssowl.core.model.types.IFeed;
import org.rssowl.core.model.types.IFolder;
import org.rssowl.core.model.types.ILabel;
import org.rssowl.core.model.types.IMark;
import org.rssowl.core.model.types.IModelTypesFactory;
import org.rssowl.core.model.types.INews;
import org.rssowl.core.model.types.ISearchMark;
import org.rssowl.core.model.types.INews.State;
import org.rssowl.core.tests.TestUtils;
import org.rssowl.ui.internal.Controller;
import org.rssowl.ui.internal.NewsService;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* This TestCase is for testing the IApplicationLayer.
*
* @author bpasero
*/
@SuppressWarnings("nls")
public class ApplicationLayerTest {
private IModelTypesFactory fFactory;
private IModelDAO fDao;
private NewsModel fModel;
private IApplicationLayer fAppLayer;
/**
* @throws Exception
*/
@Before
public void setUp() throws Exception {
Controller.getDefault().getNewsService().testDirtyShutdown();
NewsModel.getDefault().getPersistenceLayer().getModelSearch().stopIndexer();
NewsModel.getDefault().getPersistenceLayer().recreateSchema();
fFactory = NewsModel.getDefault().getTypesFactory();
fDao = NewsModel.getDefault().getPersistenceLayer().getModelDAO();
fModel = NewsModel.getDefault();
fAppLayer = fModel.getPersistenceLayer().getApplicationLayer();
}
/**
* Tests that calling setNewsState with force = true
* fires both events even though the news state has not changed.
*
* @throws Exception
*/
@Test
public void testSetNewsStateWithEquivalentNewsAndForce() throws Exception {
NewsListener newsListener = null;
try {
IFeed feed1 = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed.com"));
IFeed feed2 = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed2.com"));
INews news1 = fModel.getTypesFactory().createNews(null, feed1, new Date());
news1.setLink(new URI("www.link.com"));
INews news2 = fModel.getTypesFactory().createNews(null, feed2, new Date());
news2.setLink(new URI("www.link.com"));
fModel.getTypesFactory().createNews(null, feed1, new Date());
fModel.getTypesFactory().createNews(null, feed2, new Date());
fDao.saveFeed(feed1);
feed2 = fDao.saveFeed(feed2);
List<INews> newsList = new ArrayList<INews>(1);
newsList.add(news2);
final boolean[] newsUpdatedCalled = new boolean[1];
newsListener = new NewsAdapter() {
@Override
public void newsUpdated(Set<NewsEvent> events) {
newsUpdatedCalled[0] = true;
assertEquals(2, events.size());
}
};
NewsModel.getDefault().addNewsListener(newsListener);
fAppLayer.setNewsState(newsList, INews.State.NEW, true, true);
assertEquals(true, newsUpdatedCalled[0]);
} finally {
if (newsListener != null)
NewsModel.getDefault().removeNewsListener(newsListener);
}
}
/**
* Tests that the all NewsEvents issued after a call to setNewsState are
* fully activated even if there was an equivalent news that was not
* in memory.
*
* @throws Exception
*/
@Test
public void testSetNewsStateWithEquivalentNewsHasNewsEventEntityActivated() throws Exception {
NewsListener newsListener = null;
try {
IFeed feed1 = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed.com"));
IFeed feed2 = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed2.com"));
INews news1 = fModel.getTypesFactory().createNews(null, feed1, new Date());
news1.setLink(new URI("www.link.com"));
INews news2 = fModel.getTypesFactory().createNews(null, feed2, new Date());
news2.setLink(new URI("www.link.com"));
fModel.getTypesFactory().createNews(null, feed1, new Date());
fModel.getTypesFactory().createNews(null, feed2, new Date());
fDao.saveFeed(feed1);
feed2 = fDao.saveFeed(feed2);
feed1 = null;
feed2 = null;
news1 = null;
System.gc();
List<INews> newsList = Collections.singletonList(news2);
final boolean[] newsUpdatedCalled = new boolean[1];
newsListener = new NewsAdapter() {
@Override
public void newsUpdated(Set<NewsEvent> events) {
newsUpdatedCalled[0] = true;
assertEquals(2, events.size());
for (NewsEvent event : events) {
IFeed feed = event.getEntity().getFeedReference().resolve();
/* This should be enough to verify that the news is fully activated */
assertNotNull(feed.getId());
assertNotNull(feed.getNews());
assertNotNull(feed.getNews().get(0));
}
}
};
NewsModel.getDefault().addNewsListener(newsListener);
fAppLayer.setNewsState(newsList, INews.State.READ, true, false);
assertEquals(true, newsUpdatedCalled[0]);
} finally {
if (newsListener != null)
NewsModel.getDefault().removeNewsListener(newsListener);
}
}
/**
* Tests that calling {@link IApplicationLayer#saveFeed(IFeed, List)} does not
* cause news to be lost in the feed. See bug #276.
*
* @throws Exception
*/
@Test
public void testSaveFeedNewsLost() throws Exception {
IFeed feed = fFactory.createFeed(null, new URL("http://www.feed.com"));
INews news0 = fFactory.createNews(null, feed, new Date());
news0.setLink(new URI("http://www.feed.com/news1"));
INews news1 = fFactory.createNews(null, feed, new Date());
URI news1Link = new URI("http://www.feed.com/news2");
news1.setLink(news1Link);
fDao.saveFeed(feed);
long feedId = feed.getId();
INews news = feed.getNews().get(0);
feed.removeNews(news);
List<INews> newsToRemove = new ArrayList<INews>(0);
newsToRemove.add(news);
fAppLayer.saveFeed(feed, newsToRemove);
feed = null;
news0 = null;
news1 = null;
newsToRemove = null;
news = null;
System.gc();
feed = fDao.loadFeed(feedId);
assertEquals(1, feed.getNews().size());
assertEquals(news1Link, feed.getNews().get(0).getLink());
}
/**
* Tests that {@link IApplicationLayer#saveNews(List)} sets the current and
* old state correctly when firing a newsUpdated event.
*
* @throws Exception
*/
@Test
public void testSaveNewsSetsCurrentAndOldState() throws Exception {
IFeed feed = new Feed(new URL("http://www.feed.com"));
feed = fDao.saveFeed(feed);
INews news = fFactory.createNews(null, feed, new Date());
news.setTitle("News Title #1");
news.setLink(new URI("http://www.link.com"));
news.setState(INews.State.UNREAD);
feed = fDao.saveFeed(feed);
final INews savedNews = feed.getNews().get(0);
savedNews.setTitle("News Title Updated #1");
List<INews> newsList = new ArrayList<INews>();
newsList.add(savedNews);
NewsListener newsListener = new NewsAdapter() {
@Override
public void newsUpdated(Set<NewsEvent> events) {
assertEquals(1, events.size());
NewsEvent event = events.iterator().next();
assertEquals(true, event.getEntity().equalsId(savedNews));
assertEquals(State.UNREAD, event.getOldNews().getState());
assertEquals(State.UNREAD, event.getEntity().getState());
}
};
fModel.addNewsListener(newsListener);
try {
newsList = fAppLayer.saveNews(newsList);
} finally {
fModel.removeNewsListener(newsListener);
}
newsListener = new NewsAdapter() {
@Override
public void newsUpdated(Set<NewsEvent> events) {
assertEquals(1, events.size());
NewsEvent event = events.iterator().next();
assertEquals(savedNews.getId().longValue(), event.getEntity().getId());
assertEquals(State.UNREAD, event.getOldNews().getState());
assertEquals(State.UPDATED, event.getEntity().getState());
}
};
fModel.addNewsListener(newsListener);
newsList.get(0).setState(State.UPDATED);
try {
fAppLayer.saveNews(newsList);
} finally {
fModel.removeNewsListener(newsListener);
}
}
/**
* Tests {@link IApplicationLayer#loadFeedReference(URL)}.
*
* @throws Exception
*/
@Test
public void testLoadFeedReference() throws Exception {
URL feed1Url = new URL("http://www.feed1.com");
IFeed feed1 = new Feed(feed1Url);
feed1 = fDao.saveFeed(feed1);
URL feed2Url = new URL("http://www.feed2.com");
IFeed feed2 = new Feed(feed2Url);
feed2 = fDao.saveFeed(feed2);
assertEquals(feed1.getId().longValue(), fAppLayer.loadFeedReference(feed1Url).getId());
assertEquals(feed2.getId().longValue(), fAppLayer.loadFeedReference(feed2Url).getId());
}
/**
* Tests {@link IApplicationLayer#loadFeed(URL)}.
*
* @throws Exception
*/
@Test
public void testLoadFeed() throws Exception {
URL feed1Url = new URL("http://www.feed1.com");
IFeed feed1 = new Feed(feed1Url);
feed1 = fDao.saveFeed(feed1);
URL feed2Url = new URL("http://www.feed2.com");
IFeed feed2 = new Feed(feed2Url);
feed2 = fDao.saveFeed(feed2);
assertEquals(feed1, fAppLayer.loadFeed(feed1Url));
assertEquals(feed2, fAppLayer.loadFeed(feed2Url));
}
/**
* Tests {@link IApplicationLayer#loadFeed(URL)}.
*
* @throws Exception
*/
@Test
public void testLoadFeedActivation() throws Exception {
URL feed1Url = new URL("http://www.feed1.com");
IFeed feed1 = fFactory.createFeed(null, feed1Url);
fFactory.createNews(null, feed1, new Date());
feed1 = fDao.saveFeed(feed1);
long newsId = feed1.getNews().get(0).getId();
feed1 = null;
System.gc();
feed1 = fAppLayer.loadFeed(feed1Url);
assertNotNull(feed1);
assertEquals(1, feed1.getNews().size());
assertEquals(newsId, feed1.getNews().get(0).getId());
}
/**
* Tests {@link IApplicationLayer#saveNews(List)}.
*
* @throws Exception
*/
@Test
public void testSaveNews() throws Exception {
IFeed feed1 = new Feed(new URL("http://www.feed1.com"));
INews news11 = fFactory.createNews(null, feed1, new Date());
news11.setLink(new URI("http://www.link11.com"));
INews news12 = fFactory.createNews(null, feed1, new Date());
news12.setLink(new URI("http://www.link12.com"));
feed1 = fDao.saveFeed(feed1);
IFeed feed2 = new Feed(new URL("http://www.feed2.com"));
INews news21 = fFactory.createNews(null, feed2, new Date());
news21.setLink(new URI("http://www.link21.com"));
INews news22 = fFactory.createNews(null, feed2, new Date());
news22.setLink(new URI("http://www.link22.com"));
feed2 = fDao.saveFeed(feed2);
final List<INews> newsList = new ArrayList<INews>();
for (INews news : feed1.getNews())
newsList.add(news);
for (INews news : feed2.getNews())
newsList.add(news);
for (INews news : newsList) {
news.setComments("updated comments");
}
final boolean newsUpdatedCalled[] = new boolean[1];
NewsListener newsListener = new NewsAdapter() {
@Override
public void newsUpdated(Set<NewsEvent> events) {
assertEquals(newsUpdatedCalled[0], false);
newsUpdatedCalled[0] = true;
assertEquals(newsList.size(), events.size());
for (NewsEvent event : events) {
boolean newsFound = false;
for (INews news : newsList) {
if (event.getEntity().equalsId(news)) {
newsFound = true;
break;
}
}
assertEquals(true, newsFound);
}
}
};
fModel.addNewsListener(newsListener);
try {
List<INews> savedNews = fAppLayer.saveNews(newsList);
assertEquals(newsList, savedNews);
} finally {
fModel.removeNewsListener(newsListener);
}
assertEquals(true, newsUpdatedCalled[0]);
}
/**
* Test {@link IApplicationLayer#reparentFolder(java.util.Map)}
*
* @throws Exception
*/
@Test
public void testReparentFolder() throws Exception {
FolderListener folderListener = null;
try {
/* Add */
final IFolder oldParent = fFactory.createFolder(null, null, "Old parent");
final IFolder folder = fFactory.createFolder(null, oldParent, "Folder");
fDao.saveFolder(oldParent);
final IFolder newParent = fFactory.createFolder(null, null, "New parent");
fFactory.createFolder(null, newParent, "New parent child");
fDao.saveFolder(newParent);
final boolean[] updateEventOccurred = new boolean[1];
folderListener = new FolderListener() {
public void folderAdded(Set<FolderEvent> events) {
fail("Unexpected event");
}
public void folderDeleted(Set<FolderEvent> events) {
fail("Unexpected event");
}
public void folderUpdated(Set<FolderEvent> events) {
updateEventOccurred[0] = true;
assertEquals(4, events.size());
boolean foundFolder = false;
for (FolderEvent event : events) {
if (event.getEntity().equals(folder)) {
foundFolder = true;
assertTrue("Expected this Event to be Root Event", event.isRoot());
assertEquals(oldParent, event.getOldParent());
assertEquals(newParent, event.getEntity().getParent());
} else
assertFalse("Expected this Event to be NO Root Event", event.isRoot());
}
assertTrue("No event was issued for folder", foundFolder);
}
};
fModel.addFolderListener(folderListener);
Map<IFolder, IFolder> foldersMap = new HashMap<IFolder, IFolder>();
foldersMap.put(folder, newParent);
fAppLayer.reparentFolder(foldersMap);
/* Asserts Follow */
assertFalse(oldParent.getFolders().contains(folder));
assertEquals(0, oldParent.getFolders().size());
assertTrue(newParent.getFolders().contains(folder));
assertEquals(newParent, folder.getParent());
assertEquals(2, newParent.getFolders().size());
assertTrue("Missing folderUpdated Event", updateEventOccurred[0]);
fModel.removeFolderListener(folderListener);
/* Delete */
fDao.deleteFolder(new FolderReference(newParent.getId()));
fDao.deleteFolder(new FolderReference(oldParent.getId()));
} finally {
/* Cleanup */
if (folderListener != null)
fModel.removeFolderListener(folderListener);
}
}
/**
* Test {@link IApplicationLayer#reparentMark(java.util.Map)}
*
* @throws Exception
*/
@Test
public void testReparentMark() throws Exception {
FolderListener folderListener = null;
BookMarkListener bookMarkListener = null;
SearchMarkListener searchMarkListener = null;
try {
/* Add */
final IFolder oldParent = fFactory.createFolder(null, null, "Old parent");
FeedReference feedRef = new FeedReference(Long.MAX_VALUE);
final IBookMark bookMark = fFactory.createBookMark(null, oldParent,
new URL("http://www.link.com"), feedRef, "bookmark");
final ISearchMark searchMark = fFactory.createSearchMark(null, oldParent, "searchmark");
fDao.saveFolder(oldParent);
final IFolder newParent = fFactory.createFolder(null, null, "New parent");
fFactory.createFolder(null, newParent, "New parent child");
fDao.saveFolder(newParent);
final boolean[] bookMarkUpdateEventOccurred = new boolean[1];
bookMarkListener = new BookMarkListener() {
public void bookMarkAdded(Set<BookMarkEvent> events) {
fail("Unexpected event");
}
public void bookMarkDeleted(Set<BookMarkEvent> events) {
fail("Unexpected event");
}
public void bookMarkUpdated(Set<BookMarkEvent> events) {
bookMarkUpdateEventOccurred[0] = true;
assertEquals(1, events.size());
BookMarkEvent event = events.iterator().next();
assertEquals(bookMark, event.getEntity());
assertTrue("Expected this Event to be Root Event", event.isRoot());
assertEquals(oldParent, event.getOldParent());
assertEquals(newParent, event.getEntity().getFolder());
}
};
final boolean[] searchMarkUpdateEventOccurred = new boolean[1];
searchMarkListener = new SearchMarkListener() {
public void searchMarkAdded(Set<SearchMarkEvent> events) {
fail("Unexpected event");
}
public void searchMarkDeleted(Set<SearchMarkEvent> events) {
fail("Unexpected event");
}
public void searchMarkUpdated(Set<SearchMarkEvent> events) {
searchMarkUpdateEventOccurred[0] = true;
assertEquals(1, events.size());
SearchMarkEvent event = events.iterator().next();
assertEquals(searchMark, event.getEntity());
assertTrue("Expected this Event to be Root Event", event.isRoot());
assertEquals(oldParent, event.getOldParent());
assertEquals(newParent, event.getEntity().getFolder());
}
};
final boolean[] folderUpdateEventOccurred = new boolean[1];
folderListener = new FolderListener() {
public void folderAdded(Set<FolderEvent> events) {
fail("Unexpected event");
}
public void folderDeleted(Set<FolderEvent> events) {
fail("Unexpected event");
}
public void folderUpdated(Set<FolderEvent> events) {
folderUpdateEventOccurred[0] = true;
assertEquals(3, events.size());
for (FolderEvent event : events) {
assertFalse("Expected this Event to be NO Root Event", event.isRoot());
}
}
};
fModel.addFolderListener(folderListener);
fModel.addBookMarkListener(bookMarkListener);
fModel.addSearchMarkListener(searchMarkListener);
Map<IMark, IFolder> markFoldersMap = new HashMap<IMark, IFolder>();
markFoldersMap.put(bookMark, newParent);
markFoldersMap.put(searchMark, newParent);
fAppLayer.reparentMark(markFoldersMap);
/* Asserts Follow */
assertFalse(oldParent.getFolders().contains(bookMark));
assertFalse(oldParent.getFolders().contains(searchMark));
assertEquals(0, oldParent.getMarks().size());
assertTrue(newParent.getMarks().contains(bookMark));
assertTrue(newParent.getMarks().contains(searchMark));
assertEquals(newParent, bookMark.getFolder());
assertEquals(newParent, searchMark.getFolder());
assertEquals(2, newParent.getMarks().size());
assertTrue("Missing folderUpdated Event", folderUpdateEventOccurred[0]);
assertTrue("Missing bookMarkUpdated Event", bookMarkUpdateEventOccurred[0]);
assertTrue("Missing searchMarkUpdated Event", searchMarkUpdateEventOccurred[0]);
fModel.removeFolderListener(folderListener);
fModel.removeBookMarkListener(bookMarkListener);
fModel.removeSearchMarkListener(searchMarkListener);
/* Delete */
fDao.deleteFolder(new FolderReference(newParent.getId()));
fDao.deleteFolder(new FolderReference(oldParent.getId()));
} finally {
/* Cleanup */
if (folderListener != null)
fModel.removeFolderListener(folderListener);
if (bookMarkListener != null)
fModel.removeBookMarkListener(bookMarkListener);
if (searchMarkListener != null)
fModel.removeSearchMarkListener(searchMarkListener);
}
}
/**
* @throws Exception
*/
@Test
public void testLoadBookMarks() throws Exception {
IFeed feed = fFactory.createFeed(null, new URL("http://www.myfeed.com"));
FeedReference feedRef = new FeedReference(fDao.saveFeed(feed).getId());
List<IBookMark> emptyBookmarks = fAppLayer.loadBookMarks(feed);
assertEquals(0, emptyBookmarks.size());
IFolder root1 = fFactory.createFolder(null, null, "Root 1");
FolderReference root1Ref = new FolderReference(fDao.saveFolder(root1).getId());
IFolder childOfRoot1 = fFactory.createFolder(null, root1Ref.resolve(), "Child of Root 1");
FolderReference childOfRoot1Ref = new FolderReference(fDao.saveFolder(childOfRoot1).getId());
IBookMark bookmark1 = fFactory.createBookMark(null, root1Ref.resolve(),
feed.getLink(), feedRef, "Bookmark 1");
IBookMark bookmark2 = fFactory.createBookMark(null, root1Ref.resolve(),
feed.getLink(), feedRef, "Bookmark 2");
IBookMark bookmark3 = fFactory.createBookMark(null, childOfRoot1Ref.resolve(),
feed.getLink(), feedRef, "Bookmark 3");
BookMarkReference bookmarkRef1 = new BookMarkReference(fDao.saveBookMark(bookmark1).getId());
BookMarkReference bookmarkRef2 = new BookMarkReference(fDao.saveBookMark(bookmark2).getId());
BookMarkReference bookmarkRef3 = new BookMarkReference(fDao.saveBookMark(bookmark3).getId());
List<IBookMark> filledBookmarks = fAppLayer.loadBookMarks(feedRef.resolve());
assertEquals(3, filledBookmarks.size());
for (IBookMark mark : filledBookmarks) {
if (bookmarkRef1.resolve().equals(mark))
assertEquals(bookmark1.getName(), mark.getName());
else if (bookmarkRef2.resolve().equals(mark))
assertEquals(bookmark2.getName(), mark.getName());
else if (bookmarkRef3.resolve().equals(mark))
assertEquals(bookmark3.getName(), mark.getName());
else
fail();
}
}
/**
* @throws Exception
*/
@Test
public void testLoadBookMarksActivation() throws Exception {
IFeed feed = fFactory.createFeed(null, new URL("http://www.myfeed.com"));
FeedReference feedRef = new FeedReference(fDao.saveFeed(feed).getId());
long feedId = feedRef.getId();
IFolder root1 = fFactory.createFolder(null, null, "Root 1");
final String folderName = root1.getName();
fFactory.createBookMark(null, root1, feed.getLink(), feedRef, "Bookmark 1");
feedRef = null;
feed = null;
fDao.saveFolder(root1);
root1 = null;
System.gc();
feed = fDao.loadFeed(feedId);
List<IBookMark> marks = fAppLayer.loadBookMarks(feed);
assertEquals(1, marks.size());
assertEquals(folderName, marks.get(0).getFolder().getName());
marks = null;
System.gc();
}
/**
* @throws Exception
*/
@Test
public void testLoadAllBookMarks() throws Exception {
IFeed feed = fFactory.createFeed(null, new URL("http://www.myfeed.com"));
FeedReference feedRef = new FeedReference(fDao.saveFeed(feed).getId());
List<IBookMark> emptyBookmarks = fAppLayer.loadAllBookMarks(false);
emptyBookmarks = fAppLayer.loadAllBookMarks(true);
assertEquals(0, emptyBookmarks.size());
IFolder root1 = fFactory.createFolder(null, null, "Root 1");
root1 = fDao.saveFolder(root1);
IFolder childOfRoot1 = fFactory.createFolder(null, root1, "Child of Root 1");
childOfRoot1 = fDao.saveFolder(childOfRoot1);
IBookMark bookmark1 = fFactory.createBookMark(null, root1, feed.getLink(),
feedRef, "Bookmark 1");
IBookMark bookmark2 = fFactory.createBookMark(null, root1, feed.getLink(),
feedRef, "Bookmark 2");
IBookMark bookmark3 = fFactory.createBookMark(null, childOfRoot1, feed.getLink(),
feedRef, "Bookmark 3");
BookMarkReference bookmarkRef1 = new BookMarkReference(fDao.saveBookMark(bookmark1).getId());
BookMarkReference bookmarkRef2 = new BookMarkReference(fDao.saveBookMark(bookmark2).getId());
BookMarkReference bookmarkRef3 = new BookMarkReference(fDao.saveBookMark(bookmark3).getId());
List<IBookMark> filledBookmarks = fAppLayer.loadAllBookMarks(true);
assertEquals(3, filledBookmarks.size());
filledBookmarks = fAppLayer.loadAllBookMarks(false);
assertEquals(3, filledBookmarks.size());
for (IBookMark mark : filledBookmarks) {
if (bookmarkRef1.resolve().equals(mark))
assertEquals(bookmark1.getName(), mark.getName());
else if (bookmarkRef2.resolve().equals(mark))
assertEquals(bookmark2.getName(), mark.getName());
else if (bookmarkRef3.resolve().equals(mark))
assertEquals(bookmark3.getName(), mark.getName());
else
fail();
}
}
/**
* @throws Exception
*/
@Test
public void testLoadAllBookMarksActivation() throws Exception {
IFeed feed = fFactory.createFeed(null, new URL("http://www.myfeed.com"));
FeedReference feedRef = new FeedReference(fDao.saveFeed(feed).getId());
IFolder root1 = fFactory.createFolder(null, null, "Root 1");
final String folderName = root1.getName();
fFactory.createBookMark(null, root1, feed.getLink(), feedRef, "Bookmark 1");
feedRef = null;
feed = null;
fDao.saveFolder(root1);
root1 = null;
System.gc();
List<IBookMark> marks = fAppLayer.loadAllBookMarks(true);
assertEquals(1, marks.size());
assertEquals(folderName, marks.get(0).getFolder().getName());
marks = null;
System.gc();
marks = fAppLayer.loadAllBookMarks(false);
assertEquals(1, marks.size());
assertNull(marks.get(0).getFolder().getName());
}
/**
* @throws Exception
*/
@Test
public void testLoadLabels() throws Exception {
ILabel label1 = fFactory.createLabel(null, "Important");
label1.setColor("159,63,63");
fDao.saveLabel(label1);
ILabel label2 = fFactory.createLabel(null, "Important");
label2.setColor("255,153,0");
fDao.saveLabel(label2);
ILabel label3 = fFactory.createLabel(null, "Personal");
label3.setColor("0,153,0");
fDao.saveLabel(label3);
List<ILabel> labels = fAppLayer.loadLabels();
assertEquals(3, labels.size());
for (ILabel label : labels) {
if (label.equals(label1)) {
assertEquals("Important", label.getName());
assertEquals("159,63,63", label.getColor());
}
else if (label.equals(label2)) {
assertEquals("Important", label.getName());
assertEquals("255,153,0", label.getColor());
}
else if (label.equals(label3)) {
assertEquals("Personal", label.getName());
assertEquals("0,153,0", label.getColor());
}
}
}
/**
*
*/
public void testLoadLabelsActivation() {
String colour = "159,63,63";
ILabel label1 = fFactory.createLabel(null, "Important");
label1.setColor(colour);
fDao.saveLabel(label1);
label1 = null;
System.gc();
List<ILabel> labels = fAppLayer.loadLabels();
assertEquals(1, labels.size());
assertEquals(colour, labels.get(0).getColor());
}
/**
* Test the Method loadRootFolders()
*
* @throws Exception
*/
@Test
public void testLoadRootFolders() throws Exception {
IFolder root1 = fFactory.createFolder(null, null, "Root 1");
IFolder root2 = fFactory.createFolder(null, null, "Root 2");
IFolder root3 = fFactory.createFolder(null, null, "Root 3");
fFactory.createFolder(null, root1, "Child of Root 1");
fFactory.createFolder(null, root2, "Child of Root 2");
FolderReference root1Ref = new FolderReference(fDao.saveFolder(root1).getId());
FolderReference root2Ref = new FolderReference(fDao.saveFolder(root2).getId());
FolderReference root3Ref = new FolderReference(fDao.saveFolder(root3).getId());
List<IFolder> rootFolders = fAppLayer.loadRootFolders();
assertEquals(3, rootFolders.size());
for (IFolder folder : rootFolders) {
if (root1Ref.resolve().equals(folder))
assertEquals("Root 1", folder.getName());
else if (root2Ref.resolve().equals(folder))
assertEquals("Root 2", folder.getName());
else if (root3Ref.resolve().equals(folder))
assertEquals("Root 3", folder.getName());
else
fail();
}
}
/**
*
* @throws Exception
*/
@Test
public void testLoadRootFoldersActivation() throws Exception {
IFolder root1 = fFactory.createFolder(null, null, "Root 1");
fFactory.createFolder(null, root1, "Child of Root 1");
String childFolderName = root1.getFolders().get(0).getName();
fDao.saveFolder(root1);
root1 = null;
System.gc();
List<IFolder> rootFolders = fAppLayer.loadRootFolders();
assertEquals(1, rootFolders.size());
IFolder folder = rootFolders.get(0);
assertEquals(1, folder.getFolders().size());
assertEquals(childFolderName, folder.getFolders().get(0).getName());
}
/**
* @throws Exception
*/
@SuppressWarnings("nls")
@Test
public void testSetNewsState() throws Exception {
NewsListener newsListener = null;
try {
IFeed feed = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed.com"));
fModel.getTypesFactory().createNews(null, feed, new Date());
fModel.getTypesFactory().createNews(null, feed, new Date());
fModel.getTypesFactory().createNews(null, feed, new Date());
Feed savedFeed = (Feed) fDao.saveFeed(feed);
assertTrue(savedFeed.isIdentical(fDao.loadFeed(savedFeed.getId())));
NewsReference news1 = new NewsReference(savedFeed.getNews().get(0).getId());
NewsReference news2 = new NewsReference(savedFeed.getNews().get(1).getId());
NewsReference news3 = new NewsReference(savedFeed.getNews().get(2).getId());
List<INews> news = new ArrayList<INews>();
news.add(news1.resolve());
news.add(news2.resolve());
assertEquals(news1.resolve().getState(), INews.State.NEW);
assertEquals(news2.resolve().getState(), INews.State.NEW);
assertEquals(news3.resolve().getState(), INews.State.NEW);
newsListener = new NewsListener() {
public void newsAdded(Set<NewsEvent> events) {
fail("Unexpected Event");
}
public void newsDeleted(Set<NewsEvent> events) {
fail("Unexpected Event");
}
public void newsUpdated(Set<NewsEvent> events) {
assertEquals(2, events.size());
}
};
fModel.addNewsListener(newsListener);
fModel.getPersistenceLayer().getApplicationLayer().setNewsState(news, INews.State.UNREAD, true, false);
assertEquals(news1.resolve().getState(), INews.State.UNREAD);
assertEquals(news2.resolve().getState(), INews.State.UNREAD);
assertEquals(news3.resolve().getState(), INews.State.NEW);
fModel.getPersistenceLayer().getApplicationLayer().setNewsState(news, INews.State.READ, true, false);
assertEquals(news1.resolve().getState(), INews.State.READ);
assertEquals(news2.resolve().getState(), INews.State.READ);
assertEquals(news3.resolve().getState(), INews.State.NEW);
fModel.getPersistenceLayer().getApplicationLayer().setNewsState(news, INews.State.DELETED, true, false);
assertEquals(news1.resolve().getState(), INews.State.DELETED);
assertEquals(news2.resolve().getState(), INews.State.DELETED);
assertEquals(news3.resolve().getState(), INews.State.NEW);
} catch (PersistenceException e) {
TestUtils.fail(e);
} finally {
if (newsListener != null)
fModel.removeNewsListener(newsListener);
}
}
/**
* @throws Exception
*/
@Test
public void testSetNewsStateOnPlanet() throws Exception {
NewsListener newsListener = null;
try {
NewsService service = Controller.getDefault().getNewsService();
IFeed feed1 = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed.com"));
IFeed feed2 = fModel.getTypesFactory().createFeed(null, new URL("http://www.feed2.com"));
INews news1 = fModel.getTypesFactory().createNews(null, feed1, new Date());
news1.setLink(new URI("www.link.com"));
INews news2 = fModel.getTypesFactory().createNews(null, feed2, new Date());
news2.setLink(new URI("www.link.com"));
fModel.getTypesFactory().createNews(null, feed1, new Date());
fModel.getTypesFactory().createNews(null, feed2, new Date());
feed1 = fDao.saveFeed(feed1);
feed2 = fDao.saveFeed(feed2);
assertEquals(2, service.getUnreadCount(news1.getFeedReference()));
assertEquals(2, service.getNewCount(news1.getFeedReference()));
assertEquals(2, service.getUnreadCount(news2.getFeedReference()));
assertEquals(2, service.getNewCount(news2.getFeedReference()));
final long feed1ID = feed1.getId();
final long feed2ID = feed2.getId();
final long news1ID = feed1.getNews().get(0).getId();
final long news2ID = feed2.getNews().get(0).getId();
newsListener = new NewsListener() {
public void newsAdded(Set<NewsEvent> events) {
fail("Unexpected Event!");
}
public void newsDeleted(Set<NewsEvent> events) {
fail("Unexpected Event!");
}
public void newsUpdated(Set<NewsEvent> events) {
assertEquals(2, events.size());
for (NewsEvent event : events) {
INews news = event.getEntity();
IFeed parent = news.getFeedReference().resolve();
if (news.getId() == news1ID)
assertEquals(feed1ID, parent.getId());
else if (news.getId() == news2ID)
assertEquals(feed2ID, parent.getId());
else
fail("Unexpected Reference in Event!");
}
}
};
fModel.addNewsListener(newsListener);
fAppLayer.setNewsState(Arrays.asList(new INews[] { new NewsReference(news1ID).resolve() }), INews.State.READ, true, false);
assertEquals(1, service.getUnreadCount(news1.getFeedReference()));
assertEquals(1, service.getNewCount(news1.getFeedReference()));
assertEquals(1, service.getUnreadCount(news2.getFeedReference()));
assertEquals(1, service.getNewCount(news2.getFeedReference()));
} finally {
if (newsListener != null)
fModel.removeNewsListener(newsListener);
}
}
}