diff --git a/app/src/test/java/eu/kanade/tachiyomi/BackupTest.java b/app/src/test/java/eu/kanade/tachiyomi/BackupTest.java deleted file mode 100644 index f90c75142e..0000000000 --- a/app/src/test/java/eu/kanade/tachiyomi/BackupTest.java +++ /dev/null @@ -1,573 +0,0 @@ -package eu.kanade.tachiyomi; - -import android.app.Application; -import android.os.Build; - -import com.google.gson.Gson; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.robolectric.RuntimeEnvironment; -import org.robolectric.annotation.Config; - -import java.util.ArrayList; -import java.util.List; - -import eu.kanade.tachiyomi.data.backup.BackupManager; -import eu.kanade.tachiyomi.data.database.DatabaseHelper; -import eu.kanade.tachiyomi.data.database.models.Category; -import eu.kanade.tachiyomi.data.database.models.Chapter; -import eu.kanade.tachiyomi.data.database.models.Manga; -import eu.kanade.tachiyomi.data.database.models.MangaCategory; -import eu.kanade.tachiyomi.data.database.models.MangaSync; - -import static org.assertj.core.api.Assertions.assertThat; - -@Config(constants = BuildConfig.class, sdk = Build.VERSION_CODES.LOLLIPOP) -@RunWith(CustomRobolectricGradleTestRunner.class) -public class BackupTest { - - DatabaseHelper db; - BackupManager backupManager; - Gson gson; - JsonObject root; - - @Before - public void setup() { - Application app = RuntimeEnvironment.application; - db = new DatabaseHelper(app); - backupManager = new BackupManager(db); - gson = new Gson(); - root = new JsonObject(); - } - - @Test - public void testRestoreCategory() { - String catName = "cat"; - root = createRootJson(null, toJson(createCategories(catName))); - backupManager.restoreFromJson(root); - - List dbCats = db.getCategories().executeAsBlocking(); - assertThat(dbCats).hasSize(1); - assertThat(dbCats.get(0).name).isEqualTo(catName); - } - - @Test - public void testRestoreEmptyCategory() { - root = createRootJson(null, toJson(new ArrayList<>())); - backupManager.restoreFromJson(root); - List dbCats = db.getCategories().executeAsBlocking(); - assertThat(dbCats).isEmpty(); - } - - @Test - public void testRestoreExistingCategory() { - String catName = "cat"; - db.insertCategory(createCategory(catName)).executeAsBlocking(); - - root = createRootJson(null, toJson(createCategories(catName))); - backupManager.restoreFromJson(root); - - List dbCats = db.getCategories().executeAsBlocking(); - assertThat(dbCats).hasSize(1); - assertThat(dbCats.get(0).name).isEqualTo(catName); - } - - @Test - public void testRestoreCategories() { - root = createRootJson(null, toJson(createCategories("cat", "cat2", "cat3"))); - backupManager.restoreFromJson(root); - - List dbCats = db.getCategories().executeAsBlocking(); - assertThat(dbCats).hasSize(3); - } - - @Test - public void testRestoreExistingCategories() { - db.insertCategories(createCategories("cat", "cat2")).executeAsBlocking(); - - root = createRootJson(null, toJson(createCategories("cat", "cat2", "cat3"))); - backupManager.restoreFromJson(root); - - List dbCats = db.getCategories().executeAsBlocking(); - assertThat(dbCats).hasSize(3); - } - - @Test - public void testRestoreExistingCategoriesAlt() { - db.insertCategories(createCategories("cat", "cat2", "cat3")).executeAsBlocking(); - - root = createRootJson(null, toJson(createCategories("cat", "cat2"))); - backupManager.restoreFromJson(root); - - List dbCats = db.getCategories().executeAsBlocking(); - assertThat(dbCats).hasSize(3); - } - - @Test - public void testRestoreManga() { - String mangaName = "title"; - List mangas = createMangas(mangaName); - List elements = new ArrayList<>(); - for (Manga manga : mangas) { - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - elements.add(entry); - } - root = createRootJson(toJson(elements), null); - backupManager.restoreFromJson(root); - - List dbMangas = db.getMangas().executeAsBlocking(); - assertThat(dbMangas).hasSize(1); - assertThat(dbMangas.get(0).title).isEqualTo(mangaName); - } - - @Test - public void testRestoreExistingManga() { - String mangaName = "title"; - Manga manga = createManga(mangaName); - - db.insertManga(manga).executeAsBlocking(); - - List elements = new ArrayList<>(); - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - elements.add(entry); - - root = createRootJson(toJson(elements), null); - backupManager.restoreFromJson(root); - - List dbMangas = db.getMangas().executeAsBlocking(); - assertThat(dbMangas).hasSize(1); - } - - @Test - public void testRestoreExistingMangaWithUpdatedFields() { - // Store a manga in db - String mangaName = "title"; - String updatedThumbnailUrl = "updated thumbnail url"; - Manga manga = createManga(mangaName); - manga.chapter_flags = 1024; - manga.thumbnail_url = updatedThumbnailUrl; - db.insertManga(manga).executeAsBlocking(); - - // Add an entry for a new manga with different attributes - manga = createManga(mangaName); - manga.chapter_flags = 512; - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - - // Append the entry to the backup list - List elements = new ArrayList<>(); - elements.add(entry); - - // Restore from json - root = createRootJson(toJson(elements), null); - backupManager.restoreFromJson(root); - - List dbMangas = db.getMangas().executeAsBlocking(); - assertThat(dbMangas).hasSize(1); - assertThat(dbMangas.get(0).thumbnail_url).isEqualTo(updatedThumbnailUrl); - assertThat(dbMangas.get(0).chapter_flags).isEqualTo(512); - } - - @Test - public void testRestoreChaptersForManga() { - // Create a manga and 3 chapters - Manga manga = createManga("title"); - manga.id = 1L; - List chapters = createChapters(manga, "1", "2", "3"); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("chapters", toJson(chapters)); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), null); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(1).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - List dbChapters = db.getChapters(dbManga).executeAsBlocking(); - assertThat(dbChapters).hasSize(3); - } - - @Test - public void testRestoreChaptersForExistingManga() { - long mangaId = 3; - // Create a manga and 3 chapters - Manga manga = createManga("title"); - manga.id = mangaId; - List chapters = createChapters(manga, "1", "2", "3"); - db.insertManga(manga).executeAsBlocking(); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("chapters", toJson(chapters)); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), null); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(mangaId).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - List dbChapters = db.getChapters(dbManga).executeAsBlocking(); - assertThat(dbChapters).hasSize(3); - } - - @Test - public void testRestoreExistingChaptersForExistingManga() { - long mangaId = 5; - // Store a manga and 3 chapters - Manga manga = createManga("title"); - manga.id = mangaId; - List chapters = createChapters(manga, "1", "2", "3"); - db.insertManga(manga).executeAsBlocking(); - db.insertChapters(chapters).executeAsBlocking(); - - // The backup contains a existing chapter and a new one, so it should have 4 chapters - chapters = createChapters(manga, "3", "4"); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("chapters", toJson(chapters)); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), null); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(mangaId).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - List dbChapters = db.getChapters(dbManga).executeAsBlocking(); - assertThat(dbChapters).hasSize(4); - } - - @Test - public void testRestoreCategoriesForManga() { - // Create a manga - Manga manga = createManga("title"); - - // Create categories - List categories = createCategories("cat1", "cat2", "cat3"); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("categories", toJson(createStringCategories("cat1"))); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), toJson(categories)); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(1).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - assertThat(db.getCategoriesForManga(dbManga).executeAsBlocking()) - .hasSize(1) - .contains(Category.create("cat1")) - .doesNotContain(Category.create("cat2")); - } - - @Test - public void testRestoreCategoriesForExistingManga() { - // Store a manga - Manga manga = createManga("title"); - db.insertManga(manga).executeAsBlocking(); - - // Create categories - List categories = createCategories("cat1", "cat2", "cat3"); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("categories", toJson(createStringCategories("cat1"))); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), toJson(categories)); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(1).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - assertThat(db.getCategoriesForManga(dbManga).executeAsBlocking()) - .hasSize(1) - .contains(Category.create("cat1")) - .doesNotContain(Category.create("cat2")); - } - - @Test - public void testRestoreMultipleCategoriesForManga() { - // Create a manga - Manga manga = createManga("title"); - - // Create categories - List categories = createCategories("cat1", "cat2", "cat3"); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("categories", toJson(createStringCategories("cat1", "cat3"))); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), toJson(categories)); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(1).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - assertThat(db.getCategoriesForManga(dbManga).executeAsBlocking()) - .hasSize(2) - .contains(Category.create("cat1"), Category.create("cat3")) - .doesNotContain(Category.create("cat2")); - } - - @Test - public void testRestoreMultipleCategoriesForExistingMangaAndCategory() { - // Store a manga and a category - Manga manga = createManga("title"); - manga.id = 1L; - db.insertManga(manga).executeAsBlocking(); - - Category cat = createCategory("cat1"); - cat.id = 1; - db.insertCategory(cat).executeAsBlocking(); - db.insertMangaCategory(MangaCategory.create(manga, cat)).executeAsBlocking(); - - // Create categories - List categories = createCategories("cat1", "cat2", "cat3"); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("categories", toJson(createStringCategories("cat1", "cat2"))); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), toJson(categories)); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(1).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - assertThat(db.getCategoriesForManga(dbManga).executeAsBlocking()) - .hasSize(2) - .contains(Category.create("cat1"), Category.create("cat2")) - .doesNotContain(Category.create("cat3")); - } - - @Test - public void testRestoreSyncForManga() { - // Create a manga and mangaSync - Manga manga = createManga("title"); - manga.id = 1L; - - List mangaSync = createMangaSync(manga, 1, 2, 3); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("sync", toJson(mangaSync)); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), null); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(1).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - List dbSync = db.getMangasSync(dbManga).executeAsBlocking(); - assertThat(dbSync).hasSize(3); - } - - @Test - public void testRestoreSyncForExistingManga() { - long mangaId = 3; - // Create a manga and 3 sync - Manga manga = createManga("title"); - manga.id = mangaId; - List mangaSync = createMangaSync(manga, 1, 2, 3); - db.insertManga(manga).executeAsBlocking(); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("sync", toJson(mangaSync)); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), null); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(mangaId).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - List dbSync = db.getMangasSync(dbManga).executeAsBlocking(); - assertThat(dbSync).hasSize(3); - } - - @Test - public void testRestoreExistingSyncForExistingManga() { - long mangaId = 5; - // Store a manga and 3 sync - Manga manga = createManga("title"); - manga.id = mangaId; - List mangaSync = createMangaSync(manga, 1, 2, 3); - db.insertManga(manga).executeAsBlocking(); - db.insertMangasSync(mangaSync).executeAsBlocking(); - - // The backup contains a existing sync and a new one, so it should have 4 sync - mangaSync = createMangaSync(manga, 3, 4); - - // Add an entry for the manga - JsonObject entry = new JsonObject(); - entry.add("manga", toJson(manga)); - entry.add("sync", toJson(mangaSync)); - - // Append the entry to the backup list - List mangas = new ArrayList<>(); - mangas.add(entry); - - // Restore from json - root = createRootJson(toJson(mangas), null); - backupManager.restoreFromJson(root); - - Manga dbManga = db.getManga(mangaId).executeAsBlocking(); - assertThat(dbManga).isNotNull(); - - List dbSync = db.getMangasSync(dbManga).executeAsBlocking(); - assertThat(dbSync).hasSize(4); - } - - private JsonObject createRootJson(JsonElement mangas, JsonElement categories) { - JsonObject root = new JsonObject(); - if (mangas != null) - root.add("mangas", mangas); - if (categories != null) - root.add("categories", categories); - return root; - } - - private Category createCategory(String name) { - Category c = new Category(); - c.name = name; - return c; - } - - private List createCategories(String... names) { - List cats = new ArrayList<>(); - for (String name : names) { - cats.add(createCategory(name)); - } - return cats; - } - - private List createStringCategories(String... names) { - List cats = new ArrayList<>(); - for (String name : names) { - cats.add(name); - } - return cats; - } - - private Manga createManga(String title) { - Manga m = new Manga(); - m.title = title; - m.author = ""; - m.artist = ""; - m.thumbnail_url = ""; - m.genre = "a list of genres"; - m.description = "long description"; - m.url = "url to manga"; - m.favorite = true; - m.source = 1; - return m; - } - - private List createMangas(String... titles) { - List mangas = new ArrayList<>(); - for (String title : titles) { - mangas.add(createManga(title)); - } - return mangas; - } - - private Chapter createChapter(Manga manga, String url) { - Chapter c = Chapter.create(); - c.url = url; - c.name = url; - c.manga_id = manga.id; - return c; - } - - private List createChapters(Manga manga, String... urls) { - List chapters = new ArrayList<>(); - for (String url : urls) { - chapters.add(createChapter(manga, url)); - } - return chapters; - } - - private MangaSync createMangaSync(Manga manga, int syncId) { - MangaSync m = MangaSync.create(); - m.manga_id = manga.id; - m.sync_id = syncId; - m.title = "title"; - return m; - } - - private List createMangaSync(Manga manga, Integer... syncIds) { - List ms = new ArrayList<>(); - for (int title : syncIds) { - ms.add(createMangaSync(manga, title)); - } - return ms; - } - - private JsonElement toJson(Object element) { - return gson.toJsonTree(element); - } - -} \ No newline at end of file diff --git a/app/src/test/java/eu/kanade/tachiyomi/CategoryTest.java b/app/src/test/java/eu/kanade/tachiyomi/CategoryTest.java deleted file mode 100644 index 4f7325d3a1..0000000000 --- a/app/src/test/java/eu/kanade/tachiyomi/CategoryTest.java +++ /dev/null @@ -1,115 +0,0 @@ -package eu.kanade.tachiyomi; - -import android.app.Application; -import android.os.Build; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.robolectric.RuntimeEnvironment; -import org.robolectric.annotation.Config; - -import java.util.List; - -import eu.kanade.tachiyomi.data.database.DatabaseHelper; -import eu.kanade.tachiyomi.data.database.models.Category; -import eu.kanade.tachiyomi.data.database.models.Manga; -import eu.kanade.tachiyomi.data.database.models.MangaCategory; - -import static org.assertj.core.api.Assertions.assertThat; - -@Config(constants = BuildConfig.class, sdk = Build.VERSION_CODES.LOLLIPOP) -@RunWith(CustomRobolectricGradleTestRunner.class) -public class CategoryTest { - - DatabaseHelper db; - - @Before - public void setup() { - Application app = RuntimeEnvironment.application; - db = new DatabaseHelper(app); - - // Create 5 mangas - createManga("a"); - createManga("b"); - createManga("c"); - createManga("d"); - createManga("e"); - } - - @Test - public void testHasCategories() { - // Create 2 categories - createCategory("Reading"); - createCategory("Hold"); - - List categories = db.getCategories().executeAsBlocking(); - assertThat(categories).hasSize(2); - } - - @Test - public void testHasLibraryMangas() { - List mangas = db.getLibraryMangas().executeAsBlocking(); - assertThat(mangas).hasSize(5); - } - - @Test - public void testHasCorrectFavorites() { - Manga m = new Manga(); - m.title = "title"; - m.author = ""; - m.artist = ""; - m.thumbnail_url = ""; - m.genre = "a list of genres"; - m.description = "long description"; - m.url = "url to manga"; - m.favorite = false; - db.insertManga(m).executeAsBlocking(); - List mangas = db.getLibraryMangas().executeAsBlocking(); - assertThat(mangas).hasSize(5); - } - - @Test - public void testMangaInCategory() { - // Create 2 categories - createCategory("Reading"); - createCategory("Hold"); - - // It should not have 0 as id - Category c = db.getCategories().executeAsBlocking().get(0); - assertThat(c.id).isNotZero(); - - // Add a manga to a category - Manga m = db.getMangas().executeAsBlocking().get(0); - MangaCategory mc = MangaCategory.create(m, c); - db.insertMangaCategory(mc).executeAsBlocking(); - - // Get mangas from library and assert manga category is the same - List mangas = db.getLibraryMangas().executeAsBlocking(); - for (Manga manga : mangas) { - if (manga.id.equals(m.id)) { - assertThat(manga.category).isEqualTo(c.id); - } - } - } - - private void createManga(String title) { - Manga m = new Manga(); - m.title = title; - m.author = ""; - m.artist = ""; - m.thumbnail_url = ""; - m.genre = "a list of genres"; - m.description = "long description"; - m.url = "url to manga"; - m.favorite = true; - db.insertManga(m).executeAsBlocking(); - } - - private void createCategory(String name) { - Category c = new Category(); - c.name = name; - db.insertCategory(c).executeAsBlocking(); - } - -} diff --git a/app/src/test/java/eu/kanade/tachiyomi/CategoryTest.kt b/app/src/test/java/eu/kanade/tachiyomi/CategoryTest.kt new file mode 100644 index 0000000000..f0b251699e --- /dev/null +++ b/app/src/test/java/eu/kanade/tachiyomi/CategoryTest.kt @@ -0,0 +1,109 @@ +package eu.kanade.tachiyomi + +import android.os.Build +import eu.kanade.tachiyomi.data.database.DatabaseHelper +import eu.kanade.tachiyomi.data.database.models.CategoryImpl +import eu.kanade.tachiyomi.data.database.models.Manga +import eu.kanade.tachiyomi.data.database.models.MangaCategory +import org.assertj.core.api.Assertions.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@Config(constants = BuildConfig::class, sdk = intArrayOf(Build.VERSION_CODES.LOLLIPOP)) +@RunWith(CustomRobolectricGradleTestRunner::class) +class CategoryTest { + + lateinit var db: DatabaseHelper + + @Before + fun setup() { + val app = RuntimeEnvironment.application + db = DatabaseHelper(app) + + // Create 5 manga + createManga("a") + createManga("b") + createManga("c") + createManga("d") + createManga("e") + } + + @Test + fun testHasCategories() { + // Create 2 categories + createCategory("Reading") + createCategory("Hold") + + val categories = db.getCategories().executeAsBlocking() + assertThat(categories).hasSize(2) + } + + @Test + fun testHasLibraryMangas() { + val mangas = db.getLibraryMangas().executeAsBlocking() + assertThat(mangas).hasSize(5) + } + + @Test + fun testHasCorrectFavorites() { + val m = Manga.create(0) + m.title = "title" + m.author = "" + m.artist = "" + m.thumbnail_url = "" + m.genre = "a list of genres" + m.description = "long description" + m.url = "url to manga" + m.favorite = false + db.insertManga(m).executeAsBlocking() + val mangas = db.getLibraryMangas().executeAsBlocking() + assertThat(mangas).hasSize(5) + } + + @Test + fun testMangaInCategory() { + // Create 2 categories + createCategory("Reading") + createCategory("Hold") + + // It should not have 0 as id + val c = db.getCategories().executeAsBlocking()[0] + assertThat(c.id).isNotZero() + + // Add a manga to a category + val m = db.getMangas().executeAsBlocking()[0] + val mc = MangaCategory.create(m, c) + db.insertMangaCategory(mc).executeAsBlocking() + + // Get mangas from library and assert manga category is the same + val mangas = db.getLibraryMangas().executeAsBlocking() + for (manga in mangas) { + if (manga.id == m.id) { + assertThat(manga.category).isEqualTo(c.id) + } + } + } + + private fun createManga(title: String) { + val m = Manga.create(0) + m.title = title + m.author = "" + m.artist = "" + m.thumbnail_url = "" + m.genre = "a list of genres" + m.description = "long description" + m.url = "url to manga" + m.favorite = true + db.insertManga(m).executeAsBlocking() + } + + private fun createCategory(name: String) { + val c = CategoryImpl() + c.name = name + db.insertCategory(c).executeAsBlocking() + } + +} diff --git a/app/src/test/java/eu/kanade/tachiyomi/ChapterRecognitionTest.kt b/app/src/test/java/eu/kanade/tachiyomi/ChapterRecognitionTest.kt index 5d80daa52d..e13cd15cf1 100644 --- a/app/src/test/java/eu/kanade/tachiyomi/ChapterRecognitionTest.kt +++ b/app/src/test/java/eu/kanade/tachiyomi/ChapterRecognitionTest.kt @@ -43,7 +43,7 @@ class ChapterRecognitionTest { * Called before test */ @Before fun setup() { - manga = Manga().apply { title = "random" } + manga = Manga.create(0).apply { title = "random" } chapter = Chapter.create() } diff --git a/app/src/test/java/eu/kanade/tachiyomi/TestApp.kt b/app/src/test/java/eu/kanade/tachiyomi/TestApp.kt index ac710e95d0..35a74ceb22 100644 --- a/app/src/test/java/eu/kanade/tachiyomi/TestApp.kt +++ b/app/src/test/java/eu/kanade/tachiyomi/TestApp.kt @@ -1,19 +1,7 @@ package eu.kanade.tachiyomi -import eu.kanade.tachiyomi.injection.component.AppComponent -import eu.kanade.tachiyomi.injection.component.DaggerAppComponent -import eu.kanade.tachiyomi.injection.module.AppModule -import eu.kanade.tachiyomi.injection.module.TestDataModule - open class TestApp : App() { - override fun createAppComponent(): AppComponent { - return DaggerAppComponent.builder() - .appModule(AppModule(this)) - .dataModule(TestDataModule()) - .build() - } - override fun setupAcra() { // Do nothing } diff --git a/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt b/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt new file mode 100644 index 0000000000..37b358e86e --- /dev/null +++ b/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt @@ -0,0 +1,568 @@ +package eu.kanade.tachiyomi.data.backup + +import android.os.Build +import com.google.gson.Gson +import com.google.gson.JsonElement +import com.google.gson.JsonObject +import eu.kanade.tachiyomi.BuildConfig +import eu.kanade.tachiyomi.CustomRobolectricGradleTestRunner +import eu.kanade.tachiyomi.data.database.DatabaseHelper +import eu.kanade.tachiyomi.data.database.models.* +import org.assertj.core.api.Assertions.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import uy.kohesive.injekt.injectLazy +import java.util.* + +@Config(constants = BuildConfig::class, sdk = intArrayOf(Build.VERSION_CODES.LOLLIPOP)) +@RunWith(CustomRobolectricGradleTestRunner::class) +class BackupTest { + + val gson: Gson by injectLazy() + + lateinit var db: DatabaseHelper + + lateinit var backupManager: BackupManager + + lateinit var root: JsonObject + + @Before + fun setup() { + val app = RuntimeEnvironment.application + db = DatabaseHelper(app) + backupManager = BackupManager(db) + root = JsonObject() + } + + @Test + fun testRestoreCategory() { + val catName = "cat" + root = createRootJson(null, toJson(createCategories(catName))) + backupManager.restoreFromJson(root) + + val dbCats = db.getCategories().executeAsBlocking() + assertThat(dbCats).hasSize(1) + assertThat(dbCats[0].name).isEqualTo(catName) + } + + @Test + fun testRestoreEmptyCategory() { + root = createRootJson(null, toJson(ArrayList())) + backupManager.restoreFromJson(root) + val dbCats = db.getCategories().executeAsBlocking() + assertThat(dbCats).isEmpty() + } + + @Test + fun testRestoreExistingCategory() { + val catName = "cat" + db.insertCategory(createCategory(catName)).executeAsBlocking() + + root = createRootJson(null, toJson(createCategories(catName))) + backupManager.restoreFromJson(root) + + val dbCats = db.getCategories().executeAsBlocking() + assertThat(dbCats).hasSize(1) + assertThat(dbCats[0].name).isEqualTo(catName) + } + + @Test + fun testRestoreCategories() { + root = createRootJson(null, toJson(createCategories("cat", "cat2", "cat3"))) + backupManager.restoreFromJson(root) + + val dbCats = db.getCategories().executeAsBlocking() + assertThat(dbCats).hasSize(3) + } + + @Test + fun testRestoreExistingCategories() { + db.insertCategories(createCategories("cat", "cat2")).executeAsBlocking() + + root = createRootJson(null, toJson(createCategories("cat", "cat2", "cat3"))) + backupManager.restoreFromJson(root) + + val dbCats = db.getCategories().executeAsBlocking() + assertThat(dbCats).hasSize(3) + } + + @Test + fun testRestoreExistingCategoriesAlt() { + db.insertCategories(createCategories("cat", "cat2", "cat3")).executeAsBlocking() + + root = createRootJson(null, toJson(createCategories("cat", "cat2"))) + backupManager.restoreFromJson(root) + + val dbCats = db.getCategories().executeAsBlocking() + assertThat(dbCats).hasSize(3) + } + + @Test + fun testRestoreManga() { + val mangaName = "title" + val mangas = createMangas(mangaName) + val elements = ArrayList() + for (manga in mangas) { + val entry = JsonObject() + entry.add("manga", toJson(manga)) + elements.add(entry) + } + root = createRootJson(toJson(elements), null) + backupManager.restoreFromJson(root) + + val dbMangas = db.getMangas().executeAsBlocking() + assertThat(dbMangas).hasSize(1) + assertThat(dbMangas[0].title).isEqualTo(mangaName) + } + + @Test + fun testRestoreExistingManga() { + val mangaName = "title" + val manga = createManga(mangaName) + + db.insertManga(manga).executeAsBlocking() + + val elements = ArrayList() + val entry = JsonObject() + entry.add("manga", toJson(manga)) + elements.add(entry) + + root = createRootJson(toJson(elements), null) + backupManager.restoreFromJson(root) + + val dbMangas = db.getMangas().executeAsBlocking() + assertThat(dbMangas).hasSize(1) + } + + @Test + fun testRestoreExistingMangaWithUpdatedFields() { + // Store a manga in db + val mangaName = "title" + val updatedThumbnailUrl = "updated thumbnail url" + var manga = createManga(mangaName) + manga.chapter_flags = 1024 + manga.thumbnail_url = updatedThumbnailUrl + db.insertManga(manga).executeAsBlocking() + + // Add an entry for a new manga with different attributes + manga = createManga(mangaName) + manga.chapter_flags = 512 + val entry = JsonObject() + entry.add("manga", toJson(manga)) + + // Append the entry to the backup list + val elements = ArrayList() + elements.add(entry) + + // Restore from json + root = createRootJson(toJson(elements), null) + backupManager.restoreFromJson(root) + + val dbMangas = db.getMangas().executeAsBlocking() + assertThat(dbMangas).hasSize(1) + assertThat(dbMangas[0].thumbnail_url).isEqualTo(updatedThumbnailUrl) + assertThat(dbMangas[0].chapter_flags).isEqualTo(512) + } + + @Test + fun testRestoreChaptersForManga() { + // Create a manga and 3 chapters + val manga = createManga("title") + manga.id = 1L + val chapters = createChapters(manga, "1", "2", "3") + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("chapters", toJson(chapters)) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), null) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(1).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val dbChapters = db.getChapters(dbManga!!).executeAsBlocking() + assertThat(dbChapters).hasSize(3) + } + + @Test + fun testRestoreChaptersForExistingManga() { + val mangaId: Long = 3 + // Create a manga and 3 chapters + val manga = createManga("title") + manga.id = mangaId + val chapters = createChapters(manga, "1", "2", "3") + db.insertManga(manga).executeAsBlocking() + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("chapters", toJson(chapters)) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), null) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(mangaId).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val dbChapters = db.getChapters(dbManga!!).executeAsBlocking() + assertThat(dbChapters).hasSize(3) + } + + @Test + fun testRestoreExistingChaptersForExistingManga() { + val mangaId: Long = 5 + // Store a manga and 3 chapters + val manga = createManga("title") + manga.id = mangaId + var chapters = createChapters(manga, "1", "2", "3") + db.insertManga(manga).executeAsBlocking() + db.insertChapters(chapters).executeAsBlocking() + + // The backup contains a existing chapter and a new one, so it should have 4 chapters + chapters = createChapters(manga, "3", "4") + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("chapters", toJson(chapters)) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), null) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(mangaId).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val dbChapters = db.getChapters(dbManga!!).executeAsBlocking() + assertThat(dbChapters).hasSize(4) + } + + @Test + fun testRestoreCategoriesForManga() { + // Create a manga + val manga = createManga("title") + + // Create categories + val categories = createCategories("cat1", "cat2", "cat3") + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("categories", toJson(createStringCategories("cat1"))) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), toJson(categories)) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(1).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val result = db.getCategoriesForManga(dbManga!!).executeAsBlocking() + + assertThat(result).hasSize(1) + assertThat(result).contains(Category.create("cat1")) + assertThat(result).doesNotContain(Category.create("cat2")) + } + + @Test + fun testRestoreCategoriesForExistingManga() { + // Store a manga + val manga = createManga("title") + db.insertManga(manga).executeAsBlocking() + + // Create categories + val categories = createCategories("cat1", "cat2", "cat3") + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("categories", toJson(createStringCategories("cat1"))) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), toJson(categories)) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(1).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val result = db.getCategoriesForManga(dbManga!!).executeAsBlocking() + + assertThat(result).hasSize(1) + assertThat(result).contains(Category.create("cat1")) + assertThat(result).doesNotContain(Category.create("cat2")) + } + + @Test + fun testRestoreMultipleCategoriesForManga() { + // Create a manga + val manga = createManga("title") + + // Create categories + val categories = createCategories("cat1", "cat2", "cat3") + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("categories", toJson(createStringCategories("cat1", "cat3"))) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), toJson(categories)) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(1).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val result = db.getCategoriesForManga(dbManga!!).executeAsBlocking() + + assertThat(result).hasSize(2) + assertThat(result).contains(Category.create("cat1"), Category.create("cat3")) + assertThat(result).doesNotContain(Category.create("cat2")) + } + + @Test + fun testRestoreMultipleCategoriesForExistingMangaAndCategory() { + // Store a manga and a category + val manga = createManga("title") + manga.id = 1L + db.insertManga(manga).executeAsBlocking() + + val cat = createCategory("cat1") + cat.id = 1 + db.insertCategory(cat).executeAsBlocking() + db.insertMangaCategory(MangaCategory.create(manga, cat)).executeAsBlocking() + + // Create categories + val categories = createCategories("cat1", "cat2", "cat3") + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("categories", toJson(createStringCategories("cat1", "cat2"))) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), toJson(categories)) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(1).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val result = db.getCategoriesForManga(dbManga!!).executeAsBlocking() + + assertThat(result).hasSize(2) + assertThat(result).contains(Category.create("cat1"), Category.create("cat2")) + assertThat(result).doesNotContain(Category.create("cat3")) + } + + @Test + fun testRestoreSyncForManga() { + // Create a manga and mangaSync + val manga = createManga("title") + manga.id = 1L + + val mangaSync = createMangaSync(manga, 1, 2, 3) + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("sync", toJson(mangaSync)) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), null) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(1).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val dbSync = db.getMangasSync(dbManga!!).executeAsBlocking() + assertThat(dbSync).hasSize(3) + } + + @Test + fun testRestoreSyncForExistingManga() { + val mangaId: Long = 3 + // Create a manga and 3 sync + val manga = createManga("title") + manga.id = mangaId + val mangaSync = createMangaSync(manga, 1, 2, 3) + db.insertManga(manga).executeAsBlocking() + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("sync", toJson(mangaSync)) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), null) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(mangaId).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val dbSync = db.getMangasSync(dbManga!!).executeAsBlocking() + assertThat(dbSync).hasSize(3) + } + + @Test + fun testRestoreExistingSyncForExistingManga() { + val mangaId: Long = 5 + // Store a manga and 3 sync + val manga = createManga("title") + manga.id = mangaId + var mangaSync = createMangaSync(manga, 1, 2, 3) + db.insertManga(manga).executeAsBlocking() + db.insertMangasSync(mangaSync).executeAsBlocking() + + // The backup contains a existing sync and a new one, so it should have 4 sync + mangaSync = createMangaSync(manga, 3, 4) + + // Add an entry for the manga + val entry = JsonObject() + entry.add("manga", toJson(manga)) + entry.add("sync", toJson(mangaSync)) + + // Append the entry to the backup list + val mangas = ArrayList() + mangas.add(entry) + + // Restore from json + root = createRootJson(toJson(mangas), null) + backupManager.restoreFromJson(root) + + val dbManga = db.getManga(mangaId).executeAsBlocking() + assertThat(dbManga).isNotNull() + + val dbSync = db.getMangasSync(dbManga!!).executeAsBlocking() + assertThat(dbSync).hasSize(4) + } + + private fun createRootJson(mangas: JsonElement?, categories: JsonElement?): JsonObject { + val root = JsonObject() + if (mangas != null) + root.add("mangas", mangas) + if (categories != null) + root.add("categories", categories) + return root + } + + private fun createCategory(name: String): Category { + val c = CategoryImpl() + c.name = name + return c + } + + private fun createCategories(vararg names: String): List { + val cats = ArrayList() + for (name in names) { + cats.add(createCategory(name)) + } + return cats + } + + private fun createStringCategories(vararg names: String): List { + val cats = ArrayList() + for (name in names) { + cats.add(name) + } + return cats + } + + private fun createManga(title: String): Manga { + val m = Manga.create(1) + m.title = title + m.author = "" + m.artist = "" + m.thumbnail_url = "" + m.genre = "a list of genres" + m.description = "long description" + m.url = "url to manga" + m.favorite = true + return m + } + + private fun createMangas(vararg titles: String): List { + val mangas = ArrayList() + for (title in titles) { + mangas.add(createManga(title)) + } + return mangas + } + + private fun createChapter(manga: Manga, url: String): Chapter { + val c = Chapter.create() + c.url = url + c.name = url + c.manga_id = manga.id + return c + } + + private fun createChapters(manga: Manga, vararg urls: String): List { + val chapters = ArrayList() + for (url in urls) { + chapters.add(createChapter(manga, url)) + } + return chapters + } + + private fun createMangaSync(manga: Manga, syncId: Int): MangaSync { + val m = MangaSync.create(syncId) + m.manga_id = manga.id!! + m.title = "title" + return m + } + + private fun createMangaSync(manga: Manga, vararg syncIds: Int): List { + val ms = ArrayList() + for (title in syncIds) { + ms.add(createMangaSync(manga, title)) + } + return ms + } + + private fun toJson(element: Any): JsonElement { + return gson.toJsonTree(element) + } + +} \ No newline at end of file diff --git a/app/src/test/java/eu/kanade/tachiyomi/data/library/LibraryUpdateServiceTest.java b/app/src/test/java/eu/kanade/tachiyomi/data/library/LibraryUpdateServiceTest.java deleted file mode 100644 index 0b392df1a7..0000000000 --- a/app/src/test/java/eu/kanade/tachiyomi/data/library/LibraryUpdateServiceTest.java +++ /dev/null @@ -1,115 +0,0 @@ -package eu.kanade.tachiyomi.data.library; - -import android.content.Context; -import android.os.Build; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.robolectric.Robolectric; -import org.robolectric.annotation.Config; -import org.robolectric.shadows.ShadowApplication; - -import java.util.ArrayList; -import java.util.List; - -import eu.kanade.tachiyomi.BuildConfig; -import eu.kanade.tachiyomi.CustomRobolectricGradleTestRunner; -import eu.kanade.tachiyomi.data.database.models.Chapter; -import eu.kanade.tachiyomi.data.database.models.Manga; -import eu.kanade.tachiyomi.data.source.online.OnlineSource; -import rx.Observable; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -@Config(constants = BuildConfig.class, sdk = Build.VERSION_CODES.LOLLIPOP) -@RunWith(CustomRobolectricGradleTestRunner.class) -public class LibraryUpdateServiceTest { - - ShadowApplication app; - Context context; - LibraryUpdateService service; - OnlineSource source; - - @Before - public void setup() { - app = ShadowApplication.getInstance(); - context = app.getApplicationContext(); - service = Robolectric.setupService(LibraryUpdateService.class); - source = mock(OnlineSource.class); - when(service.sourceManager.get(anyInt())).thenReturn(source); - } - - @Test - public void testLifecycle() { - // Smoke test - Robolectric.buildService(LibraryUpdateService.class) - .attach() - .create() - .startCommand(0, 0) - .destroy() - .get(); - } - - @Test - public void testUpdateManga() { - Manga manga = createManga("/manga1").get(0); - manga.id = 1L; - service.db.insertManga(manga).executeAsBlocking(); - - List sourceChapters = createChapters("/chapter1", "/chapter2"); - - when(source.fetchChapterList(manga)).thenReturn(Observable.just(sourceChapters)); - - service.updateManga(manga).subscribe(); - - assertThat(service.db.getChapters(manga).executeAsBlocking()).hasSize(2); - } - - @Test - public void testContinuesUpdatingWhenAMangaFails() { - List favManga = createManga("/manga1", "/manga2", "/manga3"); - service.db.insertMangas(favManga).executeAsBlocking(); - favManga = service.db.getFavoriteMangas().executeAsBlocking(); - - List chapters = createChapters("/chapter1", "/chapter2"); - List chapters3 = createChapters("/achapter1", "/achapter2"); - - // One of the updates will fail - when(source.fetchChapterList(favManga.get(0))).thenReturn(Observable.just(chapters)); - when(source.fetchChapterList(favManga.get(1))).thenReturn(Observable.>error(new Exception())); - when(source.fetchChapterList(favManga.get(2))).thenReturn(Observable.just(chapters3)); - - service.updateMangaList(service.getMangaToUpdate(null)).subscribe(); - - // There are 3 network attempts and 2 insertions (1 request failed) - assertThat(service.db.getChapters(favManga.get(0)).executeAsBlocking()).hasSize(2); - assertThat(service.db.getChapters(favManga.get(1)).executeAsBlocking()).hasSize(0); - assertThat(service.db.getChapters(favManga.get(2)).executeAsBlocking()).hasSize(2); - } - - private List createChapters(String... urls) { - List list = new ArrayList<>(); - for (String url : urls) { - Chapter c = Chapter.create(); - c.url = url; - c.name = url.substring(1); - list.add(c); - } - return list; - } - - private List createManga(String... urls) { - List list = new ArrayList<>(); - for (String url : urls) { - Manga m = Manga.create(url); - m.title = url.substring(1); - m.favorite = true; - list.add(m); - } - return list; - } -} diff --git a/app/src/test/java/eu/kanade/tachiyomi/data/library/LibraryUpdateServiceTest.kt b/app/src/test/java/eu/kanade/tachiyomi/data/library/LibraryUpdateServiceTest.kt new file mode 100644 index 0000000000..49c1d5de2b --- /dev/null +++ b/app/src/test/java/eu/kanade/tachiyomi/data/library/LibraryUpdateServiceTest.kt @@ -0,0 +1,137 @@ +package eu.kanade.tachiyomi.data.library + +import android.app.Application +import android.content.Context +import android.os.Build +import eu.kanade.tachiyomi.AppModule +import eu.kanade.tachiyomi.BuildConfig +import eu.kanade.tachiyomi.CustomRobolectricGradleTestRunner +import eu.kanade.tachiyomi.data.database.models.Chapter +import eu.kanade.tachiyomi.data.database.models.Manga +import eu.kanade.tachiyomi.data.source.SourceManager +import eu.kanade.tachiyomi.data.source.online.OnlineSource +import org.assertj.core.api.Assertions.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.Matchers.anyInt +import org.mockito.Mockito +import org.mockito.Mockito.* +import org.robolectric.Robolectric +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import rx.Observable +import uy.kohesive.injekt.Injekt +import uy.kohesive.injekt.api.InjektModule +import uy.kohesive.injekt.api.InjektRegistrar +import uy.kohesive.injekt.api.InjektScope +import uy.kohesive.injekt.api.addSingleton +import uy.kohesive.injekt.registry.default.DefaultRegistrar +import java.util.* + +@Config(constants = BuildConfig::class, sdk = intArrayOf(Build.VERSION_CODES.LOLLIPOP)) +@RunWith(CustomRobolectricGradleTestRunner::class) +class LibraryUpdateServiceTest { + + lateinit var app: Application + lateinit var context: Context + lateinit var service: LibraryUpdateService + lateinit var source: OnlineSource + + @Before + fun setup() { + app = RuntimeEnvironment.application + context = app.applicationContext + + // Mock the source manager + val module = object : InjektModule { + override fun InjektRegistrar.registerInjectables() { + addSingleton(Mockito.mock(SourceManager::class.java, RETURNS_DEEP_STUBS)) + } + } + + // Restart injections for each test + Injekt = InjektScope(DefaultRegistrar()) + Injekt.importModule(AppModule(app)) + Injekt.importModule(module) + + service = Robolectric.setupService(LibraryUpdateService::class.java) + source = mock(OnlineSource::class.java) + `when`(service.sourceManager.get(anyInt())).thenReturn(source) + } + + @Test + fun testLifecycle() { + println(service.db) + + // Smoke test + Robolectric.buildService(LibraryUpdateService::class.java) + .attach() + .create() + .startCommand(0, 0) + .destroy() + .get() + } + + @Test + fun testUpdateManga() { + println(service.db) + + val manga = createManga("/manga1")[0] + manga.id = 1L + service.db.insertManga(manga).executeAsBlocking() + + val sourceChapters = createChapters("/chapter1", "/chapter2") + + `when`(source.fetchChapterList(manga)).thenReturn(Observable.just(sourceChapters)) + + service.updateManga(manga).subscribe() + + assertThat(service.db.getChapters(manga).executeAsBlocking()).hasSize(2) + } + + @Test + fun testContinuesUpdatingWhenAMangaFails() { + var favManga = createManga("/manga1", "/manga2", "/manga3") + println(service.db) + service.db.insertMangas(favManga).executeAsBlocking() + favManga = service.db.getFavoriteMangas().executeAsBlocking() + + val chapters = createChapters("/chapter1", "/chapter2") + val chapters3 = createChapters("/achapter1", "/achapter2") + + // One of the updates will fail + `when`(source.fetchChapterList(favManga[0])).thenReturn(Observable.just(chapters)) + `when`(source.fetchChapterList(favManga[1])).thenReturn(Observable.error>(Exception())) + `when`(source.fetchChapterList(favManga[2])).thenReturn(Observable.just(chapters3)) + + service.updateMangaList(service.getMangaToUpdate(null)).subscribe() + + // There are 3 network attempts and 2 insertions (1 request failed) + assertThat(service.db.getChapters(favManga[0]).executeAsBlocking()).hasSize(2) + assertThat(service.db.getChapters(favManga[1]).executeAsBlocking()).hasSize(0) + assertThat(service.db.getChapters(favManga[2]).executeAsBlocking()).hasSize(2) + } + + private fun createChapters(vararg urls: String): List { + val list = ArrayList() + for (url in urls) { + val c = Chapter.create() + c.url = url + c.name = url.substring(1) + list.add(c) + } + return list + } + + private fun createManga(vararg urls: String): List { + val list = ArrayList() + for (url in urls) { + val m = Manga.create(url) + m.title = url.substring(1) + m.favorite = true + list.add(m) + } + return list + } +} diff --git a/app/src/test/java/eu/kanade/tachiyomi/injection/module/TestDataModule.kt b/app/src/test/java/eu/kanade/tachiyomi/injection/module/TestDataModule.kt deleted file mode 100644 index 3d98dc6c07..0000000000 --- a/app/src/test/java/eu/kanade/tachiyomi/injection/module/TestDataModule.kt +++ /dev/null @@ -1,18 +0,0 @@ -package eu.kanade.tachiyomi.injection.module - -import android.app.Application -import eu.kanade.tachiyomi.data.network.NetworkHelper -import eu.kanade.tachiyomi.data.source.SourceManager -import org.mockito.Mockito - -class TestDataModule : DataModule() { - - override fun provideNetworkHelper(app: Application): NetworkHelper { - return Mockito.mock(NetworkHelper::class.java) - } - - override fun provideSourceManager(app: Application): SourceManager { - return Mockito.mock(SourceManager::class.java, Mockito.RETURNS_DEEP_STUBS) - } - -}