Migrate MediaModel to Room

WooCommerce/src/main/kotlin/com/woocommerce/android/media/FileUploadUtils.kt

@@ -79,13 +79,22 @@ object FileUploadUtils {
         }
 
         val media = MediaModel(
-            localSiteId,
-            DateTimeUtils.iso8601UTCFromTimestamp(System.currentTimeMillis() / 1000),
-            filenameWithExtension,
-            path,
-            mimeType,
-            filenameWithExtension,
-            null
+            id = 0,
+            localSiteId = localSiteId,
+            mediaId = 0L,
+            postId = 0L,
+            uploadDate = DateTimeUtils.iso8601UTCFromTimestamp(System.currentTimeMillis() / 1000),
+            url = "",
+            thumbnailUrl = null,
+            fileName = filenameWithExtension,
+            filePath = path,
+            mimeType = mimeType,
+            title = filenameWithExtension,
+            caption = "",
+            description = "",
+            alt = "",
+            uploadState = null,
+            markedLocallyAsFeatured = false
         )
         val instantiatedMedia = mediaStore.instantiateMediaModel(media)
         return if (instantiatedMedia != null) {

WooCommerce/src/main/kotlin/com/woocommerce/android/media/ProductImagesUploadWorker.kt

@@ -200,8 +200,8 @@ class ProductImagesUploadWorker @Inject constructor(
 
             val doneUploads = uploadList.count { it.isDone }
             notificationHandler.update(doneUploads + 1, uploadList.size)
-            work.fetchedMedia.postId = work.productId
-            mediaFilesRepository.uploadMedia(work.fetchedMedia).collect {
+            val mediaWithPostId = work.fetchedMedia.copy(postId = work.productId)
+            mediaFilesRepository.uploadMedia(mediaWithPostId).collect {
                 when (it) {
                     is UploadFailure -> {
                         WooLog.w(T.MEDIA, "ProductImagesUploadWorker -> upload failed for ${work.localUri}")

WooCommerce/src/test/kotlin/com/woocommerce/android/media/ProductImagesUploadWorkerTest.kt

@@ -35,7 +35,7 @@ import org.mockito.kotlin.never
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
-import org.wordpress.android.fluxc.model.MediaModel
+import org.wordpress.android.fluxc.media.MediaTestUtils
 import org.wordpress.android.fluxc.store.MediaStore.MediaErrorType.GENERIC_ERROR
 import org.wordpress.android.util.DateTimeUtils
 import java.util.Date
@@ -45,21 +45,18 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
     companion object {
         private const val REMOTE_PRODUCT_ID = 1L
         private const val TEST_URI = "test"
-        private val FETCHED_MEDIA = MediaModel(0, 0)
-        private val UPLOADED_MEDIA = MediaModel(0, 0).apply {
-            fileName = ""
-            filePath = ""
-            url = ""
+        private val FETCHED_MEDIA = MediaTestUtils.generateMediaFromPath()
+        private val UPLOADED_MEDIA = FETCHED_MEDIA.copy(
             uploadDate = DateTimeUtils.iso8601FromDate(Date())
-        }
+        )
     }
 
     private val notificationHandler: ProductImagesNotificationHandler = mock()
     private val productImagesServiceWrapper: ProductImagesServiceWrapper = mock()
     private lateinit var worker: ProductImagesUploadWorker
     private val mediaFilesRepository: MediaFilesRepository = mock {
         onBlocking { fetchMedia(TEST_URI) } doReturn FETCHED_MEDIA
-        onBlocking { uploadMedia(any(), any()) } doReturn flowOf(UploadResult.UploadSuccess(UPLOADED_MEDIA))
+        onBlocking { uploadMedia(any(), any()) } doReturn flowOf(UploadSuccess(UPLOADED_MEDIA))
     }
     private val productDetailRepository: ProductDetailRepository = mock()
 
@@ -122,7 +119,7 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         val job = launch {
             worker.events.toList(eventsList)
         }
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, FETCHED_MEDIA))
 
         advanceUntilIdle()
         verify(mediaFilesRepository).uploadMedia(any(), any())
@@ -133,9 +130,9 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
     @Test
     fun `when media upload progress changes, then update notification`() = testBlocking {
         whenever(mediaFilesRepository.uploadMedia(any(), any()))
-            .thenReturn(flowOf(UploadProgress(0.5f), UploadSuccess(MediaModel(0, 0))))
+            .thenReturn(flowOf(UploadProgress(0.5f), UploadSuccess(FETCHED_MEDIA)))
 
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, FETCHED_MEDIA))
         advanceUntilIdle()
 
         verify(notificationHandler).setProgress(0.5f)
@@ -153,7 +150,7 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         val job = launch {
             worker.events.toList(eventsList)
         }
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, FETCHED_MEDIA))
 
         advanceUntilIdle()
         assertThat(eventsList).contains(UploadFailed(REMOTE_PRODUCT_ID, TEST_URI, error))
@@ -166,7 +163,7 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         val job = launch {
             worker.events.toList(eventsList)
         }
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, FETCHED_MEDIA))
 
         advanceUntilIdle()
         assertThat(eventsList).contains(ProductUploadsCompleted(REMOTE_PRODUCT_ID))

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/media/MediaFileUploadHandlerTest.kt

@@ -29,11 +29,11 @@ import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
-import org.wordpress.android.fluxc.model.MediaModel
-import org.wordpress.android.fluxc.model.MediaModel.MediaUploadState.FAILED
-import org.wordpress.android.fluxc.model.MediaModel.MediaUploadState.UPLOADED
+import org.wordpress.android.fluxc.media.MediaTestUtils
 import org.wordpress.android.fluxc.store.MediaStore.MediaErrorType
 import org.wordpress.android.fluxc.store.MediaStore.MediaErrorType.NULL_MEDIA_ARG
