Experimental api message fixes, paging source & factory tests

Author: Melih Aksoy

core/src/main/kotlin/com/melih/core/base/lifecycle/BaseActivity.kt

@@ -8,7 +8,6 @@ import androidx.databinding.ViewDataBinding
 import androidx.navigation.fragment.NavHostFragment
 import androidx.navigation.ui.NavigationUI
 import dagger.android.support.DaggerAppCompatActivity
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 
 const val NAV_HOST_FRAGMENT_TAG = "nav_host_fragment_tag"
 
@@ -20,7 +19,6 @@ abstract class BaseActivity<T : ViewDataBinding> : DaggerAppCompatActivity() {
     protected lateinit var binding: T
     protected lateinit var navHostFragment: NavHostFragment
 
-    @ExperimentalCoroutinesApi
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 

core/src/main/kotlin/com/melih/core/base/paging/BasePagingDataSource.kt

@@ -1,3 +1,5 @@
+@file:UseExperimental(ExperimentalCoroutinesApi::class)
+
 package com.melih.core.base.paging
 
 import androidx.annotation.CallSuper
@@ -37,7 +39,6 @@ abstract class BasePagingDataSource<T> : PageKeyedDataSource<Int, T>() {
 
     // region Abstractions
 
-    @ExperimentalCoroutinesApi
     abstract fun loadDataForPage(page: Int): Flow<Result<List<T>>> // Load next page(s)
     // endregion
 
@@ -62,7 +63,6 @@ abstract class BasePagingDataSource<T> : PageKeyedDataSource<Int, T>() {
 
     // region Functions
 
-    @ExperimentalCoroutinesApi
     override fun loadInitial(params: LoadInitialParams<Int>, callback: LoadInitialCallback<Int, T>) {
         // Looping through channel as we'll receive any state, error or data here
         loadDataForPage(INITIAL_PAGE)
@@ -81,7 +81,6 @@ abstract class BasePagingDataSource<T> : PageKeyedDataSource<Int, T>() {
             .launchIn(coroutineScope)
     }
 
-    @ExperimentalCoroutinesApi
     override fun loadAfter(params: LoadParams<Int>, callback: LoadCallback<Int, T>) {
         // Key for which page to load is in params
         val page = params.key

core/src/main/kotlin/com/melih/core/base/viewmodel/BasePagingViewModel.kt

@@ -0,0 +1,62 @@
+package com.melih.core.base.viewmodel
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.Transformations
+import androidx.lifecycle.ViewModel
+import androidx.paging.LivePagedListBuilder
+import androidx.paging.PagedList
+import com.melih.core.base.paging.BasePagingFactory
+import com.melih.repository.interactors.base.Reason
+import com.melih.repository.interactors.base.State
+
+/**
+ * Base [ViewModel] for view models that will use [PagedList].
+ *
+ * Since data handling is done via [be.mediahuis.core.base.paging.BasePagingDataSource], this view model doesn't need
+ * a [kotlinx.coroutines.channels.ReceiveChannel] and will not provide any default operations of data, but instead will
+ * provde [pagedList] which should be observed and submitted.
+ *
+ * If paging won't be used, use [BaseViewModel] instead.
+ */
+abstract class BasePagingViewModel<T> : ViewModel() {
+
+    // region Abstractions
+
+    abstract val factory: BasePagingFactory<T>
+    abstract val config: PagedList.Config
+    private lateinit var _pagedList: LiveData<PagedList<T>>
+    // endregion
+
+    // region Properties
+
+    /**
+     * Observe [stateData] to get notified of state of data
+     */
+    val stateData: LiveData<State> by lazy {
+        Transformations.switchMap(factory.currentSource) {
+            it.stateData
+        }
+    }
+
+    /**
+     * Observe [errorData] to get notified if an error occurs
+     */
+    val errorData: LiveData<Reason> by lazy {
+        Transformations.switchMap(factory.currentSource) {
+            it.reasonData
+        }
+    }
+
+    /**
+     * Observe [pagedList] to submit list it provides
+     */
+    val pagedList: LiveData<PagedList<T>> by lazy {
+        LivePagedListBuilder(factory, config)
+            .build()
+    }
+    // endregion
+
+    fun refresh() {
+        factory.currentSource.value?.invalidate()
+    }
+}

core/src/test/kotlin/com/melih/core/BaseTestWithMainThread.kt

@@ -1,3 +1,5 @@
+@file:UseExperimental(ExperimentalCoroutinesApi::class)
+
 package com.melih.core
 
 import androidx.arch.core.executor.ArchTaskExecutor
@@ -15,11 +17,9 @@ import kotlin.coroutines.suspendCoroutine
 
 abstract class BaseTestWithMainThread {
 
-    @ExperimentalCoroutinesApi
     private val dispatcher = TestCoroutineDispatcher()
 
     @BeforeEach
-    @ExperimentalCoroutinesApi
     fun setUp() {
         Dispatchers.setMain(dispatcher)
         ArchTaskExecutor.getInstance()
@@ -33,7 +33,6 @@ abstract class BaseTestWithMainThread {
     }
 
     @AfterEach
-    @ExperimentalCoroutinesApi
     fun tearDown() {
         ArchTaskExecutor.getInstance()
             .setDelegate(null)

core/src/test/kotlin/com/melih/core/paging/BasePagingDataSourceTest.kt

@@ -0,0 +1,166 @@
+@file:UseExperimental(ExperimentalCoroutinesApi::class)
+
+package com.melih.core.paging
+
+import androidx.paging.PageKeyedDataSource
+import com.melih.core.BaseTestWithMainThread
+import com.melih.core.base.paging.BasePagingDataSource
+import com.melih.core.testObserve
+import com.melih.repository.interactors.base.Failure
+import com.melih.repository.interactors.base.GenericError
+import com.melih.repository.interactors.base.Result
+import com.melih.repository.interactors.base.State
+import com.melih.repository.interactors.base.Success
+import io.mockk.mockk
+import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import org.amshove.kluent.shouldBeInstanceOf
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Test
+
+class BasePagingDataSourceTest : BaseTestWithMainThread() {
+
+    val source = spyk(TestSource())
+    val failureSource = spyk(TestFailureSource())
+
+    val data = 10
+    val errorMessage = "Generic Error"
+
+    @Nested
+    inner class BasePagingSource {
+
+        @Nested
+        inner class LoadInitial {
+
+            @Test
+
+            fun `should update state accordingly`() {
+                val params = mockk<PageKeyedDataSource.LoadInitialParams<Int>>(relaxed = true)
+                val callback = mockk<PageKeyedDataSource.LoadInitialCallback<Int, Int>>(relaxed = true)
+
+                runBlocking {
+
+                    // Fake loading
+                    source.loadInitial(params, callback)
+
+                    source.stateData.testObserve {
+                        it shouldBeInstanceOf State.Loading::class
+                    }
+                }
+            }
+
+            @Test
+
+            fun `should update error Error accordingly`() {
+                val params = PageKeyedDataSource.LoadInitialParams<Int>(10, false)
+                val callback = mockk<PageKeyedDataSource.LoadInitialCallback<Int, Int>>(relaxed = true)
+
+                runBlocking {
+
+                    // Fake loading
+                    failureSource.loadInitial(params, callback)
+
+                    failureSource.reasonData.testObserve {
+                        it shouldBeInstanceOf GenericError::class
+                    }
+                }
+            }
+        }
+
+        @Nested
+        inner class LoadAfter {
+
+            @Test
+
+            fun `should update state accordingly`() {
+                val params = PageKeyedDataSource.LoadParams(2, 10)
+                val callback = mockk<PageKeyedDataSource.LoadCallback<Int, Int>>(relaxed = true)
+
+                runBlocking {
+
+                    // Fake loading
+                    source.loadAfter(params, callback)
+
+                    source.stateData.testObserve {
+                        it shouldBeInstanceOf State.Loading::class
+                    }
+                }
+            }
+
+            @Test
+
+            fun `should update error Error accordingly`() {
+                val params = PageKeyedDataSource.LoadParams(2, 10)
+                val callback = mockk<PageKeyedDataSource.LoadCallback<Int, Int>>(relaxed = true)
+
+                runBlocking {
+
+                    // Fake loading
+                    failureSource.loadAfter(params, callback)
+
+                    failureSource.reasonData.testObserve {
+                        it shouldBeInstanceOf GenericError::class
+                    }
+                }
+            }
+        }
+
+        @Test
+
+        fun `should use loadDataForPage in loadInitial and transform emmited value`() {
+            val params = mockk<PageKeyedDataSource.LoadInitialParams<Int>>(relaxed = true)
+            val callback = mockk<PageKeyedDataSource.LoadInitialCallback<Int, Int>>(relaxed = true)
+
+            // Fake loading
+            source.loadInitial(params, callback)
+
+            // Make sure load initial called only once
+            verify(exactly = 1) { source.loadDataForPage(any()) }
+
+            // Notified callback
+            verify(exactly = 1) { callback.onResult(any(), any(), any()) }
+        }
+
+        @Test
+
+        fun `should use loadDataForPage in loadAfter and transform emmited value`() {
+            val params = PageKeyedDataSource.LoadParams(2, 10)
+            val callback = mockk<PageKeyedDataSource.LoadCallback<Int, Int>>(relaxed = true)
+
+            // Fake loading
+            source.loadAfter(params, callback)
+
+            // Make sure load initial called only once
+            verify(exactly = 1) { source.loadDataForPage(any()) }
+
+            // Notified callback
+            verify(exactly = 1) { callback.onResult(any(), any()) }
+        }
+    }
+
+    inner class TestSource : BasePagingDataSource<Int>() {
+
+
+        val result = flow {
+            emit(State.Loading())
+            emit(Success(listOf(data)))
+        }
+
+
+        override fun loadDataForPage(page: Int): Flow<Result<List<Int>>> = result
+    }
+
+    inner class TestFailureSource : BasePagingDataSource<Int>() {
+
+        val result = flow {
+            emit(State.Loading())
+            emit(Failure(GenericError()))
+        }
+
+        override fun loadDataForPage(page: Int): Flow<Result<List<Int>>> = result
+    }
+}

core/src/test/kotlin/com/melih/core/paging/BasePagingFactoryTest.kt

@@ -0,0 +1,33 @@
+package com.melih.core.paging
+
+import com.melih.core.BaseTestWithMainThread
+import com.melih.core.base.paging.BasePagingDataSource
+import com.melih.core.base.paging.BasePagingFactory
+import com.melih.core.testObserve
+import io.mockk.mockk
+import io.mockk.spyk
+import kotlinx.coroutines.runBlocking
+import org.amshove.kluent.shouldEqual
+import org.junit.jupiter.api.Test
+
+class BasePagingFactoryTest : BaseTestWithMainThread() {
+
+    val factory = spyk(TestFactory())
+
+    @Test
+    fun `create should update current source when it creates a new one`() {
+        val source = factory.create()
+
+        runBlocking {
+            factory.currentSource.testObserve {
+                it shouldEqual source
+            }
+        }
+    }
+
+    inner class TestFactory : BasePagingFactory<String>() {
+
+        override fun createSource(): BasePagingDataSource<String> = mockk(relaxed = true)
+
+    }
+}

features/detail/jacoco.exec

@@ -6,7 +6,6 @@ import com.melih.detail.ui.DetailViewModel
 import dagger.Binds
 import dagger.Module
 import dagger.multibindings.IntoMap
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 
 @Module
 abstract class DetailBinds {
@@ -16,7 +15,6 @@ abstract class DetailBinds {
     @Binds
     @IntoMap
     @ViewModelKey(DetailViewModel::class)
-    @ExperimentalCoroutinesApi
     abstract fun detailViewModel(detailViewModel: DetailViewModel): ViewModel
     // endregion
 }

features/detail/src/main/kotlin/com/melih/detail/di/modules/DetailBinds.kt

@@ -6,15 +6,13 @@ import com.melih.core.actions.EXTRA_LAUNCH_ID
 import com.melih.core.base.lifecycle.BaseActivity
 import com.melih.detail.R
 import com.melih.detail.databinding.DetailActivityBinding
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 
 const val INVALID_LAUNCH_ID = -1L
 
 class DetailActivity : BaseActivity<DetailActivityBinding>() {
 
     // region Functions
 
-    @ExperimentalCoroutinesApi
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 

features/detail/src/main/kotlin/com/melih/detail/ui/DetailActivity.kt

@@ -8,20 +8,17 @@ import com.melih.core.extensions.createFor
 import com.melih.core.extensions.observe
 import com.melih.detail.R
 import com.melih.detail.databinding.DetailBinding
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 
 class DetailFragment : BaseDaggerFragment<DetailBinding>() {
 
     // region Properties
 
-    @ExperimentalCoroutinesApi
     private val viewModel: DetailViewModel
         get() = viewModelFactory.createFor(this)
     // endregion
 
     // region Functions
 
-    @ExperimentalCoroutinesApi
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)