Add product list repository

build.gradle

@@ -12,6 +12,7 @@ buildscript {
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7.3'
         classpath 'com.google.gms:google-services:3.2.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.28.3-alpha'
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
     }

core/src/main/java/in/testpress/database/ProductDao.kt

@@ -20,7 +20,7 @@ interface ProductDao: BaseDao<ProductCourseEntity> {
 
     @Transaction
     @Query("SELECT * FROM productentity")
-    fun getAll(): LiveData<List<ProductWithCoursesAndPrices>>
+    fun getAll(): List<ProductWithCoursesAndPrices>
 
     @Delete
     fun deleteProduct(product: ProductEntity)

store/build.gradle

@@ -2,6 +2,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-android-extensions'
 apply plugin: 'kotlin-kapt'
+apply plugin: 'dagger.hilt.android.plugin'
 
 android {
     compileSdkVersion rootProject.compileSdkVersion
@@ -22,6 +23,10 @@ android {
     lintOptions {
         abortOnError false
     }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
 }
 
 dependencies {
@@ -37,6 +42,10 @@ dependencies {
     testImplementation rootProject.androidxCore
     testImplementation rootProject.mockServer
     testImplementation "androidx.arch.core:core-testing:2.1.0"
+
+    //DAGGER_HILT
+    implementation "com.google.dagger:hilt-android:2.28-alpha"
+    kapt "com.google.dagger:hilt-android-compiler:2.28-alpha"
 }
 
 apply from: rootProject.file('gradle/gradle-mvn-push.gradle')

store/src/main/java/in/testpress/store/di/StoreApplication.kt

@@ -0,0 +1,7 @@
+package `in`.testpress.store.di
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class StoreApplication : Application()

store/src/main/java/in/testpress/store/di/StoreModule.kt

@@ -0,0 +1,29 @@
+package `in`.testpress.store.di
+
+import `in`.testpress.database.ProductDao
+import `in`.testpress.database.TestpressDatabase
+import `in`.testpress.store.network.StoreApiClient
+import android.content.Context
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ApplicationComponent
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Singleton
+
+@Module
+@InstallIn(ApplicationComponent::class)
+object StoreModule {
+
+    @Singleton
+    @Provides
+    fun provideProductDao(@ApplicationContext context: Context): ProductDao {
+        return TestpressDatabase(context).productDao()
+    }
+
+    @Singleton
+    @Provides
+    fun provideStoreApiClient(@ApplicationContext context: Context): StoreApiClient {
+        return StoreApiClient(context)
+    }
+}

store/src/main/java/in/testpress/store/repository/ProductsRepository.kt

@@ -0,0 +1,92 @@
+package `in`.testpress.store.repository
+
+import `in`.testpress.database.ProductCourseEntity
+import `in`.testpress.database.ProductDao
+import `in`.testpress.database.ProductPriceEntity
+import `in`.testpress.database.ProductWithCoursesAndPrices
+import `in`.testpress.network.NetworkBoundResource
+import `in`.testpress.network.Resource
+import `in`.testpress.network.RetrofitCall
+import `in`.testpress.store.domain.DomainProductWithCoursesAndPrices
+import `in`.testpress.store.domain.asDomainContent
+import `in`.testpress.store.network.NetworkProductResponse
+import `in`.testpress.store.network.StoreApiClient
+import `in`.testpress.store.network.asDatabaseModel
+import androidx.annotation.VisibleForTesting
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import javax.inject.Inject
+
+open class ProductsRepository @Inject constructor(
+        val productDao: ProductDao,
+        val storeApiClient: StoreApiClient
+) {
+
+    fun fetch(forceFetch: Boolean = true): LiveData<Resource<List<DomainProductWithCoursesAndPrices>>> {
+        return object : NetworkBoundResource<List<DomainProductWithCoursesAndPrices>, NetworkProductResponse>() {
+            override fun saveNetworkResponseToDB(item: NetworkProductResponse) {
+                saveProducts(item)
+                saveCourses(item)
+                savePrices(item)
+                saveRelationalData(item)
+            }
+
+            override fun shouldFetch(data: List<DomainProductWithCoursesAndPrices>?): Boolean {
+                return forceFetch || data.isNullOrEmpty()
+            }
+
+            override fun loadFromDb(): LiveData<List<DomainProductWithCoursesAndPrices>> {
+                val liveData = MutableLiveData<List<DomainProductWithCoursesAndPrices>>()
+                liveData.postValue(getProductFromDB()?.asDomainContent())
+                return liveData
+            }
+
+            override fun createCall(): RetrofitCall<NetworkProductResponse> {
+                return storeApiClient.productsList
+            }
+
+        }.asLiveData()
+    }
+
+    private fun saveProducts(item: NetworkProductResponse) {
+        item.products?.forEach {
+            it?.asDatabaseModel()?.let { it1 -> productDao.insertProduct(it1) }
+        }
+    }
+
+    private fun saveCourses(item: NetworkProductResponse) {
+        item.courses?.forEach {
+            it?.asDatabaseModel()?.let { it1 -> productDao.insertCourse(it1) }
+        }
+    }
+
+    private fun savePrices(item: NetworkProductResponse) {
+        item.prices?.forEach {
+            it?.asDatabaseModel()?.let { it1 -> productDao.insertPrice(it1) }
+        }
+    }
+
+    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+    fun saveRelationalData(item: NetworkProductResponse) {
+        item.products?.forEach { product ->
+            product?.courses?.forEach { courseId ->
+                productDao.insert(ProductCourseEntity(product.id, courseId))
+            }
+            product?.prices?.forEach { priceId ->
+                productDao.insertProductPrice(ProductPriceEntity(product.id, priceId))
+            }
+        }
+    }
+
+    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+    fun getProductFromDB(): List<ProductWithCoursesAndPrices>? = runBlocking {
+        val job = CoroutineScope(Dispatchers.IO).async {
+            productDao.getAll()
+        }
+        return@runBlocking job.await()
+    }
+}

store/src/test/java/in/testpress/store/repository/ProductsRepositoryTest.kt

@@ -0,0 +1,61 @@
+package `in`.testpress.store.repository
+
+import `in`.testpress.database.ProductDao
+import `in`.testpress.store.network.NetworkProductResponse
+import `in`.testpress.store.network.StoreApiClient
+import android.content.Context
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.Mockito
+import org.mockito.Mockito.verify
+import org.mockito.MockitoAnnotations
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class ProductsRepositoryTest {
+
+    @Mock
+    lateinit var productDao: ProductDao
+
+    @Mock
+    lateinit var storeApiClient: StoreApiClient
+
+    @Mock
+    lateinit var context: Context
+
+    private lateinit var repository: ProductsRepository
+
+    private lateinit var spy: ProductsRepository
+
+    @get:Rule
+    val instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @Before
+    fun setup() {
+        MockitoAnnotations.initMocks(this)
+        repository = ProductsRepository(productDao, storeApiClient)
+        spy = Mockito.spy(repository)
+    }
+
+    @Test
+    fun testWhenDbDataIsAvailableReturnDataImmediately() {
+        repository.fetch(false)
+        verify(spy).getProductFromDB()
+    }
+
+    @Test
+    fun testWhenNetworkFetchedSaveResponseToDb() {
+        repository.fetch(true)
+        verify(spy).saveRelationalData(item = NetworkProductResponse())
+    }
+
+    @Test
+    fun testWhenForceFetchFalseReturnDataImmediately() {
+        repository.fetch(false)
+        verify(spy).getProductFromDB()
+    }
+}