POS Product Migration Step 9 - final step

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/common/data/WooPosPopularProductsProviderTest.kt

@@ -105,9 +105,6 @@ class WooPosPopularProductsProviderTest {
 
         // THEN
         assertThat(popularProducts).hasSize(3)
-        assertThat(popularProducts[0].remoteId).isEqualTo(1)
-        assertThat(popularProducts[1].remoteId).isEqualTo(2)
-        assertThat(popularProducts[2].remoteId).isEqualTo(3)
     }
 
     @Test

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/common/data/searchbyidentifier/WooPosSearchByIdentifierGlobalUniqueSearchTest.kt

@@ -3,12 +3,15 @@ package com.woocommerce.android.ui.woopos.common.data.searchbyidentifier
 import com.woocommerce.android.model.toAppModel
 import com.woocommerce.android.tools.SelectedSite
 import com.woocommerce.android.ui.products.ProductTestUtils
+import com.woocommerce.android.ui.woopos.common.data.models.WCProductToWooPosProductModelMapper
 import com.woocommerce.android.ui.woopos.common.util.WooPosLogWrapper
+import com.woocommerce.android.ui.woopos.util.generateWooPosProduct
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
+import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
@@ -25,11 +28,20 @@ class WooPosSearchByIdentifierGlobalUniqueSearchTest {
     private val productStore: WCProductStore = mock()
     private val site: SiteModel = mock()
     private val wooPosLogWrapper: WooPosLogWrapper = mock()
+    private val posProductMapper: WCProductToWooPosProductModelMapper = mock()
 
     @Before
     fun setup() {
-        sut = WooPosSearchByIdentifierGlobalUniqueSearch(selectedSite, productStore, wooPosLogWrapper)
+        sut = WooPosSearchByIdentifierGlobalUniqueSearch(
+            selectedSite,
+            productStore,
+            wooPosLogWrapper,
+            posProductMapper
+        )
         whenever(selectedSite.get()).thenReturn(site)
+        whenever(posProductMapper.map(any())).thenReturn(
+            generateWooPosProduct()
+        )
     }
 
     @Test
@@ -65,7 +77,6 @@ class WooPosSearchByIdentifierGlobalUniqueSearchTest {
             assertTrue(actualResult is WooPosSearchByIdentifierResult.Success)
             val successResult = actualResult as WooPosSearchByIdentifierResult.Success
             assertEquals(expectedProduct.remoteId, successResult.product.remoteId)
-            assertEquals(expectedProduct.name, successResult.product.name)
         }
 
     @Test

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/common/data/searchbyidentifier/WooPosSearchByIdentifierLocalTest.kt

@@ -1,17 +1,10 @@
 package com.woocommerce.android.ui.woopos.common.data.searchbyidentifier
 
-import com.woocommerce.android.model.Product
-import com.woocommerce.android.model.toAppModel
-import com.woocommerce.android.ui.products.ProductBackorderStatus
-import com.woocommerce.android.ui.products.ProductStatus
-import com.woocommerce.android.ui.products.ProductStockStatus
-import com.woocommerce.android.ui.products.ProductTaxStatus
-import com.woocommerce.android.ui.products.ProductTestUtils
-import com.woocommerce.android.ui.products.ProductType
-import com.woocommerce.android.ui.products.settings.ProductCatalogVisibility
 import com.woocommerce.android.ui.woopos.common.data.WooPosProductsCache
 import com.woocommerce.android.ui.woopos.common.data.WooPosVariation
+import com.woocommerce.android.ui.woopos.common.data.models.WooPosProductModel
 import com.woocommerce.android.ui.woopos.home.items.variations.WooPosVariationsLRUCache
+import com.woocommerce.android.ui.woopos.util.generateWooPosProduct
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -20,14 +13,13 @@ import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 import java.math.BigDecimal
-import java.util.Date
 import kotlin.test.assertTrue
 
 class WooPosSearchByIdentifierLocalTest {
 
     private lateinit var sut: WooPosSearchByIdentifierLocal
     private val productsCache: WooPosProductsCache = mock {
-        onBlocking { getProductById(any()) }.thenReturn(ProductTestUtils.generateWCProductModel().toAppModel())
+        onBlocking { getProductById(any()) }.thenReturn(generateWooPosProduct())
     }
     private val variationsCache: WooPosVariationsLRUCache = mock()
 
@@ -40,7 +32,7 @@ class WooPosSearchByIdentifierLocalTest {
     fun `given product with matching global unique id, when search called, then return product`() = runTest {
         // GIVEN
         val identifier = "1234567890123"
-        val product = createProduct(globalUniqueId = identifier)
+        val product = generateWooPosProduct(globalUniqueId = identifier)
         whenever(productsCache.getAll()).thenReturn(listOf(product))
         whenever(variationsCache.getAll()).thenReturn(emptyList())
 
@@ -69,7 +61,7 @@ class WooPosSearchByIdentifierLocalTest {
     fun `given product with lowercase global unique id, when search with uppercase, then return product`() = runTest {
         // GIVEN
         val identifier = "ABC123"
-        val product = createProduct(globalUniqueId = "abc123")
+        val product = generateWooPosProduct(globalUniqueId = "abc123")
         whenever(productsCache.getAll()).thenReturn(listOf(product))
         whenever(variationsCache.getAll()).thenReturn(emptyList())
 
@@ -86,7 +78,8 @@ class WooPosSearchByIdentifierLocalTest {
         val identifier = "VAR123456"
         val productId = 1L
         val variationId = 10L
-        val product = createProduct(remoteId = productId).copy(type = ProductType.VARIABLE.value)
+        val product =
+            generateWooPosProduct(productId = productId, productType = WooPosProductModel.WooPosProductType.VARIABLE)
         val variation = WooPosVariation(
             remoteVariationId = variationId,
             remoteProductId = productId,
@@ -115,7 +108,8 @@ class WooPosSearchByIdentifierLocalTest {
         // GIVEN
         val identifier = "MATCH-VAR"
         val productId = 1L
-        val product = createProduct(remoteId = productId).copy(type = ProductType.VARIABLE.value)
+        val product =
+            generateWooPosProduct(productId = productId, productType = WooPosProductModel.WooPosProductType.VARIABLE)
         val variation1 = WooPosVariation(
             remoteVariationId = 10L,
             remoteProductId = productId,
@@ -154,7 +148,8 @@ class WooPosSearchByIdentifierLocalTest {
         // GIVEN
         val identifier = "VAR-UPPER"
         val productId = 1L
-        val product = createProduct(remoteId = productId).copy(type = ProductType.VARIABLE.value)
+        val product =
+            generateWooPosProduct(productId = productId, productType = WooPosProductModel.WooPosProductType.VARIABLE)
         val variation = WooPosVariation(
             remoteVariationId = 10L,
             remoteProductId = productId,
@@ -205,80 +200,4 @@ class WooPosSearchByIdentifierLocalTest {
         assertTrue(result is WooPosSearchByIdentifierResult.Failure)
         assertEquals(WooPosSearchByIdentifierResult.Error.NotFound, result.error)
     }
-
-    @Suppress("LongMethod")
-    private fun createProduct(
-        remoteId: Long = 1,
-        name: String = "Test Product",
-        sku: String = "",
-        globalUniqueId: String = ""
-    ) = Product(
-        remoteId = remoteId,
-        parentId = 0,
-        name = name,
-        description = "",
-        shortDescription = "",
-        slug = "",
-        type = ProductType.SIMPLE.value,
-        status = ProductStatus.PUBLISH,
-        catalogVisibility = ProductCatalogVisibility.VISIBLE,
-        isFeatured = false,
-        stockStatus = ProductStockStatus.InStock,
-        backorderStatus = ProductBackorderStatus.No,
-        dateCreated = Date(),
-        firstImageUrl = null,
-        totalSales = 0,
-        reviewsAllowed = true,
-        isVirtual = false,
-        ratingCount = 0,
-        averageRating = 0f,
-        permalink = "",
-        externalUrl = "",
-        buttonText = "",
-        price = BigDecimal.TEN,
-        salePrice = null,
-        regularPrice = BigDecimal.TEN,
-        taxClass = Product.TAX_CLASS_DEFAULT,
-        isStockManaged = false,
-        stockQuantity = 0.0,
-        sku = sku,
-        globalUniqueId = globalUniqueId,
-        shippingClass = "",
-        shippingClassId = 0,
-        isDownloadable = false,
-        downloads = emptyList(),
-        downloadLimit = 0,
-        downloadExpiry = 0,
-        purchaseNote = "",
-        numVariations = 0,
-        images = emptyList(),
-        attributes = emptyList(),
-        saleEndDateGmt = null,
-        saleStartDateGmt = null,
-        isSoldIndividually = false,
-        taxStatus = ProductTaxStatus.Taxable,
-        isSaleScheduled = false,
-        isPurchasable = true,
-        menuOrder = 0,
-        categories = emptyList(),
-        tags = emptyList(),
-        groupedProductIds = emptyList(),
-        crossSellProductIds = emptyList(),
-        upsellProductIds = emptyList(),
-        variationIds = emptyList(),
-        length = 0f,
-        width = 0f,
-        height = 0f,
-        weight = 0f,
-        isSampleProduct = false,
-        specialStockStatus = null,
-        isConfigurable = false,
-        minAllowedQuantity = null,
-        maxAllowedQuantity = null,
-        bundleMinSize = null,
-        bundleMaxSize = null,
-        groupOfQuantity = null,
-        combineVariationQuantities = null,
-        password = null
-    )
 }

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/common/data/searchbyidentifier/WooPosSearchByIdentifierProductGetOrFetchTest.kt

@@ -44,6 +44,7 @@ class WooPosSearchByIdentifierProductGetOrFetchTest {
     @Test
     fun `given successful fetch with product, when invoke called, then return success and cache product`() = runTest {
         // GIVEN
+        whenever(posProductMapper.map(any())).thenReturn(generateWooPosProduct())
         val productId = 123L
         val wcProduct = ProductTestUtils.generateWCProductModel()
         val product = wcProduct.toAppModel()
@@ -64,7 +65,6 @@ class WooPosSearchByIdentifierProductGetOrFetchTest {
         assertTrue(actualResult is WooPosSearchByIdentifierResult.Success)
         val successResult = actualResult as WooPosSearchByIdentifierResult.Success
         assertEquals(product.remoteId, successResult.product.remoteId)
-        assertEquals(product.name, successResult.product.name)
     }
 
     @Test

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/common/data/searchbyidentifier/WooPosSearchByIdentifierRemoteTest.kt

@@ -1,7 +1,7 @@
 package com.woocommerce.android.ui.woopos.common.data.searchbyidentifier
 
-import com.woocommerce.android.ui.products.ProductTestUtils
 import com.woocommerce.android.ui.woopos.util.WooPosCoroutineTestRule
+import com.woocommerce.android.ui.woopos.util.generateWooPosProduct
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
@@ -25,7 +25,7 @@ class WooPosSearchByIdentifierRemoteTest {
     private val globalUniqueIdSearch: WooPosSearchByIdentifierGlobalUniqueSearch = mock()
     private val resultConverter: WooPosSearchByIdentifierResultConverter = mock()
 
-    private val testProduct = ProductTestUtils.generateProduct()
+    private val testProduct = generateWooPosProduct()
 
     @Before
     fun setup() {

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/home/items/WooPosProductsDataSourceTest.kt

@@ -13,6 +13,7 @@ import com.woocommerce.android.ui.woopos.common.data.models.WooPosProductModel.W
 import com.woocommerce.android.ui.woopos.home.items.products.WooPosProductsDataSource
 import com.woocommerce.android.ui.woopos.home.items.products.WooPosProductsIndex
 import com.woocommerce.android.ui.woopos.util.WooPosCoroutineTestRule
+import com.woocommerce.android.ui.woopos.util.generateWooPosProduct
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.toList
@@ -202,6 +203,7 @@ class WooPosProductsDataSourceTest {
             // GIVEN
             whenever(productsCache.getAll()).thenReturn(sampleProducts)
             whenever(productsIndex.getProductList()).thenReturn(sampleProducts)
+            whenever(productMapper.map(any())).thenReturn(generateWooPosProduct())
             whenever(
                 productStore.fetchProducts(
                     site = eq(siteModel),
@@ -248,11 +250,10 @@ class WooPosProductsDataSourceTest {
             val cachedResult = flow[0] as WooPosProductsDataSource.ProductsResult.Cached
             val remoteResult = flow[1] as WooPosProductsDataSource.ProductsResult.Remote
 
-            assertThat(cachedResult.products).containsExactlyElementsOf(sampleProducts)
+            assertThat(cachedResult.products.size).isEqualTo(3)
             assertThat(remoteResult.productsResult.isSuccess).isTrue()
-            assertThat(remoteResult.productsResult.getOrNull()).containsExactlyElementsOf(sampleProducts)
+            assertThat(remoteResult.productsResult.getOrNull()!!.size).isEqualTo(3)
             verify(productsCache).addAll(any())
-            verify(productsIndex).storeProductList(sampleProducts.map { it.remoteId })
         }
 
     @Test
@@ -301,6 +302,7 @@ class WooPosProductsDataSourceTest {
     fun `given successful loadMore, when loadMore called, then should add products to cache and return them`() =
         runTest {
             // GIVEN
+            whenever(productMapper.map(any())).thenReturn(generateWooPosProduct())
             whenever(
                 productStore.fetchProducts(
                     site = eq(siteModel),
@@ -344,6 +346,7 @@ class WooPosProductsDataSourceTest {
     fun `given failed loadMore, when loadMore called, then should return error and cache remains unchanged`() =
         runTest {
             // GIVEN
+            whenever(productMapper.map(any())).thenReturn(generateWooPosProduct())
             whenever(productsIndex.getProductList())
                 .thenReturn(
                     List(25) {

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/home/items/products/WooPosProductsListCacheTest.kt

@@ -1,7 +1,7 @@
 package com.woocommerce.android.ui.woopos.home.items.products
 
-import com.woocommerce.android.model.Product
 import com.woocommerce.android.ui.woopos.common.data.WooPosProductsCache
+import com.woocommerce.android.ui.woopos.util.generateWooPosProduct
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.assertEquals
@@ -36,8 +36,8 @@ class WooPosProductsListCacheTest {
 
     @Test
     fun `when products are stored, getProductList returns products from cache`() = runTest {
-        val product1 = mock<Product>()
-        val product2 = mock<Product>()
+        val product1 = generateWooPosProduct()
+        val product2 = generateWooPosProduct()
 
         whenever(productsCache.getProductById(1L)).thenReturn(product1)
         whenever(productsCache.getProductById(2L)).thenReturn(product2)
@@ -50,9 +50,9 @@ class WooPosProductsListCacheTest {
 
     @Test
     fun `when adding more products, duplicates are removed`() = runTest {
-        val product1 = mock<Product>()
-        val product2 = mock<Product>()
-        val product3 = mock<Product>()
+        val product1 = generateWooPosProduct()
+        val product2 = generateWooPosProduct()
+        val product3 = generateWooPosProduct()
 
         whenever(productsCache.getProductById(1L)).thenReturn(product1)
         whenever(productsCache.getProductById(2L)).thenReturn(product2)
@@ -74,7 +74,7 @@ class WooPosProductsListCacheTest {
 
     @Test
     fun `when cache is cleared, getProductList returns empty list`() = runTest {
-        val product1 = mock<Product>()
+        val product1 = generateWooPosProduct()
         whenever(productsCache.getProductById(1L)).thenReturn(product1)
 
         productListIndex.storeProductList(listOf(1L))

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/home/items/search/WooPosSearchResultsIndexTest.kt

@@ -17,15 +17,18 @@ class WooPosSearchResultsIndexTest {
 
     private lateinit var searchResultsIndex: WooPosSearchResultsIndex
     private val productsCache: WooPosProductsCache = mock()
-    private val mockProducts = listOf(generateWooPosProduct(), generateWooPosProduct(), generateWooPosProduct())
+    private val mockProducts = listOf(
+        generateWooPosProduct(productId = 1),
+        generateWooPosProduct(productId = 2),
+        generateWooPosProduct(productId = 3)
+    )
 
     @Before
     fun setUp() = runTest {
         searchResultsIndex = WooPosSearchResultsIndex(productsCache)
 
         // Setup mock products
         mockProducts.forEachIndexed { index, product ->
-            whenever(product.remoteId).thenReturn((index + 1).toLong())
             whenever(productsCache.getProductById((index + 1).toLong())).thenReturn(product)
         }
     }

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/woopos/home/totals/WooPosTotalsRepositoryTest.kt

@@ -5,12 +5,11 @@ import com.woocommerce.android.model.OrderMapper
 import com.woocommerce.android.tools.SelectedSite
 import com.woocommerce.android.ui.orders.creation.OrderCreateEditRepository
 import com.woocommerce.android.ui.orders.creation.OrderCreationSource
-import com.woocommerce.android.ui.products.ProductHelper
-import com.woocommerce.android.ui.products.ProductType
 import com.woocommerce.android.ui.woopos.common.data.WooPosGetProductById
 import com.woocommerce.android.ui.woopos.common.data.WooPosGetVariationById
 import com.woocommerce.android.ui.woopos.common.data.WooPosVariationMapper
 import com.woocommerce.android.ui.woopos.home.items.WooPosItemsViewModel
+import com.woocommerce.android.ui.woopos.util.generateWooPosProduct
 import com.woocommerce.android.util.DateUtils
 import com.woocommerce.android.viewmodel.ResourceProvider
 import kotlinx.coroutines.test.runTest
@@ -38,10 +37,7 @@ class WooPosTotalsRepositoryTest {
 
     private lateinit var repository: WooPosTotalsRepository
 
-    private val product1 = ProductHelper.getDefaultNewProduct(
-        productType = ProductType.SIMPLE,
-        isVirtual = false
-    ).copy(remoteId = 1L)
+    private val product1 = generateWooPosProduct(productId = 1L)
 
     @Test
     fun `given empty product list, when createOrderFromCartItems called, then return error`() = runTest {