1369 lines
45 KiB
Kotlin
1369 lines
45 KiB
Kotlin
package bou.amine.apps.readerforselfossv2.repository
|
|
|
|
import bou.amine.apps.readerforselfossv2.dao.ITEM
|
|
import bou.amine.apps.readerforselfossv2.dao.ReaderForSelfossDB
|
|
import bou.amine.apps.readerforselfossv2.dao.SOURCE
|
|
import bou.amine.apps.readerforselfossv2.dao.TAG
|
|
import bou.amine.apps.readerforselfossv2.model.SelfossModel
|
|
import bou.amine.apps.readerforselfossv2.rest.SelfossApi
|
|
import bou.amine.apps.readerforselfossv2.service.AppSettingsService
|
|
import bou.amine.apps.readerforselfossv2.utils.ItemType
|
|
import bou.amine.apps.readerforselfossv2.utils.toView
|
|
import io.mockk.*
|
|
import junit.framework.TestCase.*
|
|
import kotlinx.coroutines.flow.MutableStateFlow
|
|
import kotlinx.coroutines.runBlocking
|
|
import org.junit.Assert.assertNotEquals
|
|
import org.junit.Before
|
|
import org.junit.Test
|
|
|
|
class RepositoryTest {
|
|
private val db = mockk<ReaderForSelfossDB>(relaxed = true)
|
|
private val appSettingsService = mockk<AppSettingsService>()
|
|
private val api = mockk<SelfossApi>()
|
|
|
|
private val NUMBER_ARTICLES = 100
|
|
private val NUMBER_UNREAD = 50
|
|
private val NUMBER_STARRED = 20
|
|
private lateinit var repository: Repository
|
|
|
|
|
|
private fun initializeRepository(
|
|
isConnectionAvailable: MutableStateFlow<Boolean> = MutableStateFlow(
|
|
true
|
|
)
|
|
) {
|
|
repository = Repository(api, appSettingsService, isConnectionAvailable, db)
|
|
|
|
runBlocking {
|
|
repository.updateApiVersion()
|
|
}
|
|
}
|
|
|
|
@Before
|
|
fun setup() {
|
|
clearAllMocks()
|
|
every { appSettingsService.getApiVersion() } returns 4
|
|
every { appSettingsService.getBaseUrl() } returns "https://test.com/selfoss/"
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
|
|
coEvery { api.version() } returns SelfossModel.StatusAndData(
|
|
success = true,
|
|
data = SelfossModel.ApiVersion("2.19-ba1e8e3", "4.0.0")
|
|
)
|
|
coEvery { api.stats() } returns SelfossModel.StatusAndData(
|
|
success = true,
|
|
data = SelfossModel.Stats(NUMBER_ARTICLES, NUMBER_UNREAD, NUMBER_STARRED)
|
|
)
|
|
|
|
every { db.itemsQueries.items().executeAsList() } returns generateTestDBItems()
|
|
every { db.tagsQueries.deleteAllTags() } returns Unit
|
|
every { db.tagsQueries.transaction(any(), any()) } returns Unit
|
|
every { db.tagsQueries.insertTag(any()) } returns Unit
|
|
}
|
|
|
|
@Test
|
|
fun instantiate_repository() {
|
|
initializeRepository()
|
|
|
|
coVerify(exactly = 1) { api.version() }
|
|
}
|
|
|
|
@Test
|
|
fun instantiate_repository_without_api_version() {
|
|
every { appSettingsService.getApiVersion() } returns -1
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
|
|
coVerify(exactly = 0) { api.version() }
|
|
coVerify(exactly = 0) { api.stats() }
|
|
}
|
|
|
|
@Test
|
|
fun get_api_4_date_with_api_1_version_stored() {
|
|
every { appSettingsService.getApiVersion() } returns 1
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
every { appSettingsService.updateApiVersion(any()) } returns Unit
|
|
|
|
initializeRepository()
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
verify(exactly = 1) { appSettingsService.updateApiVersion(4) }
|
|
}
|
|
|
|
@Test
|
|
fun get_api_1_date_with_api_4_version_stored() {
|
|
every { appSettingsService.getApiVersion() } returns 4
|
|
coEvery { api.version() } returns SelfossModel.StatusAndData(success = false, null)
|
|
val itemParameters = FakeItemParameters()
|
|
itemParameters.datetime = "2021-04-23 11:45:32"
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(
|
|
success = true,
|
|
data = generateTestApiItem(itemParameters)
|
|
)
|
|
|
|
initializeRepository()
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(1, repository.items.size)
|
|
}
|
|
|
|
@Test
|
|
fun get_newer_items() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
coVerify(exactly = 1) { api.getItems("unread", 0, null, null, null, null, any()) }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_all_newer_items() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
repository.displayedItems = ItemType.ALL
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
coVerify(exactly = 1) { api.getItems("all", 0, null, null, null, null, any()) }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_newer_starred_items() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
repository.displayedItems = ItemType.STARRED
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
coVerify(exactly = 1) { api.getItems("starred", 0, null, null, null, null, any()) }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_newer_items_without_connectivity() {
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
coVerify(exactly = 0) { api.getItems("unread", 0, null, null, null, null, any()) }
|
|
verify(atLeast = 1) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_newer_items_without_connectivity_and_tag_filter() {
|
|
val itemParameter1 = FakeItemParameters()
|
|
val itemParameter2 = FakeItemParameters()
|
|
val itemParameter3 = FakeItemParameters()
|
|
itemParameter2.tags = "Test, Stuff"
|
|
itemParameter2.id = "2"
|
|
itemParameter3.tags = "Other, Tag"
|
|
itemParameter3.id = "3"
|
|
coEvery { db.itemsQueries.items().executeAsList() } returns generateTestDBItems(
|
|
itemParameter1
|
|
) +
|
|
generateTestDBItems(itemParameter2) +
|
|
generateTestDBItems(itemParameter3)
|
|
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
repository.tagFilter = SelfossModel.Tag("Test", "red", 3)
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
coVerify(exactly = 0) { api.getItems("unread", 0, null, null, null, null, any()) }
|
|
verify(atLeast = 1) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_newer_items_without_connectivity_and_source_filter() {
|
|
val itemParameter1 = FakeItemParameters()
|
|
val itemParameter2 = FakeItemParameters()
|
|
val itemParameter3 = FakeItemParameters()
|
|
itemParameter2.sourcetitle = "Test"
|
|
itemParameter2.id = "2"
|
|
itemParameter3.sourcetitle = "Other"
|
|
itemParameter3.id = "3"
|
|
coEvery { db.itemsQueries.items().executeAsList() } returns generateTestDBItems(
|
|
itemParameter1
|
|
) +
|
|
generateTestDBItems(itemParameter2) +
|
|
generateTestDBItems(itemParameter3)
|
|
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
repository.sourceFilter = SelfossModel.Source(
|
|
1,
|
|
"Test",
|
|
listOf("tags"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
runBlocking {
|
|
repository.getNewerItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 1)
|
|
coVerify(exactly = 0) { api.getItems("unread", 0, null, null, null, null, any()) }
|
|
verify(atLeast = 1) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_older_items() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
repository.items = ArrayList(generateTestApiItem())
|
|
runBlocking {
|
|
repository.getOlderItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 2)
|
|
coVerify(exactly = 1) { api.getItems("unread", 1, null, null, null, null, any()) }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_all_older_items() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
repository.items = ArrayList(generateTestApiItem())
|
|
repository.displayedItems = ItemType.ALL
|
|
runBlocking {
|
|
repository.getOlderItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 2)
|
|
coVerify(exactly = 1) { api.getItems("all", 1, null, null, null, null, any()) }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_older_starred_items() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
repository.displayedItems = ItemType.STARRED
|
|
repository.items = ArrayList(generateTestApiItem())
|
|
runBlocking {
|
|
repository.getOlderItems()
|
|
}
|
|
|
|
assertSame(repository.items.size, 2)
|
|
coVerify(exactly = 1) { api.getItems("starred", 1, null, null, null, null, any()) }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun reload_badges() {
|
|
var success: Boolean
|
|
|
|
initializeRepository()
|
|
runBlocking {
|
|
success = repository.reloadBadges()
|
|
}
|
|
|
|
assertSame(true, success)
|
|
assertSame(NUMBER_ARTICLES, repository.badgeAll)
|
|
assertSame(NUMBER_UNREAD, repository.badgeUnread)
|
|
assertSame(NUMBER_STARRED, repository.badgeStarred)
|
|
coVerify(atLeast = 1) { api.stats() }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun reload_badges_without_response() {
|
|
coEvery { api.stats() } returns SelfossModel.StatusAndData(success = false, data = null)
|
|
|
|
var success: Boolean
|
|
|
|
initializeRepository()
|
|
runBlocking {
|
|
success = repository.reloadBadges()
|
|
}
|
|
|
|
assertSame(false, success)
|
|
assertSame(0, repository.badgeAll)
|
|
assertSame(0, repository.badgeUnread)
|
|
assertSame(0, repository.badgeStarred)
|
|
coVerify(atLeast = 1) { api.stats() }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun reload_badges_without_connection() {
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
every { db.itemsQueries.items().executeAsList() } returns generateTestDBItems()
|
|
|
|
var success: Boolean
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
runBlocking {
|
|
success = repository.reloadBadges()
|
|
}
|
|
|
|
assertTrue(success)
|
|
assertSame(1, repository.badgeAll)
|
|
assertSame(1, repository.badgeUnread)
|
|
assertSame(1, repository.badgeStarred)
|
|
coVerify(exactly = 0) { api.stats() }
|
|
verify(atLeast = 1) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun reload_badges_without_connection_and_items_caching_disabled() {
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
|
|
var success: Boolean
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
runBlocking {
|
|
success = repository.reloadBadges()
|
|
}
|
|
|
|
assertFalse(success)
|
|
assertSame(0, repository.badgeAll)
|
|
assertSame(0, repository.badgeUnread)
|
|
assertSame(0, repository.badgeStarred)
|
|
coVerify(exactly = 0) { api.stats() }
|
|
verify(exactly = 0) { db.itemsQueries.items().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository()
|
|
var testTags: List<SelfossModel.Tag>?
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
assertSame(tags, testTags)
|
|
assertNotSame(tagsDB.map { it.toView() }, testTags)
|
|
coVerify(exactly = 1) { api.tags() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_with_sources_update_disabled() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository()
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
// Tags will be fetched from the database on the second call, thus testTags != tags
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.tags() }
|
|
assertNotSame(tags, testTags)
|
|
assertEquals(tagsDB.map { it.toView() }, testTags)
|
|
verify(atLeast = 1) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_with_items_caching_disabled() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
|
|
initializeRepository()
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
assertSame(tags, testTags)
|
|
coVerify(exactly = 1) { api.tags() }
|
|
verify(exactly = 0) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_with_sources_update_and_items_caching_disabled() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
|
|
initializeRepository()
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.tags() }
|
|
assertNotSame(tags, testTags)
|
|
assertEquals(tagsDB.map { it.toView() }, testTags)
|
|
verify(atLeast = 1) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_without_connection() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
assertNotSame(tags, testTags)
|
|
assertEquals(tagsDB.map { it.toView() }, testTags)
|
|
coVerify(exactly = 0) { api.tags() }
|
|
verify(atLeast = 1) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_without_connection_and_items_caching_disabled() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
assertSame(emptyList<SelfossModel.Tag>(), testTags)
|
|
coVerify(exactly = 0) { api.tags() }
|
|
verify(exactly = 0) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_without_connection_and_sources_update_disabled() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
assertNotSame(tags, testTags)
|
|
assertEquals(tagsDB.map { it.toView() }, testTags)
|
|
coVerify(exactly = 0) { api.tags() }
|
|
verify(atLeast = 1) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_tags_without_connection_and_sources_update_and_items_caching_disabled() {
|
|
val tags = listOf(
|
|
SelfossModel.Tag("test", "red", 6),
|
|
SelfossModel.Tag("second", "yellow", 0)
|
|
)
|
|
val tagsDB = listOf(
|
|
TAG("test_DB", "red", 6),
|
|
TAG("second_DB", "yellow", 0)
|
|
)
|
|
|
|
coEvery { api.tags() } returns SelfossModel.StatusAndData(success = true, data = tags)
|
|
coEvery { db.tagsQueries.tags().executeAsList() } returns tagsDB
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testTags: List<SelfossModel.Tag>
|
|
runBlocking {
|
|
testTags = repository.getTags()
|
|
}
|
|
|
|
assertEquals(tagsDB.map { it.toView() }, testTags)
|
|
coVerify(exactly = 0) { api.tags() }
|
|
verify(atLeast = 1) { db.tagsQueries.tags().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First DB source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository()
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertSame(sources, testSources)
|
|
assertNotEquals(sourcesDB.map { it.toView() }, testSources)
|
|
coVerify(exactly = 1) { api.sources() }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_with_sources_update_disabled() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second DB source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository()
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
// Sources will be fetched from the database on the second call, thus testSources != sources
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.sources() }
|
|
assertNotSame(sources, testSources)
|
|
assertEquals(sourcesDB.map { it.toView() }, testSources)
|
|
verify(atLeast = 1) { db.sourcesQueries.sources().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_with_items_caching_disabled() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository()
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertSame(sources, testSources)
|
|
coVerify(exactly = 1) { api.sources() }
|
|
verify(exactly = 0) { db.sourcesQueries }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_with_sources_update_and_items_caching_disabled() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository()
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertSame(sources, testSources)
|
|
coVerify(exactly = 1) { api.sources() }
|
|
verify(atLeast = 1) { db.sourcesQueries }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_without_connection() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First DB source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertEquals(sourcesDB.map { it.toView() }, testSources)
|
|
coVerify(exactly = 0) { api.sources() }
|
|
verify(atLeast = 1) { db.sourcesQueries.sources().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_without_connection_and_items_caching_disabled() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First DB source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns true
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertEquals(emptyList<SelfossModel.Source>(), testSources)
|
|
coVerify(exactly = 0) { api.sources() }
|
|
verify(exactly = 0) { db.sourcesQueries.sources().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_without_connection_and_sources_update_disabled() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First DB source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
every { appSettingsService.isItemCachingEnabled() } returns true
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertEquals(sourcesDB.map { it.toView() }, testSources)
|
|
coVerify(exactly = 0) { api.sources() }
|
|
verify(atLeast = 1) { db.sourcesQueries.sources().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun get_sources_without_connection_and_items_caching_and_sources_update_disabled() {
|
|
val sources = arrayListOf(
|
|
SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SelfossModel.Source(
|
|
2,
|
|
"Second source",
|
|
listOf("second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
val sourcesDB = listOf(
|
|
SOURCE(
|
|
"1",
|
|
"First DB source",
|
|
"Test,second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
),
|
|
SOURCE(
|
|
"2",
|
|
"Second source",
|
|
"second",
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"b3aa8a664d08eb15d6ff1db2fa83e0d9.png"
|
|
)
|
|
)
|
|
|
|
every { appSettingsService.isItemCachingEnabled() } returns false
|
|
every { appSettingsService.isUpdateSourcesEnabled() } returns false
|
|
coEvery { api.sources() } returns SelfossModel.StatusAndData(success = true, data = sources)
|
|
every { db.sourcesQueries.sources().executeAsList() } returns sourcesDB
|
|
initializeRepository(MutableStateFlow(false))
|
|
var testSources: List<SelfossModel.Source>?
|
|
runBlocking {
|
|
testSources = repository.getSources()
|
|
}
|
|
|
|
assertEquals(sourcesDB.map { it.toView() }, testSources)
|
|
coVerify(exactly = 0) { api.sources() }
|
|
verify(atLeast = 1) { db.sourcesQueries.sources().executeAsList() }
|
|
}
|
|
|
|
@Test
|
|
fun create_source() {
|
|
coEvery { api.createSourceForVersion(any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.SuccessResponse(true)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.createSource(
|
|
"test",
|
|
"https://test.com/feed",
|
|
"spouts\\rss\\fulltextrss",
|
|
"Test, New",
|
|
""
|
|
)
|
|
}
|
|
|
|
coVerify(exactly = 1) {
|
|
api.createSourceForVersion(
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any()
|
|
)
|
|
}
|
|
assertSame(true, response)
|
|
}
|
|
|
|
@Test
|
|
fun create_source_but_response_fails() {
|
|
coEvery { api.createSourceForVersion(any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.SuccessResponse(false)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.createSource(
|
|
"test",
|
|
"https://test.com/feed",
|
|
"spouts\\rss\\fulltextrss",
|
|
"Test, New",
|
|
""
|
|
)
|
|
}
|
|
|
|
coVerify(exactly = 1) {
|
|
api.createSourceForVersion(
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any()
|
|
)
|
|
}
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun create_source_without_connection() {
|
|
coEvery { api.createSourceForVersion(any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.SuccessResponse(true)
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.createSource(
|
|
"test",
|
|
"https://test.com/feed",
|
|
"spouts\\rss\\fulltextrss",
|
|
"Test, New",
|
|
""
|
|
)
|
|
}
|
|
|
|
coVerify(exactly = 0) {
|
|
api.createSourceForVersion(
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any()
|
|
)
|
|
}
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun delete_source() {
|
|
coEvery { api.deleteSource(any()) } returns SelfossModel.SuccessResponse(true)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.deleteSource(5)
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.deleteSource(5) }
|
|
assertSame(true, response)
|
|
}
|
|
|
|
@Test
|
|
fun delete_source_but_response_fails() {
|
|
coEvery { api.deleteSource(any()) } returns SelfossModel.SuccessResponse(false)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.deleteSource(5)
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.deleteSource(5) }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun delete_source_without_connection() {
|
|
coEvery { api.deleteSource(any()) } returns SelfossModel.SuccessResponse(false)
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.deleteSource(5)
|
|
}
|
|
|
|
coVerify(exactly = 0) { api.deleteSource(5) }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun update_remote() {
|
|
coEvery { api.update() } returns SelfossModel.StatusAndData(
|
|
success = true,
|
|
data = "finished"
|
|
)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.updateRemote()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.update() }
|
|
assertTrue(response)
|
|
}
|
|
|
|
@Test
|
|
fun update_remote_but_response_fails() {
|
|
coEvery { api.update() } returns SelfossModel.StatusAndData(
|
|
success = false,
|
|
data = "unallowed access"
|
|
)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.updateRemote()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.update() }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun update_remote_with_unallowed_access() {
|
|
coEvery { api.update() } returns SelfossModel.StatusAndData(
|
|
success = true,
|
|
data = "unallowed access"
|
|
)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.updateRemote()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.update() }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun update_remote_without_connection() {
|
|
coEvery { api.update() } returns SelfossModel.StatusAndData(
|
|
success = true,
|
|
data = "undocumented..."
|
|
)
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.updateRemote()
|
|
}
|
|
|
|
coVerify(exactly = 0) { api.update() }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun login() {
|
|
coEvery { api.login() } returns SelfossModel.SuccessResponse(success = true)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.login()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.login() }
|
|
assertSame(true, response)
|
|
}
|
|
|
|
@Test
|
|
fun login_but_response_fails() {
|
|
coEvery { api.login() } returns SelfossModel.SuccessResponse(success = false)
|
|
|
|
initializeRepository()
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.login()
|
|
}
|
|
|
|
coVerify(exactly = 1) { api.login() }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun login_but_without_connection() {
|
|
coEvery { api.login() } returns SelfossModel.SuccessResponse(success = true)
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
var response: Boolean
|
|
runBlocking {
|
|
response = repository.login()
|
|
}
|
|
|
|
coVerify(exactly = 0) { api.login() }
|
|
assertSame(false, response)
|
|
}
|
|
|
|
@Test
|
|
fun refresh_login_information() {
|
|
coEvery { api.refreshLoginInformation() } returns Unit
|
|
coEvery { appSettingsService.refreshLoginInformation(any(), any(), any()) } returns Unit
|
|
|
|
initializeRepository()
|
|
repository.refreshLoginInformation("https://test.com/selfoss/", "login", "password")
|
|
|
|
coVerify(exactly = 1) { api.refreshLoginInformation() }
|
|
coVerify(exactly = 1) {
|
|
appSettingsService.refreshLoginInformation(
|
|
"https://test.com/selfoss/",
|
|
"login",
|
|
"password"
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun cache_items() {
|
|
val itemParameter1 = FakeItemParameters()
|
|
val itemParameter2 = FakeItemParameters()
|
|
val itemParameter3 = FakeItemParameters()
|
|
itemParameter2.id = "2"
|
|
itemParameter3.id = "3"
|
|
coEvery {
|
|
api.getItems(
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any(),
|
|
any()
|
|
)
|
|
} returnsMany listOf(
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem(itemParameter1)),
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem(itemParameter2)),
|
|
SelfossModel.StatusAndData(success = true, data = generateTestApiItem(itemParameter1)),
|
|
)
|
|
|
|
initializeRepository()
|
|
repository.tagFilter = SelfossModel.Tag("Tag", "read", 0)
|
|
repository.sourceFilter = SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
)
|
|
repository.searchFilter = "search"
|
|
runBlocking {
|
|
repository.tryToCacheItemsAndGetNewOnes()
|
|
}
|
|
|
|
coVerify(exactly = 3) { api.getItems(any(), 0, null, null, null, null, 200) }
|
|
}
|
|
|
|
@Test
|
|
fun cache_items_but_response_fails() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = false, data = generateTestApiItem())
|
|
|
|
initializeRepository()
|
|
repository.tagFilter = SelfossModel.Tag("Tag", "read", 0)
|
|
repository.sourceFilter = SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
)
|
|
repository.searchFilter = "search"
|
|
runBlocking {
|
|
repository.tryToCacheItemsAndGetNewOnes()
|
|
}
|
|
|
|
coVerify(exactly = 3) { api.getItems(any(), 0, null, null, null, null, 200) }
|
|
}
|
|
|
|
@Test
|
|
fun cache_items_without_connection() {
|
|
coEvery { api.getItems(any(), any(), any(), any(), any(), any(), any()) } returns
|
|
SelfossModel.StatusAndData(success = false, data = generateTestApiItem())
|
|
|
|
initializeRepository(MutableStateFlow(false))
|
|
repository.tagFilter = SelfossModel.Tag("Tag", "read", 0)
|
|
repository.sourceFilter = SelfossModel.Source(
|
|
1,
|
|
"First source",
|
|
listOf("Test", "second"),
|
|
"spouts\\rss\\fulltextrss",
|
|
"",
|
|
"d8c92cdb1ef119ea85c4b9205c879ca7.png"
|
|
)
|
|
repository.searchFilter = "search"
|
|
runBlocking {
|
|
repository.tryToCacheItemsAndGetNewOnes()
|
|
}
|
|
|
|
coVerify(exactly = 0) { api.getItems(any(), 0, null, null, null, null, 200) }
|
|
}
|
|
} |