Add underlying support for file sends (#646)

app/src/test/java/com/x8bit/bitwarden/data/vault/datasource/network/model/SendJsonRequestUtil.kt

@@ -17,6 +17,7 @@ fun createMockSendJsonRequest(
         maxAccessCount = 1,
         expirationDate = ZonedDateTime.parse("2023-10-27T12:00:00Z"),
         deletionDate = ZonedDateTime.parse("2023-10-27T12:00:00Z"),
+        fileLength = 1,
         file = createMockFile(number),
         text = createMockText(number),
         password = "mockPassword-$number",

app/src/test/java/com/x8bit/bitwarden/data/vault/datasource/network/model/SyncResponseSendUtil.kt

@@ -2,14 +2,17 @@ package com.x8bit.bitwarden.data.vault.datasource.network.model
 
 import java.time.ZonedDateTime
 
-fun createMockSend(number: Int): SyncResponseJson.Send =
+fun createMockSend(
+    number: Int,
+    type: SendTypeJson = SendTypeJson.FILE,
+): SyncResponseJson.Send =
     SyncResponseJson.Send(
         accessCount = 1,
         notes = "mockNotes-$number",
         revisionDate = ZonedDateTime.parse("2023-10-27T12:00:00Z"),
         maxAccessCount = 1,
         shouldHideEmail = false,
-        type = SendTypeJson.FILE,
+        type = type,
         accessId = "mockAccessId-$number",
         password = "mockPassword-$number",
         file = createMockFile(number = number),

app/src/test/java/com/x8bit/bitwarden/data/vault/datasource/network/service/SendsServiceTest.kt

@@ -1,29 +1,73 @@
 package com.x8bit.bitwarden.data.vault.datasource.network.service
 
+import android.net.Uri
 import com.x8bit.bitwarden.data.platform.base.BaseServiceTest
+import com.x8bit.bitwarden.data.vault.datasource.network.api.AzureApi
 import com.x8bit.bitwarden.data.vault.datasource.network.api.SendsApi
+import com.x8bit.bitwarden.data.vault.datasource.network.model.SendFileResponseJson
+import com.x8bit.bitwarden.data.vault.datasource.network.model.SendTypeJson
 import com.x8bit.bitwarden.data.vault.datasource.network.model.UpdateSendResponseJson
 import com.x8bit.bitwarden.data.vault.datasource.network.model.createMockSend
 import com.x8bit.bitwarden.data.vault.datasource.network.model.createMockSendJsonRequest
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkStatic
 import kotlinx.coroutines.test.runTest
 import okhttp3.mockwebserver.MockResponse
+import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import retrofit2.create
+import java.time.Clock
+import java.time.Instant
+import java.time.ZoneOffset
 
 class SendsServiceTest : BaseServiceTest() {
+    private val clock: Clock = Clock.fixed(
+        Instant.parse("2023-10-27T12:00:00Z"),
+        ZoneOffset.UTC,
+    )
+    private val azureApi: AzureApi = retrofit.create()
     private val sendsApi: SendsApi = retrofit.create()
 
     private val sendsService: SendsService = SendsServiceImpl(
+        azureApi = azureApi,
         sendsApi = sendsApi,
         json = json,
+        clock = clock,
     )
 
+    @BeforeEach
+    fun setup() {
+        mockkStatic(Uri::class)
+    }
+
+    @AfterEach
+    fun tearDown() {
+        unmockkStatic(Uri::class)
+    }
+
+    @Test
+    fun `createFileSend should return the correct response`() = runTest {
+        val response = SendFileResponseJson(
+            url = "www.test.com",
+            fileUploadType = SendFileResponseJson.FileUploadType.AZURE,
+            sendResponse = createMockSend(number = 1, type = SendTypeJson.FILE),
+        )
+        server.enqueue(MockResponse().setBody(CREATE_FILE_SEND_SUCCESS_JSON))
+        val result = sendsService.createFileSend(
+            body = createMockSendJsonRequest(number = 1, type = SendTypeJson.FILE),
+        )
+        assertEquals(response, result.getOrThrow())
+    }
+
     @Test
     fun `createSend should return the correct response`() = runTest {
         server.enqueue(MockResponse().setBody(CREATE_UPDATE_SEND_SUCCESS_JSON))
         val result = sendsService.createSend(
-            body = createMockSendJsonRequest(number = 1),
+            body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT),
         )
         assertEquals(
             createMockSend(number = 1),
@@ -64,6 +108,46 @@ class SendsServiceTest : BaseServiceTest() {
             )
         }
 
+    @Test
+    fun `uploadFile with Azure uploadFile success should return send`() = runTest {
+        val url = "www.test.com"
+        setupMockUri(url = url, queryParams = mapOf("sv" to "2024-04-03"))
+        val mockSend = createMockSend(number = 1, type = SendTypeJson.FILE)
+        val sendFileResponse = SendFileResponseJson(
+            url = url,
+            fileUploadType = SendFileResponseJson.FileUploadType.AZURE,
+            sendResponse = mockSend,
+        )
+        val encryptedFile = byteArrayOf()
+        server.enqueue(MockResponse().setResponseCode(201))
+
+        val result = sendsService.uploadFile(
+            sendFileResponse = sendFileResponse,
+            encryptedFile = encryptedFile,
+        )
+
+        assertEquals(mockSend, result.getOrThrow())
+    }
+
+    @Test
+    fun `uploadFile with Direct uploadFile success should return send`() = runTest {
+        val mockSend = createMockSend(number = 1, type = SendTypeJson.FILE)
+        val sendFileResponse = SendFileResponseJson(
+            url = "www.test.com",
+            fileUploadType = SendFileResponseJson.FileUploadType.DIRECT,
+            sendResponse = mockSend,
+        )
+        val encryptedFile = byteArrayOf()
+        server.enqueue(MockResponse().setResponseCode(201))
+
+        val result = sendsService.uploadFile(
+            sendFileResponse = sendFileResponse,
+            encryptedFile = encryptedFile,
+        )
+
+        assertEquals(mockSend, result.getOrThrow())
+    }
+
     @Test
     fun `deleteSend should return a Success with the correct data`() = runTest {
         server.enqueue(MockResponse().setResponseCode(200))
@@ -96,6 +180,19 @@ class SendsServiceTest : BaseServiceTest() {
                 result.getOrThrow(),
             )
         }
+
+    private fun setupMockUri(
+        url: String,
+        queryParams: Map<String, String>,
+    ): Uri {
+        val mockUri = mockk<Uri> {
+            queryParams.forEach {
+                every { getQueryParameter(it.key) } returns it.value
+            }
+        }
+        every { Uri.parse(url) } returns mockUri
+        return mockUri
+    }
 }
 
 private const val CREATE_UPDATE_SEND_SUCCESS_JSON = """
@@ -127,6 +224,39 @@ private const val CREATE_UPDATE_SEND_SUCCESS_JSON = """
 }
 """
 
+private const val CREATE_FILE_SEND_SUCCESS_JSON = """
+{
+  "url": "www.test.com",
+  "fileUploadType": "1",
+  "sendResponse": {
+    "id": "mockId-1",
+    "accessId": "mockAccessId-1",
+    "type": 1,
+    "name": "mockName-1",
+    "notes": "mockNotes-1",
+    "file": {
+      "id": "mockId-1",
+      "fileName": "mockFileName-1",
+      "size": 1,
+      "sizeName": "mockSizeName-1"
+    },
+    "text": {
+      "text": "mockText-1",
+      "hidden": false
+    },
+    "key": "mockKey-1",
+    "maxAccessCount": 1,
+    "accessCount": 1,
+    "password": "mockPassword-1",
+    "disabled": false,
+    "revisionDate": "2023-10-27T12:00:00.00Z",
+    "expirationDate": "2023-10-27T12:00:00.00Z",
+    "deletionDate": "2023-10-27T12:00:00.00Z",
+    "hideEmail": false
+  }
+}
+"""
+
 private const val UPDATE_SEND_INVALID_JSON = """
 {
   "message": "You do not have permission to edit this.",

app/src/test/java/com/x8bit/bitwarden/data/vault/datasource/sdk/model/VaultSdkSendUtil.kt

@@ -9,7 +9,10 @@ import java.time.ZonedDateTime
 /**
  * Create a mock [Send] with a given [number].
  */
-fun createMockSdkSend(number: Int): Send =
+fun createMockSdkSend(
+    number: Int,
+    type: SendType = SendType.FILE,
+): Send =
     Send(
         id = "mockId-$number",
         accessId = "mockAccessId-$number",
@@ -17,7 +20,7 @@ fun createMockSdkSend(number: Int): Send =
         notes = "mockNotes-$number",
         key = "mockKey-$number",
         password = "mockPassword-$number",
-        type = SendType.FILE,
+        type = type,
         file = createMockSdkFile(number = number),
         text = createMockSdkText(number = number),
         maxAccessCount = 1u,

app/src/test/java/com/x8bit/bitwarden/data/vault/repository/VaultRepositoryTest.kt

@@ -1,5 +1,6 @@
 package com.x8bit.bitwarden.data.vault.repository
 
+import android.net.Uri
 import app.cash.turbine.test
 import com.bitwarden.core.CipherView
 import com.bitwarden.core.CollectionView
@@ -7,6 +8,7 @@ import com.bitwarden.core.FolderView
 import com.bitwarden.core.InitOrgCryptoRequest
 import com.bitwarden.core.InitUserCryptoMethod
 import com.bitwarden.core.InitUserCryptoRequest
+import com.bitwarden.core.SendType
 import com.bitwarden.core.SendView
 import com.bitwarden.crypto.Kdf
 import com.x8bit.bitwarden.data.auth.datasource.disk.model.AccountJson
@@ -21,6 +23,8 @@ import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFl
 import com.x8bit.bitwarden.data.platform.util.asFailure
 import com.x8bit.bitwarden.data.platform.util.asSuccess
 import com.x8bit.bitwarden.data.vault.datasource.disk.VaultDiskSource
+import com.x8bit.bitwarden.data.vault.datasource.network.model.SendFileResponseJson
+import com.x8bit.bitwarden.data.vault.datasource.network.model.SendTypeJson
 import com.x8bit.bitwarden.data.vault.datasource.network.model.SyncResponseJson
 import com.x8bit.bitwarden.data.vault.datasource.network.model.UpdateCipherResponseJson
 import com.x8bit.bitwarden.data.vault.datasource.network.model.UpdateSendResponseJson
@@ -46,6 +50,7 @@ import com.x8bit.bitwarden.data.vault.datasource.sdk.model.createMockSdkCollecti
 import com.x8bit.bitwarden.data.vault.datasource.sdk.model.createMockSdkFolder
 import com.x8bit.bitwarden.data.vault.datasource.sdk.model.createMockSdkSend
 import com.x8bit.bitwarden.data.vault.datasource.sdk.model.createMockSendView
+import com.x8bit.bitwarden.data.vault.manager.FileManager
 import com.x8bit.bitwarden.data.vault.manager.VaultLockManager
 import com.x8bit.bitwarden.data.vault.repository.model.CreateCipherResult
 import com.x8bit.bitwarden.data.vault.repository.model.CreateSendResult
@@ -68,12 +73,16 @@ import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.just
 import io.mockk.mockk
+import io.mockk.mockkStatic
 import io.mockk.runs
+import io.mockk.unmockkStatic
 import io.mockk.verify
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import java.net.UnknownHostException
 
@@ -81,6 +90,7 @@ import java.net.UnknownHostException
 class VaultRepositoryTest {
 
     private val dispatcherManager: DispatcherManager = FakeDispatcherManager()
+    private val fileManager: FileManager = mockk()
     private val fakeAuthDiskSource = FakeAuthDiskSource()
     private val syncService: SyncService = mockk()
     private val sendsService: SendsService = mockk()
@@ -112,8 +122,19 @@ class VaultRepositoryTest {
         authDiskSource = fakeAuthDiskSource,
         vaultLockManager = vaultLockManager,
         dispatcherManager = dispatcherManager,
+        fileManager = fileManager,
     )
 
+    @BeforeEach
+    fun setup() {
+        mockkStatic(Uri::class)
+    }
+
+    @AfterEach
+    fun tearDown() {
+        unmockkStatic(Uri::class)
+    }
+
     @Test
     fun `ciphersStateFlow should emit decrypted list of ciphers when decryptCipherList succeeds`() =
         runTest {
@@ -1561,51 +1582,181 @@ class VaultRepositoryTest {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
             } returns IllegalStateException().asFailure()
 
-            val result = vaultRepository.createSend(sendView = mockSendView)
+            val result = vaultRepository.createSend(sendView = mockSendView, fileUri = null)
 
             assertEquals(CreateSendResult.Error, result)
         }
 
     @Test
     @Suppress("MaxLineLength")
-    fun `createSend with sendsService createSend failure should return CreateSendResult failure`() =
+    fun `createSend with TEXT and sendsService createSend failure should return CreateSendResult failure`() =
         runTest {
             fakeAuthDiskSource.userState = MOCK_USER_STATE
             val userId = "mockId-1"
-            val mockSendView = createMockSendView(number = 1)
+            val mockSendView = createMockSendView(number = 1, type = SendType.TEXT)
             coEvery {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
-            } returns createMockSdkSend(number = 1).asSuccess()
+            } returns createMockSdkSend(number = 1, type = SendType.TEXT).asSuccess()
             coEvery {
-                sendsService.createSend(body = createMockSendJsonRequest(number = 1))
+                sendsService.createSend(
+                    body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT)
+                        .copy(fileLength = null),
+                )
             } returns IllegalStateException().asFailure()
 
-            val result = vaultRepository.createSend(sendView = mockSendView)
+            val result = vaultRepository.createSend(sendView = mockSendView, fileUri = null)
 
             assertEquals(CreateSendResult.Error, result)
         }
 
+    @Suppress("MaxLineLength")
     @Test
-    fun `createSend with sendsService createSend success should return CreateSendResult success`() =
+    fun `createSend with TEXT and sendsService createSend success should return CreateSendResult success`() =
         runTest {
             fakeAuthDiskSource.userState = MOCK_USER_STATE
             val userId = "mockId-1"
-            val mockSendView = createMockSendView(number = 1)
-            val mockSdkSend = createMockSdkSend(number = 1)
-            val mockSend = createMockSend(number = 1)
+            val mockSendView = createMockSendView(number = 1, type = SendType.TEXT)
+            val mockSdkSend = createMockSdkSend(number = 1, type = SendType.TEXT)
+            val mockSend = createMockSend(number = 1, type = SendTypeJson.TEXT)
             val mockSendViewResult = createMockSendView(number = 2)
             coEvery {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
             } returns mockSdkSend.asSuccess()
             coEvery {
-                sendsService.createSend(body = createMockSendJsonRequest(number = 1))
+                sendsService.createSend(
+                    body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT)
+                        .copy(fileLength = null),
+                )
             } returns mockSend.asSuccess()
             coEvery { vaultDiskSource.saveSend(userId, mockSend) } just runs
             coEvery {
                 vaultSdkSource.decryptSend(userId, mockSdkSend)
             } returns mockSendViewResult.asSuccess()
 
-            val result = vaultRepository.createSend(sendView = mockSendView)
+            val result = vaultRepository.createSend(sendView = mockSendView, fileUri = null)
+
+            assertEquals(CreateSendResult.Success(mockSendViewResult), result)
+        }
+
+    @Test
+    @Suppress("MaxLineLength")
+    fun `createSend with FILE and sendsService createFileSend failure should return CreateSendResult failure`() =
+        runTest {
+            fakeAuthDiskSource.userState = MOCK_USER_STATE
+            val userId = "mockId-1"
+            val uri = setupMockUri(url = "www.test.com")
+            val mockSendView = createMockSendView(number = 1)
+            val mockSdkSend = createMockSdkSend(number = 1)
+            val byteArray = byteArrayOf(1)
+            val encryptedByteArray = byteArrayOf(2)
+            coEvery {
+                vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
+            } returns mockSdkSend.asSuccess()
+            every { fileManager.uriToByteArray(any()) } returns byteArray
+            coEvery {
+                vaultSdkSource.encryptBuffer(
+                    userId = userId,
+                    send = mockSdkSend,
+                    fileBuffer = byteArray,
+                )
+            } returns encryptedByteArray.asSuccess()
+            coEvery {
+                sendsService.createFileSend(body = createMockSendJsonRequest(number = 1))
+            } returns IllegalStateException().asFailure()
+
+            val result = vaultRepository.createSend(sendView = mockSendView, fileUri = uri)
+
+            assertEquals(CreateSendResult.Error, result)
+        }
+
+    @Test
+    @Suppress("MaxLineLength")
+    fun `createSend with FILE and sendsService uploadFile failure should return CreateSendResult failure`() =
+        runTest {
+            fakeAuthDiskSource.userState = MOCK_USER_STATE
+            val userId = "mockId-1"
+            val url = "www.test.com"
+            val uri = setupMockUri(url = url)
+            val mockSendView = createMockSendView(number = 1)
+            val mockSdkSend = createMockSdkSend(number = 1)
+            val byteArray = byteArrayOf(1)
+            val encryptedByteArray = byteArrayOf(2)
+            val sendFileResponse = SendFileResponseJson(
+                url = url,
+                fileUploadType = SendFileResponseJson.FileUploadType.AZURE,
+                sendResponse = createMockSend(number = 1, type = SendTypeJson.FILE),
+            )
+            coEvery {
+                vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
+            } returns mockSdkSend.asSuccess()
+            every { fileManager.uriToByteArray(any()) } returns byteArray
+            coEvery {
+                vaultSdkSource.encryptBuffer(
+                    userId = userId,
+                    send = mockSdkSend,
+                    fileBuffer = byteArray,
+                )
+            } returns encryptedByteArray.asSuccess()
+            coEvery {
+                sendsService.createFileSend(body = createMockSendJsonRequest(number = 1))
+            } returns sendFileResponse.asSuccess()
+            coEvery {
+                sendsService.uploadFile(
+                    sendFileResponse = sendFileResponse,
+                    encryptedFile = encryptedByteArray,
+                )
+            } returns Throwable("Fail").asFailure()
+
+            val result = vaultRepository.createSend(sendView = mockSendView, fileUri = uri)
+
+            assertEquals(CreateSendResult.Error, result)
+        }
+
+    @Test
+    @Suppress("MaxLineLength")
+    fun `createSend with FILE and sendsService uploadFile success should return CreateSendResult success`() =
+        runTest {
+            fakeAuthDiskSource.userState = MOCK_USER_STATE
+            val userId = "mockId-1"
+            val url = "www.test.com"
+            val uri = setupMockUri(url = url)
+            val mockSendView = createMockSendView(number = 1)
+            val mockSdkSend = createMockSdkSend(number = 1)
+            val byteArray = byteArrayOf(1)
+            val encryptedByteArray = byteArrayOf(2)
+            val sendResponse = createMockSend(number = 1)
+            val sendFileResponse = SendFileResponseJson(
+                url = url,
+                fileUploadType = SendFileResponseJson.FileUploadType.AZURE,
+                sendResponse = sendResponse,
+            )
+            val mockSendViewResult = createMockSendView(number = 1)
+            coEvery {
+                vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
+            } returns mockSdkSend.asSuccess()
+            every { fileManager.uriToByteArray(any()) } returns byteArray
+            coEvery {
+                vaultSdkSource.encryptBuffer(
+                    userId = userId,
+                    send = mockSdkSend,
+                    fileBuffer = byteArray,
+                )
+            } returns encryptedByteArray.asSuccess()
+            coEvery {
+                sendsService.createFileSend(body = createMockSendJsonRequest(number = 1))
+            } returns sendFileResponse.asSuccess()
+            coEvery {
+                sendsService.uploadFile(
+                    sendFileResponse = sendFileResponse,
+                    encryptedFile = encryptedByteArray,
+                )
+            } returns sendResponse.asSuccess()
+            coEvery { vaultDiskSource.saveSend(userId, sendResponse) } just runs
+            coEvery {
+                vaultSdkSource.decryptSend(userId, mockSdkSend)
+            } returns mockSendViewResult.asSuccess()
+
+            val result = vaultRepository.createSend(sendView = mockSendView, fileUri = uri)
 
             assertEquals(CreateSendResult.Success(mockSendViewResult), result)
         }
@@ -1636,14 +1787,15 @@ class VaultRepositoryTest {
             fakeAuthDiskSource.userState = MOCK_USER_STATE
             val userId = "mockId-1"
             val sendId = "sendId1234"
-            val mockSendView = createMockSendView(number = 1)
+            val mockSendView = createMockSendView(number = 1, type = SendType.TEXT)
             coEvery {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
-            } returns createMockSdkSend(number = 1).asSuccess()
+            } returns createMockSdkSend(number = 1, type = SendType.TEXT).asSuccess()
             coEvery {
                 sendsService.updateSend(
                     sendId = sendId,
-                    body = createMockSendJsonRequest(number = 1),
+                    body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT)
+                        .copy(fileLength = null),
                 )
             } returns IllegalStateException().asFailure()
 
@@ -1662,14 +1814,15 @@ class VaultRepositoryTest {
             fakeAuthDiskSource.userState = MOCK_USER_STATE
             val userId = "mockId-1"
             val sendId = "sendId1234"
-            val mockSendView = createMockSendView(number = 1)
+            val mockSendView = createMockSendView(number = 1, type = SendType.TEXT)
             coEvery {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
-            } returns createMockSdkSend(number = 1).asSuccess()
+            } returns createMockSdkSend(number = 1, type = SendType.TEXT).asSuccess()
             coEvery {
                 sendsService.updateSend(
                     sendId = sendId,
-                    body = createMockSendJsonRequest(number = 1),
+                    body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT)
+                        .copy(fileLength = null),
                 )
             } returns UpdateSendResponseJson
                 .Invalid(
@@ -1698,19 +1851,22 @@ class VaultRepositoryTest {
             fakeAuthDiskSource.userState = MOCK_USER_STATE
             val userId = "mockId-1"
             val sendId = "sendId1234"
-            val mockSendView = createMockSendView(number = 1)
+            val mockSendView = createMockSendView(number = 1, type = SendType.TEXT)
             coEvery {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
-            } returns createMockSdkSend(number = 1).asSuccess()
-            val mockSend = createMockSend(number = 1)
+            } returns createMockSdkSend(number = 1, type = SendType.TEXT).asSuccess()
+            val mockSend = createMockSend(number = 1, type = SendTypeJson.TEXT)
             coEvery {
                 sendsService.updateSend(
                     sendId = sendId,
-                    body = createMockSendJsonRequest(number = 1),
+                    body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT)
+                        .copy(fileLength = null),
                 )
             } returns UpdateSendResponseJson.Success(send = mockSend).asSuccess()
             coEvery {
-                vaultSdkSource.decryptSend(userId = userId, send = createMockSdkSend(number = 1))
+                vaultSdkSource.decryptSend(
+                    userId = userId, send = createMockSdkSend(number = 1, type = SendType.TEXT),
+                )
             } returns Throwable("Fail").asFailure()
             coEvery { vaultDiskSource.saveSend(userId = userId, send = mockSend) } just runs
 
