mirror of
https://github.com/TeamNewPipe/NewPipe
synced 2025-11-15 14:47:11 +00:00
Migrate & adapt database tests to Kotlin as well
Signed-off-by: Aayush Gupta <aayushgupta219@gmail.com>
This commit is contained in:
Aayush Gupta
@@ -129,7 +129,7 @@ class DatabaseMigrationTest {
|
||||
)
|
||||
|
||||
val migratedDatabaseV3 = getMigratedDatabase()
|
||||
val listFromDB = migratedDatabaseV3.streamDAO().all.blockingFirst()
|
||||
val listFromDB = migratedDatabaseV3.streamDAO().getAll().blockingFirst()
|
||||
|
||||
// Only expect 2, the one with the null url will be ignored
|
||||
assertEquals(2, listFromDB.size)
|
||||
@@ -217,7 +217,7 @@ class DatabaseMigrationTest {
|
||||
)
|
||||
|
||||
val migratedDatabaseV8 = getMigratedDatabase()
|
||||
val listFromDB = migratedDatabaseV8.searchHistoryDAO().all.blockingFirst()
|
||||
val listFromDB = migratedDatabaseV8.searchHistoryDAO().getAll().blockingFirst()
|
||||
|
||||
assertEquals(2, listFromDB.size)
|
||||
assertEquals("abc", listFromDB[0].search)
|
||||
@@ -283,8 +283,8 @@ class DatabaseMigrationTest {
|
||||
)
|
||||
|
||||
val migratedDatabaseV9 = getMigratedDatabase()
|
||||
var localListFromDB = migratedDatabaseV9.playlistDAO().all.blockingFirst()
|
||||
var remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().all.blockingFirst()
|
||||
var localListFromDB = migratedDatabaseV9.playlistDAO().getAll().blockingFirst()
|
||||
var remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().getAll().blockingFirst()
|
||||
|
||||
assertEquals(1, localListFromDB.size)
|
||||
assertEquals(localUid2, localListFromDB[0].uid)
|
||||
@@ -294,17 +294,27 @@ class DatabaseMigrationTest {
|
||||
assertEquals(-1, remoteListFromDB[0].displayIndex)
|
||||
|
||||
val localUid3 = migratedDatabaseV9.playlistDAO().insert(
|
||||
PlaylistEntity(DEFAULT_NAME + "3", false, -1, -1)
|
||||
PlaylistEntity(
|
||||
name = "${DEFAULT_NAME}3",
|
||||
isThumbnailPermanent = false,
|
||||
thumbnailStreamId = -1,
|
||||
displayIndex = -1
|
||||
)
|
||||
)
|
||||
val remoteUid3 = migratedDatabaseV9.playlistRemoteDAO().insert(
|
||||
PlaylistRemoteEntity(
|
||||
DEFAULT_THIRD_SERVICE_ID, DEFAULT_NAME, DEFAULT_THIRD_URL,
|
||||
DEFAULT_THUMBNAIL, DEFAULT_UPLOADER_NAME, -1, 10
|
||||
serviceId = DEFAULT_THIRD_SERVICE_ID,
|
||||
orderingName = DEFAULT_NAME,
|
||||
url = DEFAULT_THIRD_URL,
|
||||
thumbnailUrl = DEFAULT_THUMBNAIL,
|
||||
uploader = DEFAULT_UPLOADER_NAME,
|
||||
displayIndex = -1,
|
||||
streamCount = 10
|
||||
)
|
||||
)
|
||||
|
||||
localListFromDB = migratedDatabaseV9.playlistDAO().all.blockingFirst()
|
||||
remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().all.blockingFirst()
|
||||
localListFromDB = migratedDatabaseV9.playlistDAO().getAll().blockingFirst()
|
||||
remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().getAll().blockingFirst()
|
||||
assertEquals(2, localListFromDB.size)
|
||||
assertEquals(localUid3, localListFromDB[1].uid)
|
||||
assertEquals(-1, localListFromDB[1].displayIndex)
|
||||
|
||||
@@ -41,7 +41,7 @@ class HistoryRecordManagerTest {
|
||||
// For some reason the Flowable returned by getAll() never completes, so we can't assert
|
||||
// that the number of Lists it returns is exactly 1, we can only check if the first List is
|
||||
// correct. Why on earth has a Flowable been used instead of a Single for getAll()?!?
|
||||
val entities = database.searchHistoryDAO().all.blockingFirst()
|
||||
val entities = database.searchHistoryDAO().getAll().blockingFirst()
|
||||
assertThat(entities).hasSize(1)
|
||||
assertThat(entities[0].id).isEqualTo(1)
|
||||
assertThat(entities[0].serviceId).isEqualTo(0)
|
||||
@@ -51,50 +51,50 @@ class HistoryRecordManagerTest {
|
||||
@Test
|
||||
fun deleteSearchHistory() {
|
||||
val entries = listOf(
|
||||
SearchHistoryEntry(time.minusSeconds(1), 0, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(2), 2, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(3), 1, "B"),
|
||||
SearchHistoryEntry(time.minusSeconds(4), 0, "B"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 0, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 2, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 1, search = "B"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 0, search = "B"),
|
||||
)
|
||||
|
||||
// make sure all 4 were inserted
|
||||
database.searchHistoryDAO().insertAll(entries)
|
||||
assertThat(database.searchHistoryDAO().all.blockingFirst()).hasSameSizeAs(entries)
|
||||
assertThat(database.searchHistoryDAO().getAll().blockingFirst()).hasSameSizeAs(entries)
|
||||
|
||||
// try to delete only "A" entries, "B" entries should be untouched
|
||||
manager.deleteSearchHistory("A").test().await().assertValue(2)
|
||||
val entities = database.searchHistoryDAO().all.blockingFirst()
|
||||
val entities = database.searchHistoryDAO().getAll().blockingFirst()
|
||||
assertThat(entities).hasSize(2)
|
||||
assertThat(entities).usingElementComparator { o1, o2 -> if (o1.hasEqualValues(o2)) 0 else 1 }
|
||||
.containsExactly(*entries.subList(2, 4).toTypedArray())
|
||||
|
||||
// assert that nothing happens if we delete a search query that does exist in the db
|
||||
manager.deleteSearchHistory("A").test().await().assertValue(0)
|
||||
val entities2 = database.searchHistoryDAO().all.blockingFirst()
|
||||
val entities2 = database.searchHistoryDAO().getAll().blockingFirst()
|
||||
assertThat(entities2).hasSize(2)
|
||||
assertThat(entities2).usingElementComparator { o1, o2 -> if (o1.hasEqualValues(o2)) 0 else 1 }
|
||||
.containsExactly(*entries.subList(2, 4).toTypedArray())
|
||||
|
||||
// delete all remaining entries
|
||||
manager.deleteSearchHistory("B").test().await().assertValue(2)
|
||||
assertThat(database.searchHistoryDAO().all.blockingFirst()).isEmpty()
|
||||
assertThat(database.searchHistoryDAO().getAll().blockingFirst()).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun deleteCompleteSearchHistory() {
|
||||
val entries = listOf(
|
||||
SearchHistoryEntry(time.minusSeconds(1), 1, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(2), 2, "B"),
|
||||
SearchHistoryEntry(time.minusSeconds(3), 0, "C"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 1, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 2, search = "B"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 0, search = "C"),
|
||||
)
|
||||
|
||||
// make sure all 3 were inserted
|
||||
database.searchHistoryDAO().insertAll(entries)
|
||||
assertThat(database.searchHistoryDAO().all.blockingFirst()).hasSameSizeAs(entries)
|
||||
assertThat(database.searchHistoryDAO().getAll().blockingFirst()).hasSameSizeAs(entries)
|
||||
|
||||
// should remove everything
|
||||
manager.deleteCompleteSearchHistory().test().await().assertValue(entries.size)
|
||||
assertThat(database.searchHistoryDAO().all.blockingFirst()).isEmpty()
|
||||
assertThat(database.searchHistoryDAO().getAll().blockingFirst()).isEmpty()
|
||||
}
|
||||
|
||||
private fun insertShuffledRelatedSearches(relatedSearches: Collection<SearchHistoryEntry>) {
|
||||
@@ -107,7 +107,7 @@ class HistoryRecordManagerTest {
|
||||
// make sure all entries were inserted
|
||||
assertEquals(
|
||||
relatedSearches.size,
|
||||
database.searchHistoryDAO().all.blockingFirst().size
|
||||
database.searchHistoryDAO().getAll().blockingFirst().size
|
||||
)
|
||||
}
|
||||
|
||||
@@ -127,19 +127,18 @@ class HistoryRecordManagerTest {
|
||||
|
||||
@Test
|
||||
fun getRelatedSearches_emptyQuery_manyDuplicates() {
|
||||
insertShuffledRelatedSearches(
|
||||
listOf(
|
||||
SearchHistoryEntry(time.minusSeconds(9), 3, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(8), 3, "AB"),
|
||||
SearchHistoryEntry(time.minusSeconds(7), 3, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(6), 3, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(5), 3, "BA"),
|
||||
SearchHistoryEntry(time.minusSeconds(4), 3, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(3), 3, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(2), 0, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(1), 2, "AA"),
|
||||
)
|
||||
val relatedSearches = listOf(
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(9), serviceId = 3, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(8), serviceId = 3, search = "AB"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(7), serviceId = 3, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(6), serviceId = 3, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(5), serviceId = 3, search = "BA"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 3, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 3, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 0, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 2, search = "AA"),
|
||||
)
|
||||
insertShuffledRelatedSearches(relatedSearches)
|
||||
|
||||
val searches = manager.getRelatedSearches("", 9, 3).blockingFirst()
|
||||
assertThat(searches).containsExactly("AA", "A", "BA")
|
||||
@@ -166,13 +165,13 @@ class HistoryRecordManagerTest {
|
||||
private val time = OffsetDateTime.of(LocalDateTime.of(2000, 1, 1, 1, 1), ZoneOffset.UTC)
|
||||
|
||||
private val RELATED_SEARCHES_ENTRIES = listOf(
|
||||
SearchHistoryEntry(time.minusSeconds(7), 2, "AC"),
|
||||
SearchHistoryEntry(time.minusSeconds(6), 0, "ABC"),
|
||||
SearchHistoryEntry(time.minusSeconds(5), 1, "BA"),
|
||||
SearchHistoryEntry(time.minusSeconds(4), 3, "A"),
|
||||
SearchHistoryEntry(time.minusSeconds(2), 0, "B"),
|
||||
SearchHistoryEntry(time.minusSeconds(3), 2, "AA"),
|
||||
SearchHistoryEntry(time.minusSeconds(1), 1, "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(7), serviceId = 2, search = "AC"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(6), serviceId = 0, search = "ABC"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(5), serviceId = 1, search = "BA"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 3, search = "A"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 0, search = "B"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 2, search = "AA"),
|
||||
SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 1, search = "A"),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -72,6 +72,6 @@ class LocalPlaylistManagerTest {
|
||||
val result = manager.createPlaylist("name", listOf(stream, upserted))
|
||||
|
||||
result.test().await().assertComplete()
|
||||
database.streamDAO().all.test().awaitCount(1).assertValue(listOf(stream, upserted))
|
||||
database.streamDAO().getAll().test().awaitCount(1).assertValue(listOf(stream, upserted))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,106 +0,0 @@
|
||||
package org.schabi.newpipe.database.playlist;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity;
|
||||
import org.schabi.newpipe.local.bookmark.MergedPlaylistManager;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class PlaylistLocalItemTest {
|
||||
@Test
|
||||
public void emptyPlaylists() {
|
||||
final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
|
||||
final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
|
||||
final List<PlaylistLocalItem> mergedPlaylists =
|
||||
MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
|
||||
|
||||
assertEquals(0, mergedPlaylists.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void onlyLocalPlaylists() {
|
||||
final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
|
||||
final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
|
||||
localPlaylists.add(new PlaylistMetadataEntry(1, "name1", "", false, -1, 0, 1));
|
||||
localPlaylists.add(new PlaylistMetadataEntry(2, "name2", "", false, -1, 1, 1));
|
||||
localPlaylists.add(new PlaylistMetadataEntry(3, "name3", "", false, -1, 3, 1));
|
||||
final List<PlaylistLocalItem> mergedPlaylists =
|
||||
MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
|
||||
|
||||
assertEquals(3, mergedPlaylists.size());
|
||||
assertEquals(0, mergedPlaylists.get(0).getDisplayIndex());
|
||||
assertEquals(1, mergedPlaylists.get(1).getDisplayIndex());
|
||||
assertEquals(3, mergedPlaylists.get(2).getDisplayIndex());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void onlyRemotePlaylists() {
|
||||
final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
|
||||
final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
1, "name1", "url1", "", "", 1, 1L));
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
2, "name2", "url2", "", "", 2, 1L));
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
3, "name3", "url3", "", "", 4, 1L));
|
||||
final List<PlaylistLocalItem> mergedPlaylists =
|
||||
MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
|
||||
|
||||
assertEquals(3, mergedPlaylists.size());
|
||||
assertEquals(1, mergedPlaylists.get(0).getDisplayIndex());
|
||||
assertEquals(2, mergedPlaylists.get(1).getDisplayIndex());
|
||||
assertEquals(4, mergedPlaylists.get(2).getDisplayIndex());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameIndexWithDifferentName() {
|
||||
final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
|
||||
final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
|
||||
localPlaylists.add(new PlaylistMetadataEntry(1, "name1", "", false, -1, 0, 1));
|
||||
localPlaylists.add(new PlaylistMetadataEntry(2, "name2", "", false, -1, 1, 1));
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
1, "name3", "url1", "", "", 0, 1L));
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
2, "name4", "url2", "", "", 1, 1L));
|
||||
final List<PlaylistLocalItem> mergedPlaylists =
|
||||
MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
|
||||
|
||||
assertEquals(4, mergedPlaylists.size());
|
||||
assertTrue(mergedPlaylists.get(0) instanceof PlaylistMetadataEntry);
|
||||
assertEquals("name1", ((PlaylistMetadataEntry) mergedPlaylists.get(0)).name);
|
||||
assertTrue(mergedPlaylists.get(1) instanceof PlaylistRemoteEntity);
|
||||
assertEquals("name3", ((PlaylistRemoteEntity) mergedPlaylists.get(1)).getName());
|
||||
assertTrue(mergedPlaylists.get(2) instanceof PlaylistMetadataEntry);
|
||||
assertEquals("name2", ((PlaylistMetadataEntry) mergedPlaylists.get(2)).name);
|
||||
assertTrue(mergedPlaylists.get(3) instanceof PlaylistRemoteEntity);
|
||||
assertEquals("name4", ((PlaylistRemoteEntity) mergedPlaylists.get(3)).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameNameWithDifferentIndex() {
|
||||
final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
|
||||
final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
|
||||
localPlaylists.add(new PlaylistMetadataEntry(1, "name1", "", false, -1, 1, 1));
|
||||
localPlaylists.add(new PlaylistMetadataEntry(2, "name2", "", false, -1, 3, 1));
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
1, "name1", "url1", "", "", 0, 1L));
|
||||
remotePlaylists.add(new PlaylistRemoteEntity(
|
||||
2, "name2", "url2", "", "", 2, 1L));
|
||||
final List<PlaylistLocalItem> mergedPlaylists =
|
||||
MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
|
||||
|
||||
assertEquals(4, mergedPlaylists.size());
|
||||
assertTrue(mergedPlaylists.get(0) instanceof PlaylistRemoteEntity);
|
||||
assertEquals("name1", ((PlaylistRemoteEntity) mergedPlaylists.get(0)).getName());
|
||||
assertTrue(mergedPlaylists.get(1) instanceof PlaylistMetadataEntry);
|
||||
assertEquals("name1", ((PlaylistMetadataEntry) mergedPlaylists.get(1)).name);
|
||||
assertTrue(mergedPlaylists.get(2) instanceof PlaylistRemoteEntity);
|
||||
assertEquals("name2", ((PlaylistRemoteEntity) mergedPlaylists.get(2)).getName());
|
||||
assertTrue(mergedPlaylists.get(3) instanceof PlaylistMetadataEntry);
|
||||
assertEquals("name2", ((PlaylistMetadataEntry) mergedPlaylists.get(3)).name);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2022-2024 NewPipe contributors <https://newpipe.net>
|
||||
* SPDX-FileCopyrightText: 2025 NewPipe e.V. <https://newpipe-ev.de>
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
package org.schabi.newpipe.database.playlist
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity
|
||||
import org.schabi.newpipe.local.bookmark.MergedPlaylistManager
|
||||
|
||||
class PlaylistLocalItemTest {
|
||||
|
||||
@Test
|
||||
fun emptyPlaylists() {
|
||||
val localPlaylists = listOf<PlaylistMetadataEntry?>()
|
||||
val remotePlaylists = listOf<PlaylistRemoteEntity?>()
|
||||
val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
|
||||
assertEquals(0, mergedPlaylists.size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun onlyLocalPlaylists() {
|
||||
val localPlaylists = listOf<PlaylistMetadataEntry?>(
|
||||
PlaylistMetadataEntry(1, "name1", "", 0, false, -1, 1),
|
||||
PlaylistMetadataEntry(2, "name2", "", 1, false, -1, 1),
|
||||
PlaylistMetadataEntry(3, "name3", "", 3, false, -1, 1)
|
||||
)
|
||||
val remotePlaylists = listOf<PlaylistRemoteEntity?>()
|
||||
val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
|
||||
|
||||
assertEquals(3, mergedPlaylists.size)
|
||||
assertEquals(0L, mergedPlaylists[0]!!.displayIndex)
|
||||
assertEquals(1L, mergedPlaylists[1]!!.displayIndex)
|
||||
assertEquals(3L, mergedPlaylists[2]!!.displayIndex)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun onlyRemotePlaylists() {
|
||||
val localPlaylists = listOf<PlaylistMetadataEntry?>()
|
||||
val remotePlaylists = listOf<PlaylistRemoteEntity?>(
|
||||
PlaylistRemoteEntity(1, 1, "name1", "url1", "", "", 1, 1),
|
||||
PlaylistRemoteEntity(2, 2, "name2", "url2", "", "", 2, 1),
|
||||
PlaylistRemoteEntity(3, 3, "name3", "url3", "", "", 4, 1)
|
||||
)
|
||||
val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
|
||||
|
||||
assertEquals(3, mergedPlaylists.size)
|
||||
assertEquals(1L, mergedPlaylists[0]!!.displayIndex)
|
||||
assertEquals(2L, mergedPlaylists[1]!!.displayIndex)
|
||||
assertEquals(4L, mergedPlaylists[2]!!.displayIndex)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sameIndexWithDifferentName() {
|
||||
val localPlaylists = listOf<PlaylistMetadataEntry?>(
|
||||
PlaylistMetadataEntry(1, "name1", "", 0, false, -1, 1),
|
||||
PlaylistMetadataEntry(2, "name2", "", 1, false, -1, 1)
|
||||
)
|
||||
val remotePlaylists = listOf<PlaylistRemoteEntity?>(
|
||||
PlaylistRemoteEntity(1, 1, "name3", "url1", "", "", 0, 1),
|
||||
PlaylistRemoteEntity(2, 2, "name4", "url2", "", "", 1, 1)
|
||||
)
|
||||
val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
|
||||
|
||||
assertEquals(4, mergedPlaylists.size)
|
||||
assertTrue(mergedPlaylists[0] is PlaylistMetadataEntry)
|
||||
assertEquals("name1", (mergedPlaylists[0] as PlaylistMetadataEntry).orderingName)
|
||||
assertTrue(mergedPlaylists[1] is PlaylistRemoteEntity)
|
||||
assertEquals("name3", (mergedPlaylists[1] as PlaylistRemoteEntity).orderingName)
|
||||
assertTrue(mergedPlaylists[2] is PlaylistMetadataEntry)
|
||||
assertEquals("name2", (mergedPlaylists[2] as PlaylistMetadataEntry).orderingName)
|
||||
assertTrue(mergedPlaylists[3] is PlaylistRemoteEntity)
|
||||
assertEquals("name4", (mergedPlaylists[3] as PlaylistRemoteEntity).orderingName)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sameNameWithDifferentIndex() {
|
||||
val localPlaylists = listOf<PlaylistMetadataEntry?>(
|
||||
PlaylistMetadataEntry(1, "name1", "", 1, false, -1, 1),
|
||||
PlaylistMetadataEntry(2, "name2", "", 3, false, -1, 1)
|
||||
)
|
||||
val remotePlaylists = listOf<PlaylistRemoteEntity?>(
|
||||
PlaylistRemoteEntity(1, 1, "name1", "url1", "", "", 0, 1),
|
||||
PlaylistRemoteEntity(2, 2, "name2", "url2", "", "", 2, 1)
|
||||
)
|
||||
val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
|
||||
|
||||
assertEquals(4, mergedPlaylists.size)
|
||||
assertTrue(mergedPlaylists[0] is PlaylistRemoteEntity)
|
||||
assertEquals("name1", (mergedPlaylists[0] as PlaylistRemoteEntity).orderingName)
|
||||
assertTrue(mergedPlaylists[1] is PlaylistMetadataEntry)
|
||||
assertEquals("name1", (mergedPlaylists[1] as PlaylistMetadataEntry).orderingName)
|
||||
assertTrue(mergedPlaylists[2] is PlaylistRemoteEntity)
|
||||
assertEquals("name2", (mergedPlaylists[2] as PlaylistRemoteEntity).orderingName)
|
||||
assertTrue(mergedPlaylists[3] is PlaylistMetadataEntry)
|
||||
assertEquals("name2", (mergedPlaylists[3] as PlaylistMetadataEntry).orderingName)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user