+import org.wordpress.android.fluxc.store.MediaUploadState.FAILED
+import org.wordpress.android.fluxc.store.MediaUploadState.UPLOADED
 import org.wordpress.android.util.DateTimeUtils
 import java.util.Date
 
@@ -42,6 +42,8 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     companion object {
         private const val REMOTE_PRODUCT_ID = 1L
         private const val TEST_URI = "test"
+
+        private val FAKE_MEDIA = MediaTestUtils.generateMediaFromPath()
     }
 
     private val eventsFlow = MutableSharedFlow<Event>(extraBufferCapacity = Int.MAX_VALUE)
@@ -80,7 +82,7 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     fun `when media is fetched, then start uploading it`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
-        val fetchedMedia = MediaModel(0, 0)
+        val fetchedMedia = FAKE_MEDIA
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.FetchSucceeded(
                 REMOTE_PRODUCT_ID,
@@ -129,10 +131,10 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
             assertThat(successfulUpload.uploadState).isEqualTo(UPLOADED.toString())
         }
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            setUploadState(UPLOADED)
-        }
+        val mediaModel = FAKE_MEDIA.copy(
+            postId = REMOTE_PRODUCT_ID,
+            uploadState = UPLOADED.toString()
+        )
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadSucceeded(
                 REMOTE_PRODUCT_ID,
@@ -146,13 +148,13 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     fun `given there is no external observer, when uploads finish, then start product update`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            fileName = "test"
-            url = "url"
-            uploadDate = DateTimeUtils.iso8601FromDate(Date())
-            setUploadState(UPLOADED)
-        }
+        val mediaModel = FAKE_MEDIA.copy(
+            postId = REMOTE_PRODUCT_ID,
+            fileName = "test",
+            url = "url",
+            uploadDate = DateTimeUtils.iso8601FromDate(Date()),
+            uploadState = UPLOADED.toString()
+        )
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadSucceeded(
                 REMOTE_PRODUCT_ID,
@@ -170,13 +172,13 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
             val testUri2 = "file:///test2"
             mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI, testUri2))
 
-            val mediaModel = MediaModel(0, 0).apply {
-                postId = REMOTE_PRODUCT_ID
-                fileName = "test"
-                url = "url"
-                uploadDate = DateTimeUtils.iso8601FromDate(Date())
-                setUploadState(UPLOADED)
-            }
+            val mediaModel = FAKE_MEDIA.copy(
+                postId = REMOTE_PRODUCT_ID,
+                fileName = "test",
+                url = "url",
+                uploadDate = DateTimeUtils.iso8601FromDate(Date()),
+                uploadState = UPLOADED.toString()
+            )
             eventsFlow.tryEmit(
                 Event.MediaUploadEvent.UploadSucceeded(
                     REMOTE_PRODUCT_ID,
@@ -203,10 +205,10 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
 
         val job = launch { mediaFileUploadHandler.observeSuccessfulUploads(REMOTE_PRODUCT_ID).collect() }
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            setUploadState(FAILED)
-        }
+        val mediaModel = FAKE_MEDIA.copy(
+            postId = REMOTE_PRODUCT_ID,
+            uploadState = FAILED.toString()
+        )
 
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadFailed(
@@ -229,10 +231,10 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     fun `given there is no external observer, when an upload fails, then show notification`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            setUploadState(FAILED)
-        }
+        val mediaModel = FAKE_MEDIA.copy(
+            postId = REMOTE_PRODUCT_ID,
+            uploadState = FAILED.toString()
+        )
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadFailed(
                 REMOTE_PRODUCT_ID,
@@ -261,12 +263,12 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     @Test
     fun `when assigning uploads to created product, then update the id for the successful ones`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(ProductDetailViewModel.DEFAULT_ADD_NEW_PRODUCT_ID, listOf(TEST_URI))
-        val mediaModel = MediaModel(0, 0).apply {
-            fileName = "test"
-            url = "url"
-            uploadDate = DateTimeUtils.iso8601FromDate(Date())
-            setUploadState(UPLOADED)
-        }
+        val mediaModel = FAKE_MEDIA.copy(
+            fileName = "test",
+            url = "url",
+            uploadDate = DateTimeUtils.iso8601FromDate(Date()),
+            uploadState = UPLOADED.toString()
+        )
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadSucceeded(
                 ProductDetailViewModel.DEFAULT_ADD_NEW_PRODUCT_ID,

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/products/details/ProductDetailViewModelTest.kt

@@ -62,7 +62,7 @@ import org.mockito.kotlin.spy
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
-import org.wordpress.android.fluxc.model.MediaModel
+import org.wordpress.android.fluxc.media.MediaTestUtils.generateMediaFromPath
 import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.store.MediaStore
 import org.wordpress.android.fluxc.store.WCProductStore
@@ -1089,11 +1089,11 @@ class ProductDetailViewModelTest : BaseUnitTest() {
         mediaFileUploadHandler = mock {
             on { it.observeCurrentUploadErrors(any()) } doReturn emptyFlow()
             on { it.observeCurrentUploads(any()) } doReturn flowOf(emptyList())
-            on { it.observeSuccessfulUploads(any()) } doReturn uris.map {
-                MediaModel(0, 0).apply {
-                    url = it
-                    uploadDate = "2022-09-27 18:00:00.000"
-                }
+            on { it.observeSuccessfulUploads(any()) } doReturn uris.map { uri ->
+                generateMediaFromPath().copy(
+                    uploadDate = "2022-09-27 18:00:00.000",
+                    url = uri
+                )
             }.asFlow()
         }