@@ -1729,20 +1885,24 @@ class VaultRepositoryTest {
             fakeAuthDiskSource.userState = MOCK_USER_STATE
             val userId = "mockId-1"
             val sendId = "sendId1234"
-            val mockSendView = createMockSendView(number = 1)
+            val mockSendView = createMockSendView(number = 1, type = SendType.TEXT)
             coEvery {
                 vaultSdkSource.encryptSend(userId = userId, sendView = mockSendView)
-            } returns createMockSdkSend(number = 1).asSuccess()
-            val mockSend = createMockSend(number = 1)
+            } returns createMockSdkSend(number = 1, type = SendType.TEXT).asSuccess()
+            val mockSend = createMockSend(number = 1, type = SendTypeJson.TEXT)
             coEvery {
                 sendsService.updateSend(
                     sendId = sendId,
-                    body = createMockSendJsonRequest(number = 1),
+                    body = createMockSendJsonRequest(number = 1, type = SendTypeJson.TEXT)
+                        .copy(fileLength = null),
                 )
             } returns UpdateSendResponseJson.Success(send = mockSend).asSuccess()
-            val mockSendViewResult = createMockSendView(number = 2)
+            val mockSendViewResult = createMockSendView(number = 2, type = SendType.TEXT)
             coEvery {
-                vaultSdkSource.decryptSend(userId = userId, send = createMockSdkSend(number = 1))
+                vaultSdkSource.decryptSend(
+                    userId = userId,
+                    send = createMockSdkSend(number = 1, type = SendType.TEXT),
+                )
             } returns mockSendViewResult.asSuccess()
             coEvery { vaultDiskSource.saveSend(userId = userId, send = mockSend) } just runs
 
