From a87c505380ee9f4ce0247a8636a78881cc622a58 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 23 Jan 2021 23:12:01 +0100 Subject: Run DbReaderTest etc. with Robolectric --- .../antennapod/core/storage/DbCleanupTests.java | 237 ++++++++++++ .../core/storage/DbQueueCleanupAlgorithmTest.java | 52 +++ .../antennapod/core/storage/DbReaderTest.java | 420 +++++++++++++++++++++ .../antennapod/core/storage/DbTestUtils.java | 77 ++++ 4 files changed, 786 insertions(+) create mode 100644 core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java create mode 100644 core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java create mode 100644 core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java create mode 100644 core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java (limited to 'core/src') diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java new file mode 100644 index 000000000..13d24adc1 --- /dev/null +++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java @@ -0,0 +1,237 @@ +package de.danoeh.antennapod.core.storage; + +import android.app.Application; +import android.content.Context; +import android.content.SharedPreferences; +import androidx.preference.PreferenceManager; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import androidx.test.platform.app.InstrumentationRegistry; + +import de.danoeh.antennapod.core.ApplicationCallbacks; +import de.danoeh.antennapod.core.ClientConfig; +import de.danoeh.antennapod.core.feed.Feed; +import de.danoeh.antennapod.core.feed.FeedItem; +import de.danoeh.antennapod.core.feed.FeedMedia; +import de.danoeh.antennapod.core.preferences.PlaybackPreferences; +import de.danoeh.antennapod.core.preferences.UserPreferences; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; + +import static de.danoeh.antennapod.core.storage.DbTestUtils.saveFeedlist; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +/** + * Test class for DBTasks. + */ +@RunWith(RobolectricTestRunner.class) +public class DbCleanupTests { + + static final int EPISODE_CACHE_SIZE = 5; + private int cleanupAlgorithm; + + Context context; + + private File destFolder; + + public DbCleanupTests() { + setCleanupAlgorithm(UserPreferences.EPISODE_CLEANUP_DEFAULT); + } + + protected void setCleanupAlgorithm(int cleanupAlgorithm) { + this.cleanupAlgorithm = cleanupAlgorithm; + } + + @Before + public void setUp() { + context = InstrumentationRegistry.getInstrumentation().getTargetContext(); + destFolder = new File(context.getCacheDir(), "DbCleanupTests"); + //noinspection ResultOfMethodCallIgnored + destFolder.mkdir(); + cleanupDestFolder(destFolder); + assertNotNull(destFolder); + assertTrue(destFolder.exists()); + assertTrue(destFolder.canWrite()); + + // create new database + PodDBAdapter.init(context); + PodDBAdapter.deleteDatabase(); + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.close(); + + SharedPreferences.Editor prefEdit = PreferenceManager + .getDefaultSharedPreferences(context.getApplicationContext()).edit(); + prefEdit.putString(UserPreferences.PREF_EPISODE_CACHE_SIZE, Integer.toString(EPISODE_CACHE_SIZE)); + prefEdit.putString(UserPreferences.PREF_EPISODE_CLEANUP, Integer.toString(cleanupAlgorithm)); + prefEdit.putBoolean(UserPreferences.PREF_ENABLE_AUTODL, true); + prefEdit.commit(); + + UserPreferences.init(context); + PlaybackPreferences.init(context); + + Application app = (Application) context; + ClientConfig.applicationCallbacks = mock(ApplicationCallbacks.class); + when(ClientConfig.applicationCallbacks.getApplicationInstance()).thenReturn(app); + } + + @After + public void tearDown() { + cleanupDestFolder(destFolder); + assertTrue(destFolder.delete()); + + DBWriter.tearDownTests(); + PodDBAdapter.tearDownTests(); + } + + private void cleanupDestFolder(File destFolder) { + //noinspection ConstantConditions + for (File f : destFolder.listFiles()) { + assertTrue(f.delete()); + } + } + + @Test + public void testPerformAutoCleanupShouldDelete() throws IOException { + final int numItems = EPISODE_CACHE_SIZE * 2; + + Feed feed = new Feed("url", null, "title"); + List items = new ArrayList<>(); + feed.setItems(items); + List files = new ArrayList<>(); + populateItems(numItems, feed, items, files, FeedItem.PLAYED, false, false); + + DBTasks.performAutoCleanup(context); + for (int i = 0; i < files.size(); i++) { + if (i < EPISODE_CACHE_SIZE) { + assertTrue(files.get(i).exists()); + } else { + assertFalse(files.get(i).exists()); + } + } + } + + @SuppressWarnings("SameParameterValue") + void populateItems(final int numItems, Feed feed, List items, + List files, int itemState, boolean addToQueue, + boolean addToFavorites) throws IOException { + for (int i = 0; i < numItems; i++) { + Date itemDate = new Date(numItems - i); + Date playbackCompletionDate = null; + if (itemState == FeedItem.PLAYED) { + playbackCompletionDate = itemDate; + } + FeedItem item = new FeedItem(0, "title", "id", "link", itemDate, itemState, feed); + + File f = new File(destFolder, "file " + i); + assertTrue(f.createNewFile()); + files.add(f); + item.setMedia(new FeedMedia(0, item, 1, 0, 1L, "m", + f.getAbsolutePath(), "url", true, playbackCompletionDate, 0, 0)); + items.add(item); + } + + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.setCompleteFeed(feed); + if (addToQueue) { + adapter.setQueue(items); + } + if (addToFavorites) { + adapter.setFavorites(items); + } + adapter.close(); + + assertTrue(feed.getId() != 0); + for (FeedItem item : items) { + assertTrue(item.getId() != 0); + //noinspection ConstantConditions + assertTrue(item.getMedia().getId() != 0); + } + } + + @Test + public void testPerformAutoCleanupHandleUnplayed() throws IOException { + final int numItems = EPISODE_CACHE_SIZE * 2; + + Feed feed = new Feed("url", null, "title"); + List items = new ArrayList<>(); + feed.setItems(items); + List files = new ArrayList<>(); + populateItems(numItems, feed, items, files, FeedItem.UNPLAYED, false, false); + + DBTasks.performAutoCleanup(context); + for (File file : files) { + assertTrue(file.exists()); + } + } + + @Test + public void testPerformAutoCleanupShouldNotDeleteBecauseInQueue() throws IOException { + final int numItems = EPISODE_CACHE_SIZE * 2; + + Feed feed = new Feed("url", null, "title"); + List items = new ArrayList<>(); + feed.setItems(items); + List files = new ArrayList<>(); + populateItems(numItems, feed, items, files, FeedItem.PLAYED, true, false); + + DBTasks.performAutoCleanup(context); + for (File file : files) { + assertTrue(file.exists()); + } + } + + /** + * Reproduces a bug where DBTasks.performAutoCleanup(android.content.Context) would use the ID + * of the FeedItem in the call to DBWriter.deleteFeedMediaOfItem instead of the ID of the FeedMedia. + * This would cause the wrong item to be deleted. + */ + @Test + public void testPerformAutoCleanupShouldNotDeleteBecauseInQueue_withFeedsWithNoMedia() throws IOException { + // add feed with no enclosures so that item ID != media ID + saveFeedlist(1, 10, false); + + // add candidate for performAutoCleanup + List feeds = saveFeedlist(1, 1, true); + FeedMedia m = feeds.get(0).getItems().get(0).getMedia(); + //noinspection ConstantConditions + m.setDownloaded(true); + m.setFile_url("file"); + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.setMedia(m); + adapter.close(); + + testPerformAutoCleanupShouldNotDeleteBecauseInQueue(); + } + + @Test + public void testPerformAutoCleanupShouldNotDeleteBecauseFavorite() throws IOException { + final int numItems = EPISODE_CACHE_SIZE * 2; + + Feed feed = new Feed("url", null, "title"); + List items = new ArrayList<>(); + feed.setItems(items); + List files = new ArrayList<>(); + populateItems(numItems, feed, items, files, FeedItem.PLAYED, false, true); + + DBTasks.performAutoCleanup(context); + for (File file : files) { + assertTrue(file.exists()); + } + } +} diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java new file mode 100644 index 000000000..6e53bd20e --- /dev/null +++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java @@ -0,0 +1,52 @@ +package de.danoeh.antennapod.core.storage; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import de.danoeh.antennapod.core.feed.Feed; +import de.danoeh.antennapod.core.feed.FeedItem; +import de.danoeh.antennapod.core.preferences.UserPreferences; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +/** + * Tests that the APQueueCleanupAlgorithm is working correctly. + */ +@RunWith(RobolectricTestRunner.class) +public class DbQueueCleanupAlgorithmTest extends DbCleanupTests { + + public DbQueueCleanupAlgorithmTest() { + setCleanupAlgorithm(UserPreferences.EPISODE_CLEANUP_QUEUE); + } + + /** + * For APQueueCleanupAlgorithm we expect even unplayed episodes to be deleted if needed + * if they aren't in the queue. + */ + @Test + public void testPerformAutoCleanupHandleUnplayed() throws IOException { + final int numItems = EPISODE_CACHE_SIZE * 2; + + Feed feed = new Feed("url", null, "title"); + List items = new ArrayList<>(); + feed.setItems(items); + List files = new ArrayList<>(); + populateItems(numItems, feed, items, files, FeedItem.UNPLAYED, false, false); + + DBTasks.performAutoCleanup(context); + for (int i = 0; i < files.size(); i++) { + if (i < EPISODE_CACHE_SIZE) { + assertTrue(files.get(i).exists()); + } else { + assertFalse(files.get(i).exists()); + } + } + } +} diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java new file mode 100644 index 000000000..212b94743 --- /dev/null +++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java @@ -0,0 +1,420 @@ +package de.danoeh.antennapod.core.storage; + +import android.content.Context; + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Random; + +import androidx.test.platform.app.InstrumentationRegistry; +import de.danoeh.antennapod.core.feed.Feed; +import de.danoeh.antennapod.core.feed.FeedItem; +import de.danoeh.antennapod.core.feed.FeedMedia; +import de.danoeh.antennapod.core.preferences.UserPreferences; +import de.danoeh.antennapod.core.util.LongList; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; + +import static de.danoeh.antennapod.core.storage.DbTestUtils.saveFeedlist; +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; + +/** + * Test class for DBReader. + */ +@SuppressWarnings("ConstantConditions") +@RunWith(RobolectricTestRunner.class) +public class DbReaderTest { + + @Before + public void setUp() { + Context context = InstrumentationRegistry.getInstrumentation().getContext(); + UserPreferences.init(context); + + PodDBAdapter.init(context); + PodDBAdapter.deleteDatabase(); + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.close(); + } + + @After + public void tearDown() { + PodDBAdapter.tearDownTests(); + DBWriter.tearDownTests(); + } + + @Test + public void testGetFeedList() { + List feeds = saveFeedlist(10, 0, false); + List savedFeeds = DBReader.getFeedList(); + assertNotNull(savedFeeds); + assertEquals(feeds.size(), savedFeeds.size()); + for (int i = 0; i < feeds.size(); i++) { + assertEquals(feeds.get(i).getId(), savedFeeds.get(i).getId()); + } + } + + @Test + public void testGetFeedListSortOrder() { + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + + Feed feed1 = new Feed(0, null, "A", "link", "d", null, null, null, "rss", "A", null, "", "", true); + Feed feed2 = new Feed(0, null, "b", "link", "d", null, null, null, "rss", "b", null, "", "", true); + Feed feed3 = new Feed(0, null, "C", "link", "d", null, null, null, "rss", "C", null, "", "", true); + Feed feed4 = new Feed(0, null, "d", "link", "d", null, null, null, "rss", "d", null, "", "", true); + adapter.setCompleteFeed(feed1); + adapter.setCompleteFeed(feed2); + adapter.setCompleteFeed(feed3); + adapter.setCompleteFeed(feed4); + assertTrue(feed1.getId() != 0); + assertTrue(feed2.getId() != 0); + assertTrue(feed3.getId() != 0); + assertTrue(feed4.getId() != 0); + + adapter.close(); + + List saved = DBReader.getFeedList(); + assertNotNull(saved); + assertEquals("Wrong size: ", 4, saved.size()); + + assertEquals("Wrong id of feed 1: ", feed1.getId(), saved.get(0).getId()); + assertEquals("Wrong id of feed 2: ", feed2.getId(), saved.get(1).getId()); + assertEquals("Wrong id of feed 3: ", feed3.getId(), saved.get(2).getId()); + assertEquals("Wrong id of feed 4: ", feed4.getId(), saved.get(3).getId()); + } + + @Test + public void testFeedListDownloadUrls() { + List feeds = saveFeedlist(10, 0, false); + List urls = DBReader.getFeedListDownloadUrls(); + assertNotNull(urls); + assertEquals(feeds.size(), urls.size()); + for (int i = 0; i < urls.size(); i++) { + assertEquals(urls.get(i), feeds.get(i).getDownload_url()); + } + } + + @Test + public void testLoadFeedDataOfFeedItemlist() { + final int numFeeds = 10; + final int numItems = 1; + List feeds = saveFeedlist(numFeeds, numItems, false); + List items = new ArrayList<>(); + for (Feed f : feeds) { + for (FeedItem item : f.getItems()) { + item.setFeed(null); + item.setFeedId(f.getId()); + items.add(item); + } + } + DBReader.loadAdditionalFeedItemListData(items); + for (int i = 0; i < numFeeds; i++) { + for (int j = 0; j < numItems; j++) { + FeedItem item = feeds.get(i).getItems().get(j); + assertNotNull(item.getFeed()); + assertEquals(feeds.get(i).getId(), item.getFeed().getId()); + assertEquals(item.getFeed().getId(), item.getFeedId()); + } + } + } + + @Test + public void testGetFeedItemList() { + final int numFeeds = 1; + final int numItems = 10; + Feed feed = saveFeedlist(numFeeds, numItems, false).get(0); + List items = feed.getItems(); + feed.setItems(null); + List savedItems = DBReader.getFeedItemList(feed); + assertNotNull(savedItems); + assertEquals(items.size(), savedItems.size()); + for (int i = 0; i < savedItems.size(); i++) { + assertEquals(savedItems.get(i).getId(), items.get(i).getId()); + } + } + + @SuppressWarnings("SameParameterValue") + private List saveQueue(int numItems) { + if (numItems <= 0) { + throw new IllegalArgumentException("numItems<=0"); + } + List feeds = saveFeedlist(numItems, numItems, false); + List allItems = new ArrayList<>(); + for (Feed f : feeds) { + allItems.addAll(f.getItems()); + } + // take random items from every feed + Random random = new Random(); + List queue = new ArrayList<>(); + while (queue.size() < numItems) { + int index = random.nextInt(numItems); + if (!queue.contains(allItems.get(index))) { + queue.add(allItems.get(index)); + } + } + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.setQueue(queue); + adapter.close(); + return queue; + } + + @Test + public void testGetQueueIdList() { + final int numItems = 10; + List queue = saveQueue(numItems); + LongList ids = DBReader.getQueueIDList(); + assertNotNull(ids); + assertEquals(ids.size(), queue.size()); + for (int i = 0; i < queue.size(); i++) { + assertTrue(ids.get(i) != 0); + assertEquals(ids.get(i), queue.get(i).getId()); + } + } + + @Test + public void testGetQueue() { + final int numItems = 10; + List queue = saveQueue(numItems); + List savedQueue = DBReader.getQueue(); + assertNotNull(savedQueue); + assertEquals(savedQueue.size(), queue.size()); + for (int i = 0; i < queue.size(); i++) { + assertTrue(savedQueue.get(i).getId() != 0); + assertEquals(savedQueue.get(i).getId(), queue.get(i).getId()); + } + } + + @SuppressWarnings("SameParameterValue") + private List saveDownloadedItems(int numItems) { + if (numItems <= 0) { + throw new IllegalArgumentException("numItems<=0"); + } + List feeds = saveFeedlist(numItems, numItems, true); + List items = new ArrayList<>(); + for (Feed f : feeds) { + items.addAll(f.getItems()); + } + List downloaded = new ArrayList<>(); + Random random = new Random(); + + while (downloaded.size() < numItems) { + int i = random.nextInt(numItems); + if (!downloaded.contains(items.get(i))) { + FeedItem item = items.get(i); + item.getMedia().setDownloaded(true); + item.getMedia().setFile_url("file" + i); + downloaded.add(item); + } + } + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.setFeedItemlist(downloaded); + adapter.close(); + return downloaded; + } + + @Test + public void testGetDownloadedItems() { + final int numItems = 10; + List downloaded = saveDownloadedItems(numItems); + List downloadedSaved = DBReader.getDownloadedItems(); + assertNotNull(downloadedSaved); + assertEquals(downloaded.size(), downloadedSaved.size()); + for (FeedItem item : downloadedSaved) { + assertNotNull(item.getMedia()); + assertTrue(item.getMedia().isDownloaded()); + assertNotNull(item.getMedia().getDownload_url()); + } + } + + @SuppressWarnings("SameParameterValue") + private List saveNewItems(int numItems) { + List feeds = saveFeedlist(numItems, numItems, true); + List items = new ArrayList<>(); + for (Feed f : feeds) { + items.addAll(f.getItems()); + } + List newItems = new ArrayList<>(); + Random random = new Random(); + + while (newItems.size() < numItems) { + int i = random.nextInt(numItems); + if (!newItems.contains(items.get(i))) { + FeedItem item = items.get(i); + item.setNew(); + newItems.add(item); + } + } + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + adapter.setFeedItemlist(newItems); + adapter.close(); + return newItems; + } + + @Test + public void testGetNewItemIds() { + final int numItems = 10; + + List newItems = saveNewItems(numItems); + long[] unreadIds = new long[newItems.size()]; + for (int i = 0; i < newItems.size(); i++) { + unreadIds[i] = newItems.get(i).getId(); + } + List newItemsSaved = DBReader.getNewItemsList(0, Integer.MAX_VALUE); + assertNotNull(newItemsSaved); + assertEquals(newItemsSaved.size(), newItems.size()); + for (FeedItem feedItem : newItemsSaved) { + long savedId = feedItem.getId(); + boolean found = false; + for (long id : unreadIds) { + if (id == savedId) { + found = true; + break; + } + } + assertTrue(found); + } + } + + @Test + public void testGetPlaybackHistory() { + final int numItems = (DBReader.PLAYBACK_HISTORY_SIZE + 1) * 2; + final int playedItems = DBReader.PLAYBACK_HISTORY_SIZE + 1; + final int numReturnedItems = Math.min(playedItems, DBReader.PLAYBACK_HISTORY_SIZE); + final int numFeeds = 1; + + Feed feed = DbTestUtils.saveFeedlist(numFeeds, numItems, true).get(0); + long[] ids = new long[playedItems]; + + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + for (int i = 0; i < playedItems; i++) { + FeedMedia m = feed.getItems().get(i).getMedia(); + m.setPlaybackCompletionDate(new Date(i + 1)); + adapter.setFeedMediaPlaybackCompletionDate(m); + ids[ids.length - 1 - i] = m.getItem().getId(); + } + adapter.close(); + + List saved = DBReader.getPlaybackHistory(); + assertNotNull(saved); + assertEquals("Wrong size: ", numReturnedItems, saved.size()); + for (int i = 0; i < numReturnedItems; i++) { + FeedItem item = saved.get(i); + assertNotNull(item.getMedia().getPlaybackCompletionDate()); + assertEquals("Wrong sort order: ", item.getId(), ids[i]); + } + } + + @Test + public void testGetNavDrawerDataQueueEmptyNoUnreadItems() { + final int numFeeds = 10; + final int numItems = 10; + DbTestUtils.saveFeedlist(numFeeds, numItems, true); + DBReader.NavDrawerData navDrawerData = DBReader.getNavDrawerData(); + assertEquals(numFeeds, navDrawerData.feeds.size()); + assertEquals(0, navDrawerData.numNewItems); + assertEquals(0, navDrawerData.queueSize); + } + + @Test + public void testGetNavDrawerDataQueueNotEmptyWithUnreadItems() { + final int numFeeds = 10; + final int numItems = 10; + final int numQueue = 1; + final int numNew = 2; + List feeds = DbTestUtils.saveFeedlist(numFeeds, numItems, true); + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + for (int i = 0; i < numNew; i++) { + FeedItem item = feeds.get(0).getItems().get(i); + item.setNew(); + adapter.setSingleFeedItem(item); + } + List queue = new ArrayList<>(); + for (int i = 0; i < numQueue; i++) { + FeedItem item = feeds.get(1).getItems().get(i); + queue.add(item); + } + adapter.setQueue(queue); + + adapter.close(); + + DBReader.NavDrawerData navDrawerData = DBReader.getNavDrawerData(); + assertEquals(numFeeds, navDrawerData.feeds.size()); + assertEquals(numNew, navDrawerData.numNewItems); + assertEquals(numQueue, navDrawerData.queueSize); + } + + @Test + public void testGetFeedItemlistCheckChaptersFalse() { + List feeds = DbTestUtils.saveFeedlist(10, 10, false, false, 0); + for (Feed feed : feeds) { + for (FeedItem item : feed.getItems()) { + assertFalse(item.hasChapters()); + } + } + } + + @Test + public void testGetFeedItemlistCheckChaptersTrue() { + List feeds = saveFeedlist(10, 10, false, true, 10); + for (Feed feed : feeds) { + for (FeedItem item : feed.getItems()) { + assertTrue(item.hasChapters()); + } + } + } + + @Test + public void testLoadChaptersOfFeedItemNoChapters() { + List feeds = saveFeedlist(1, 3, false, false, 0); + saveFeedlist(1, 3, false, true, 3); + for (Feed feed : feeds) { + for (FeedItem item : feed.getItems()) { + assertFalse(item.hasChapters()); + item.setChapters(DBReader.loadChaptersOfFeedItem(item)); + assertFalse(item.hasChapters()); + assertNull(item.getChapters()); + } + } + } + + @Test + public void testLoadChaptersOfFeedItemWithChapters() { + final int numChapters = 3; + DbTestUtils.saveFeedlist(1, 3, false, false, 0); + List feeds = saveFeedlist(1, 3, false, true, numChapters); + for (Feed feed : feeds) { + for (FeedItem item : feed.getItems()) { + assertTrue(item.hasChapters()); + item.setChapters(DBReader.loadChaptersOfFeedItem(item)); + assertTrue(item.hasChapters()); + assertNotNull(item.getChapters()); + assertEquals(numChapters, item.getChapters().size()); + } + } + } + + @Test + public void testGetItemWithChapters() { + final int numChapters = 3; + List feeds = saveFeedlist(1, 1, false, true, numChapters); + FeedItem item1 = feeds.get(0).getItems().get(0); + FeedItem item2 = DBReader.getFeedItem(item1.getId()); + item2.setChapters(DBReader.loadChaptersOfFeedItem(item2)); + assertTrue(item2.hasChapters()); + assertEquals(item1.getChapters(), item2.getChapters()); + } +} diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java new file mode 100644 index 000000000..400ddda36 --- /dev/null +++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java @@ -0,0 +1,77 @@ +package de.danoeh.antennapod.core.storage; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Date; +import java.util.List; + +import de.danoeh.antennapod.core.feed.Chapter; +import de.danoeh.antennapod.core.feed.Feed; +import de.danoeh.antennapod.core.feed.FeedItem; +import de.danoeh.antennapod.core.feed.FeedMedia; +import de.danoeh.antennapod.core.feed.SimpleChapter; +import de.danoeh.antennapod.core.util.comparator.FeedItemPubdateComparator; + +import static org.junit.Assert.assertTrue; + +/** + * Utility methods for DB* tests. + */ +abstract class DbTestUtils { + + /** + * Use this method when tests don't involve chapters. + */ + public static List saveFeedlist(int numFeeds, int numItems, boolean withMedia) { + return saveFeedlist(numFeeds, numItems, withMedia, false, 0); + } + + /** + * Use this method when tests involve chapters. + */ + public static List saveFeedlist(int numFeeds, int numItems, boolean withMedia, + boolean withChapters, int numChapters) { + if (numFeeds <= 0) { + throw new IllegalArgumentException("numFeeds<=0"); + } + if (numItems < 0) { + throw new IllegalArgumentException("numItems<0"); + } + + List feeds = new ArrayList<>(); + PodDBAdapter adapter = PodDBAdapter.getInstance(); + adapter.open(); + for (int i = 0; i < numFeeds; i++) { + Feed f = new Feed(0, null, "feed " + i, "link" + i, "descr", null, null, + null, null, "id" + i, null, null, "url" + i, false); + f.setItems(new ArrayList<>()); + for (int j = 0; j < numItems; j++) { + FeedItem item = new FeedItem(0, "item " + j, "id" + j, "link" + j, new Date(), + FeedItem.PLAYED, f, withChapters); + if (withMedia) { + FeedMedia media = new FeedMedia(item, "url" + j, 1, "audio/mp3"); + item.setMedia(media); + } + if (withChapters) { + List chapters = new ArrayList<>(); + item.setChapters(chapters); + for (int k = 0; k < numChapters; k++) { + chapters.add(new SimpleChapter(k, "item " + j + " chapter " + k, + "http://example.com", "http://example.com/image.png")); + } + } + f.getItems().add(item); + } + Collections.sort(f.getItems(), new FeedItemPubdateComparator()); + adapter.setCompleteFeed(f); + assertTrue(f.getId() != 0); + for (FeedItem item : f.getItems()) { + assertTrue(item.getId() != 0); + } + feeds.add(f); + } + adapter.close(); + + return feeds; + } +} -- cgit v1.2.3