Merge remote-tracking branch 'origin/main' into main

app/build.gradle

@@ -118,6 +118,7 @@ dependencies {
     implementation("androidx.hilt:hilt-navigation-compose:1.0.0")
     implementation "com.github.bumptech.glide:compose:1.0.0-alpha.1"
     implementation "androidx.compose.material3:material3:1.1.1"
+    testImplementation("org.mockito:mockito-core:2.1.0")
 
     debugImplementation "androidx.compose.ui:ui-tooling:1.4.2"
     implementation "androidx.compose.ui:ui-tooling-preview:1.4.2"
@@ -126,6 +127,7 @@ dependencies {
     implementation "androidx.compose.material:material-icons-extended:1.0.0"
 
     implementation libs.caruilib
+    testImplementation "org.mockito.kotlin:mockito-kotlin:5.1.0"
 
     testImplementation libs.junit
     androidTestImplementation libs.androidx.test.runner

app/src/test/java/com/hieuwu/groceriesstore/domain/usecases/impl/GetCategoriesListUseCaseImplTest.kt

@@ -0,0 +1,68 @@
+package com.hieuwu.groceriesstore.domain.usecases.impl
+
+import com.hieuwu.groceriesstore.data.repository.CategoryRepository
+import com.hieuwu.groceriesstore.domain.models.CategoryModel
+import com.hieuwu.groceriesstore.domain.usecases.GetCategoriesListUseCase
+import junit.framework.TestCase.assertEquals
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+import org.mockito.kotlin.whenever
+
+@RunWith(MockitoJUnitRunner::class)
+
+class GetCategoriesListUseCaseImplTest {
+
+    @Mock
+    lateinit var mockedCategoryRepository: CategoryRepository
+
+    private lateinit var testee: GetCategoriesListUseCaseImpl
+
+    @Before
+    fun setUp() {
+        testee = GetCategoriesListUseCaseImpl(
+            categoryRepository = mockedCategoryRepository
+        )
+    }
+
+    @Test
+    fun givenCategoriesAvailable_whenExecute_thenReturnCorrectValue() {
+        val mockCategories = listOf(
+            CategoryModel(id = "1", name = "Category 1", image = "image1.jpg"),
+            CategoryModel(id = "2", name = "Category 2", image = "image2.jpg"),
+            CategoryModel(id = "3", name = "Category 3", image = "image3.jpg"),
+            CategoryModel(id = "4", name = "Category 4", image = "image4.jpg")
+        )
+        whenever(mockedCategoryRepository.getFromLocal()).thenReturn(flow {
+            emit(mockCategories)
+        })
+        runBlocking {
+            val result = testee.execute(GetCategoriesListUseCase.Input())
+
+            result.result.collect { categories ->
+                assertEquals(mockCategories[0], categories[0])
+                assertEquals(mockCategories[1], categories[1])
+                assertEquals(mockCategories[2], categories[2])
+                assertEquals(mockCategories[1].name, "Category 2")
+                assertEquals(mockCategories[3].image, "image4.jpg")
+            }
+        }
+    }
+
+    @Test
+    fun givenCategoriesUnavailable_whenExecute_thenReturnCorrectValue() {
+        whenever(mockedCategoryRepository.getFromLocal()).thenReturn(flow {
+            emit(listOf())
+        })
+        runBlocking {
+            val result = testee.execute(GetCategoriesListUseCase.Input())
+            result.result.collect {
+                assertEquals(it.isEmpty(), true)
+            }
+        }
+    }
+}

app/src/test/java/com/hieuwu/groceriesstore/domain/usecases/impl/GetCurrentCartUseCaseImplTest.kt

@@ -0,0 +1,71 @@
+package com.hieuwu.groceriesstore.domain.usecases.impl
+
+import com.hieuwu.groceriesstore.data.repository.OrderRepository
+import com.hieuwu.groceriesstore.domain.models.OrderModel
+import com.hieuwu.groceriesstore.domain.usecases.GetCurrentCartUseCase
+import com.hieuwu.groceriesstore.utilities.OrderStatus
+import junit.framework.TestCase.assertEquals
+import junit.framework.TestCase.assertNull
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+import org.mockito.kotlin.whenever
+
+@RunWith(MockitoJUnitRunner::class)
+
+class GetCurrentCartUseCaseImplTest {
+
+    @Mock
+    lateinit var mockedOrderRepository: OrderRepository
+
+    private lateinit var testee: GetCurrentCartUseCaseImpl
+
+    @Before
+    fun setUp() {
+        testee = GetCurrentCartUseCaseImpl(
+            orderRepository = mockedOrderRepository
+        )
+    }
+
+    @Test
+    fun givenCartNotEmpty_whenExecute_thenReturnOrdersInCart() {
+        val mockOrder = OrderModel(
+            id = "",
+            status = OrderStatus.IN_CART.value,
+            address = null,
+            lineItemList = mutableListOf(),
+            createdAt = ""
+        )
+        whenever(mockedOrderRepository.getOneOrderByStatus(OrderStatus.IN_CART)).thenReturn(flow {
+            emit(mockOrder)
+        })
+        runBlocking {
+            val result = testee.execute(GetCurrentCartUseCase.Input())
+
+            result.result.collect { order ->
+                assertEquals(order?.id, "")
+                assertEquals(order?.status, "cart")
+                assertEquals(order?.address, null)
+                assertEquals(order?.lineItemList!!.isEmpty(), true)
+                assertEquals(order.createdAt, "")
+            }
+        }
+    }
+
+    @Test
+    fun givenCartEmpty_whenExecute_thenReturnNull() {
+        whenever(mockedOrderRepository.getOneOrderByStatus(OrderStatus.IN_CART)).thenReturn(flow {
+            null
+        })
+        runBlocking {
+            val result = testee.execute(GetCurrentCartUseCase.Input())
+            result.result.collect {
+                assertNull(it)
+            }
+        }
+    }
+}

app/src/test/java/com/hieuwu/groceriesstore/domain/usecases/impl/GetProductsListUseCaseImplTest.kt

@@ -0,0 +1,68 @@
+package com.hieuwu.groceriesstore.domain.usecases.impl
+
+import com.hieuwu.groceriesstore.data.repository.ProductRepository
+import com.hieuwu.groceriesstore.domain.models.ProductModel
+import com.hieuwu.groceriesstore.domain.usecases.GetProductsListUseCase
+import junit.framework.TestCase.assertEquals
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+import org.mockito.kotlin.whenever
+
+@RunWith(MockitoJUnitRunner::class)
+
+class GetProductsListUseCaseImplTest {
+
+    @Mock
+    lateinit var mockedProductsRepository: ProductRepository
+
+    private lateinit var testee: GetProductsListUseCase
+
+    @Before
+    fun setUp() {
+        testee = GetProductsListUseCaseImpl(
+            productRepository = mockedProductsRepository
+        )
+    }
+
+    @Test
+    fun givenProductsAvailable_whenExecute_thenReturnCorrectValue() {
+        val mockedProducts = listOf(
+            ProductModel(id = "1", name = "Apple", price = 1.0, image = "image1.jpg", description = "Fruit", nutrition = "Healthy"),
+            ProductModel(id = "2", name = "Fries", price = 5.0, image = "image2.jpg", description = "Junk food", nutrition = "Unhealthy"),
+            ProductModel(id = "3", name = "Potato", price = 10.0, image = "image3.jpg", description = "Vegetable", nutrition = "Healthy"),
+        )
+        whenever(mockedProductsRepository.products).thenReturn(flow {
+            emit(mockedProducts)
+        })
+        runBlocking {
+            val result = testee.execute(GetProductsListUseCase.Input())
+
+            result.result.collect { products ->
+                assertEquals(mockedProducts[0], products[0])
+                assertEquals(mockedProducts[1], products[1])
+                assertEquals(mockedProducts[2], products[2])
+                assertEquals(mockedProducts[1].name, "Fries")
+            }
+        }
+    }
+
+    @Test
+    fun givenProductsUnavailable_whenExecute_thenReturnCorrectValue() {
+        whenever(mockedProductsRepository.products).thenReturn(flow {
+            emit(listOf())
+        })
+
+        runBlocking {
+            val result = testee.execute(GetProductsListUseCase.Input())
+            result.result.collect {
+                assertEquals(it.isEmpty(), true)
+            }
+        }
+    }
+
+}

app/src/test/java/com/hieuwu/groceriesstore/domain/usecases/impl/GetProfileUseCaseImplTest.kt

@@ -0,0 +1,76 @@
+package com.hieuwu.groceriesstore.domain.usecases.impl
+
+import com.hieuwu.groceriesstore.data.repository.UserRepository
+import com.hieuwu.groceriesstore.domain.models.UserModel
+import com.hieuwu.groceriesstore.domain.usecases.GetProfileUseCase
+import junit.framework.TestCase.assertEquals
+import junit.framework.TestCase.assertNotNull
+import junit.framework.TestCase.assertNull
+import junit.framework.TestCase.assertTrue
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+import org.mockito.kotlin.whenever
+
+@RunWith(MockitoJUnitRunner::class)
+
+class GetProfileUseCaseImplTest {
+
+    @Mock
+    lateinit var mockedUserRepository: UserRepository
+
+    private lateinit var testee: GetProfileUseCase
+
+    @Before
+    fun setUp() {
+        testee = GetProfileUseCaseImpl(
+            userRepository = mockedUserRepository
+        )
+    }
+
+    @Test
+    fun givenUserAvailable_whenExecute_thenReturnCorrectValue() {
+        whenever(mockedUserRepository.getCurrentUser()).thenReturn(flow {
+            UserModel(
+                id = "",
+                name = "",
+                email = "",
+                phone = "",
+                address = "",
+                isOrderCreatedNotiEnabled = true,
+                isPromotionNotiEnabled = true,
+                isDataRefreshedNotiEnabled = true
+            )
+        })
+        runBlocking {
+            val result = testee.execute(GetProfileUseCase.Input())
+
+            result.result.collect {
+                assertEquals("", it?.id)
+                assertTrue(it!!.isDataRefreshedNotiEnabled)
+                assertTrue(it.isOrderCreatedNotiEnabled)
+                assertTrue(it.isPromotionNotiEnabled)
+            }
+        }
+    }
+
+
+    @Test
+    fun givenUserUnavailable_whenExecute_thenReturnCorrectValue() {
+        whenever(mockedUserRepository.getCurrentUser()).thenReturn(flow {
+            null
+        })
+
+        runBlocking {
+            val result = testee.execute(GetProfileUseCase.Input())
+            result.result.collect {
+                assertNull(it)
+            }
+        }
+    }
+
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Tue Oct 10 05:12:00 IST 2023
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

local.properties

@@ -4,8 +4,8 @@
 # Location of the SDK. This is only used by Gradle.
 # For customization when using a Version Control System, please read the
 # header note.
-#Mon Jun 19 22:39:27 ICT 2023
-sdk.dir=/Users/hieuvu/Library/Android/sdk
+#Tue Oct 10 04:51:12 IST 2023
 API_KEY=YOUR_SUPABASE_KEY
-SUPABASE_URL=YOUR_SUPABASE_URL
 SECRET=YOUR_SUPABASE_SECRET
+SUPABASE_URL=YOUR_SUPABASE_URL
+sdk.dir=C\:\\Users\\raghu\\AppData\\Local\\Android\\Sdk