@@ -1992,6 +2152,19 @@ class VaultRepositoryTest {
         }
     }
 
+    private fun setupMockUri(
+        url: String,
+        queryParams: Map<String, String> = emptyMap(),
+    ): Uri {
+        val mockUri = mockk<Uri> {
+            queryParams.forEach {
+                every { getQueryParameter(it.key) } returns it.value
+            }
+        }
+        every { Uri.parse(url) } returns mockUri
+        return mockUri
+    }
+
     //endregion Helper functions
 }
 

app/src/test/java/com/x8bit/bitwarden/data/vault/repository/util/VaultSdkSendExtensionsTest.kt

@@ -8,13 +8,22 @@ import org.junit.jupiter.api.Test
 
 class VaultSdkSendExtensionsTest {
 
+    @Suppress("MaxLineLength")
     @Test
-    fun `toEncryptedNetworkSend should convert a SDK-based Send to network-based Send`() {
+    fun `toEncryptedNetworkSend should convert a SDK-based Send to network-based Send with file length`() {
         val sdkSend = createMockSdkSend(number = 1)
-        val networkSend = sdkSend.toEncryptedNetworkSend()
+        val networkSend = sdkSend.toEncryptedNetworkSend(fileLength = 1)
         assertEquals(createMockSendJsonRequest(number = 1), networkSend)
     }
 
+    @Suppress("MaxLineLength")
+    @Test
+    fun `toEncryptedNetworkSend should convert a SDK-based Send to network-based Send without file length`() {
+        val sdkSend = createMockSdkSend(number = 1)
+        val networkSend = sdkSend.toEncryptedNetworkSend(fileLength = null)
+        assertEquals(createMockSendJsonRequest(number = 1).copy(fileLength = null), networkSend)
+    }
+
     @Test
     fun `toEncryptedSdkSend should convert a network-based Send to SDK-based Send`() {
         val syncSend = createMockSend(number = 1)

app/src/test/java/com/x8bit/bitwarden/ui/tools/feature/send/addsend/AddSendViewModelTest.kt

@@ -120,7 +120,7 @@ class AddSendViewModelTest : BaseViewModelTest() {
                 every { toSendUrl(DEFAULT_ENVIRONMENT_URL) } returns sendUrl
             }
             coEvery {
-                vaultRepository.createSend(mockSendView)
+                vaultRepository.createSend(sendView = mockSendView, fileUri = null)
             } returns CreateSendResult.Success(sendView = resultSendView)
             val viewModel = createViewModel(initialState)
 
@@ -131,7 +131,7 @@ class AddSendViewModelTest : BaseViewModelTest() {
             }
             assertEquals(initialState, viewModel.stateFlow.value)
             coVerify(exactly = 1) {
-                vaultRepository.createSend(mockSendView)
+                vaultRepository.createSend(sendView = mockSendView, fileUri = null)
             }
         }
 
@@ -143,7 +143,9 @@ class AddSendViewModelTest : BaseViewModelTest() {
         val initialState = DEFAULT_STATE.copy(viewState = viewState)
         val mockSendView = mockk<SendView>()
         every { viewState.toSendView(clock) } returns mockSendView
-        coEvery { vaultRepository.createSend(mockSendView) } returns CreateSendResult.Error
+        coEvery {
+            vaultRepository.createSend(sendView = mockSendView, fileUri = null)
+        } returns CreateSendResult.Error
         val viewModel = createViewModel(initialState)
 
         viewModel.stateFlow.test {
@@ -168,7 +170,7 @@ class AddSendViewModelTest : BaseViewModelTest() {
             )
         }
         coVerify(exactly = 1) {
-            vaultRepository.createSend(mockSendView)
+            vaultRepository.createSend(sendView = mockSendView, fileUri = null)
         }
     }