diff --git a/src/App/Pages/Send/SendAddEditPage.xaml b/src/App/Pages/Send/SendAddEditPage.xaml
index 1ff2b8f77..963312d6b 100644
--- a/src/App/Pages/Send/SendAddEditPage.xaml
+++ b/src/App/Pages/Send/SendAddEditPage.xaml
@@ -215,7 +215,7 @@
Clicked="ChooseFile_Clicked" />
@@ -513,4 +513,4 @@
-
\ No newline at end of file
+
diff --git a/src/App/Pages/Send/SendAddEditPageViewModel.cs b/src/App/Pages/Send/SendAddEditPageViewModel.cs
index b729d29ce..e3624779e 100644
--- a/src/App/Pages/Send/SendAddEditPageViewModel.cs
+++ b/src/App/Pages/Send/SendAddEditPageViewModel.cs
@@ -327,7 +327,7 @@ namespace Bit.App.Pages
AppResources.AnErrorHasOccurred);
return false;
}
- if (FileData.Length > 104857600) // 100 MB
+ if (FileData.Length > 524288000) // 500 MB
{
await _platformUtilsService.ShowDialogAsync(AppResources.MaxFileSize,
AppResources.AnErrorHasOccurred);
diff --git a/src/App/Resources/AppResources.resx b/src/App/Resources/AppResources.resx
index 326fa92c1..806ab4c2f 100644
--- a/src/App/Resources/AppResources.resx
+++ b/src/App/Resources/AppResources.resx
@@ -927,6 +927,9 @@
Maximum file size is 100 MB.
+
+
+ Maximum file size is 500 MB.
You cannot use this feature until you update your encryption key.
diff --git a/src/Core/Abstractions/IApiService.cs b/src/Core/Abstractions/IApiService.cs
index 0f79493bd..4edeba2fd 100644
--- a/src/Core/Abstractions/IApiService.cs
+++ b/src/Core/Abstractions/IApiService.cs
@@ -56,7 +56,11 @@ namespace Bit.Core.Abstractions
Task GetSendAsync(string id);
Task PostSendAsync(SendRequest request);
+ Task PostFileTypeSendAsync(SendRequest request);
+ Task PostSendFileAsync(string sendId, string fileId, MultipartFormDataContent data);
+ [Obsolete("Mar 25 2021: This method has been deprecated in favor of direct uploads. This method still exists for backward compatibility with old server versions.")]
Task PostSendFileAsync(MultipartFormDataContent data);
+ Task RenewFileUploadUrlAsync(string sendId, string fileId);
Task PutSendAsync(string id, SendRequest request);
Task PutSendRemovePasswordAsync(string id);
Task DeleteSendAsync(string id);
diff --git a/src/Core/Abstractions/IAzureFileUpoadService.cs b/src/Core/Abstractions/IAzureFileUpoadService.cs
new file mode 100644
index 000000000..fe38ffb4f
--- /dev/null
+++ b/src/Core/Abstractions/IAzureFileUpoadService.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Bit.Core.Abstractions
+{
+ public interface IAzureFileUploadService
+ {
+ Task Upload(string uri, byte[] data, Func> renewalCallback);
+ }
+}
diff --git a/src/Core/Abstractions/IFileUploadService.cs b/src/Core/Abstractions/IFileUploadService.cs
new file mode 100644
index 000000000..b0da4e170
--- /dev/null
+++ b/src/Core/Abstractions/IFileUploadService.cs
@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+using Bit.Core.Models.Domain;
+using Bit.Core.Models.Response;
+
+namespace Bit.Core.Abstractions {
+ public interface IFileUploadService {
+ Task UploadSendFileAsync(SendFileUploadDataResponse uploadData, CipherString fileName, byte[] encryptedFileData);
+ }
+}
diff --git a/src/Core/Enums/FileUploadType.cs b/src/Core/Enums/FileUploadType.cs
new file mode 100644
index 000000000..8aeb51072
--- /dev/null
+++ b/src/Core/Enums/FileUploadType.cs
@@ -0,0 +1,9 @@
+using System;
+namespace Bit.Core.Enums
+{
+ public enum FileUploadType
+ {
+ Direct = 0,
+ Azure = 1,
+ }
+}
diff --git a/src/Core/Models/Response/SendFileUploadDataResponse.cs b/src/Core/Models/Response/SendFileUploadDataResponse.cs
new file mode 100644
index 000000000..8ea79ae0e
--- /dev/null
+++ b/src/Core/Models/Response/SendFileUploadDataResponse.cs
@@ -0,0 +1,12 @@
+using System;
+using Bit.Core.Enums;
+
+namespace Bit.Core.Models.Response
+{
+ public class SendFileUploadDataResponse
+ {
+ public string Url { get; set; }
+ public FileUploadType FileUploadType { get; set; }
+ public SendResponse SendResponse { get; set; }
+ }
+}
diff --git a/src/Core/Services/ApiService.cs b/src/Core/Services/ApiService.cs
index 8f5245593..f0ea50bbd 100644
--- a/src/Core/Services/ApiService.cs
+++ b/src/Core/Services/ApiService.cs
@@ -223,9 +223,19 @@ namespace Bit.Core.Services
public Task PostSendAsync(SendRequest request) =>
SendAsync(HttpMethod.Post, "/sends", request, true, true);
+ public Task PostFileTypeSendAsync(SendRequest request) =>
+ SendAsync(HttpMethod.Post, "/sends/file/v2", request, true, true);
+
+ public Task PostSendFileAsync(string sendId, string fileId, MultipartFormDataContent data) =>
+ SendAsync(HttpMethod.Post, $"/sends/{sendId}/file/{fileId}", data, true, false);
+
+ [Obsolete("Mar 25 2021: This method has been deprecated in favor of direct uploads. This method still exists for backward compatibility with old server versions.")]
public Task PostSendFileAsync(MultipartFormDataContent data) =>
SendAsync(HttpMethod.Post, "/sends/file", data, true, true);
+ public Task RenewFileUploadUrlAsync(string sendId, string fileId) =>
+ SendAsync(HttpMethod.Get, $"/sends/{sendId}/file/{fileId}", null, true, true);
+
public Task PutSendAsync(string id, SendRequest request) =>
SendAsync(HttpMethod.Put, $"/sends/{id}", request, true, true);
diff --git a/src/Core/Services/AzureFileUploadService.cs b/src/Core/Services/AzureFileUploadService.cs
new file mode 100644
index 000000000..5b77de31f
--- /dev/null
+++ b/src/Core/Services/AzureFileUploadService.cs
@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+using Bit.Core.Abstractions;
+using Bit.Core.Utilities;
+
+namespace Bit.Core.Services
+{
+ public class AzureFileUploadService : IAzureFileUploadService
+ {
+ private const long MAX_SINGLE_BLOB_UPLOAD_SIZE = 256 * 1024 * 1024; // 256 MiB
+ private const int MAX_BLOCKS_PER_BLOB = 50000;
+ private const decimal MAX_MOBILE_BLOCK_SIZE = 5 * 1024 * 1024; // 5 MB
+
+ private readonly HttpClient _httpClient = new HttpClient();
+
+ public AzureFileUploadService()
+ {
+ _httpClient.DefaultRequestHeaders.CacheControl = new CacheControlHeaderValue()
+ {
+ NoCache = true,
+ };
+ }
+
+ public async Task Upload(string uri, byte[] data, Func> renewalCallback)
+ {
+ if (data.Length <= MAX_SINGLE_BLOB_UPLOAD_SIZE)
+ {
+ await AzureUploadBlob(uri, data);
+ }
+ else
+ {
+ await AzureUploadBlocks(uri, data, renewalCallback);
+ }
+ }
+
+ private async Task AzureUploadBlob(string uri, byte[] data)
+ {
+ using (var requestMessage = new HttpRequestMessage())
+ {
+ var uriBuilder = new UriBuilder(uri);
+ var paramValues = HttpUtility.ParseQueryString(uriBuilder.Query);
+
+ requestMessage.Headers.Add("x-ms-date", DateTime.UtcNow.ToString("R"));
+ requestMessage.Headers.Add("x-ms-version", paramValues["sv"]);
+ requestMessage.Headers.Add("x-ms-blob-type", "BlockBlob");
+
+ requestMessage.Content = new ByteArrayContent(data);
+ requestMessage.Version = new Version(1, 0);
+ requestMessage.Method = HttpMethod.Put;
+ requestMessage.RequestUri = uriBuilder.Uri;
+
+ var blobResponse = await _httpClient.SendAsync(requestMessage);
+
+ if (blobResponse.StatusCode != HttpStatusCode.Created)
+ {
+ throw new Exception("Failed to create Azure blob");
+ }
+ }
+ }
+
+ private async Task AzureUploadBlocks(string uri, byte[] data, Func> renewalFunc)
+ {
+ _httpClient.Timeout = TimeSpan.FromHours(3);
+ var baseParams = HttpUtility.ParseQueryString(CoreHelpers.GetUri(uri).Query);
+ var blockSize = MaxBlockSize(baseParams["sv"]);
+ var blockIndex = 0;
+ var numBlocks = Math.Ceiling((decimal)data.Length / blockSize);
+ var blocksStaged = new List();
+
+ if (numBlocks > MAX_BLOCKS_PER_BLOB)
+ {
+ throw new Exception($"Cannot upload file, exceeds maximum size of {blockSize * MAX_BLOCKS_PER_BLOB}");
+ }
+
+ while (blockIndex < numBlocks)
+ {
+ uri = await RenewUriIfNecessary(uri, renewalFunc);
+ var blockUriBuilder = new UriBuilder(uri);
+ var blockId = EncodeBlockId(blockIndex);
+ var blockParams = HttpUtility.ParseQueryString(blockUriBuilder.Query);
+ blockParams.Add("comp", "block");
+ blockParams.Add("blockid", blockId);
+ blockUriBuilder.Query = blockParams.ToString();
+
+ using (var requestMessage = new HttpRequestMessage())
+ {
+ requestMessage.Headers.Add("x-ms-date", DateTime.UtcNow.ToString("R"));
+ requestMessage.Headers.Add("x-ms-version", baseParams["sv"]);
+ requestMessage.Headers.Add("x-ms-blob-type", "BlockBlob");
+
+ requestMessage.Content = new ByteArrayContent(data.Skip(blockIndex * blockSize).Take(blockSize).ToArray());
+ requestMessage.Version = new Version(1, 0);
+ requestMessage.Method = HttpMethod.Put;
+ requestMessage.RequestUri = blockUriBuilder.Uri;
+
+ var blockResponse = await _httpClient.SendAsync(requestMessage);
+
+ if (blockResponse.StatusCode != HttpStatusCode.Created)
+ {
+ throw new Exception("Failed to create Azure block");
+ }
+ }
+
+ blocksStaged.Add(blockId);
+ blockIndex++;
+ }
+
+ using (var requestMessage = new HttpRequestMessage())
+ {
+ uri = await RenewUriIfNecessary(uri, renewalFunc);
+ var blockListXml = GenerateBlockListXml(blocksStaged);
+ var blockListUriBuilder = new UriBuilder(uri);
+ var blockListParams = HttpUtility.ParseQueryString(blockListUriBuilder.Query);
+ blockListParams.Add("comp", "blocklist");
+ blockListUriBuilder.Query = blockListParams.ToString();
+
+ requestMessage.Headers.Add("x-ms-date", DateTime.UtcNow.ToString("R"));
+ requestMessage.Headers.Add("x-ms-version", baseParams["sv"]);
+
+ requestMessage.Content = new StringContent(blockListXml);
+ requestMessage.Version = new Version(1, 0);
+ requestMessage.Method = HttpMethod.Put;
+ requestMessage.RequestUri = blockListUriBuilder.Uri;
+
+ var blockListResponse = await _httpClient.SendAsync(requestMessage);
+
+ if (blockListResponse.StatusCode != HttpStatusCode.Created)
+ {
+ throw new Exception("Failed to PUT Azure block list");
+ }
+ }
+ }
+
+ private async Task RenewUriIfNecessary(string uri, Func> renewalFunc)
+ {
+ var uriParams = HttpUtility.ParseQueryString(CoreHelpers.GetUri(uri).Query);
+
+ if (DateTime.TryParse(uriParams.Get("se") ?? "", out DateTime expiry) && expiry < DateTime.UtcNow.AddSeconds(1))
+ {
+ return await renewalFunc();
+ }
+ return uri;
+ }
+
+ private string GenerateBlockListXml(List blocksStaged)
+ {
+ var xml = new StringBuilder("");
+ foreach(var blockId in blocksStaged)
+ {
+ xml.Append($"{blockId}");
+ }
+ xml.Append("");
+ return xml.ToString();
+ }
+
+ private string EncodeBlockId(int index)
+ {
+ // Encoded blockId max size is 64, so pre-encoding max size is 48
+ var paddedString = index.ToString("D48");
+ return Convert.ToBase64String(Encoding.UTF8.GetBytes(paddedString));
+ }
+
+ private int MaxBlockSize(string version)
+ {
+ long maxSize = 4194304L; // 4 MiB
+ if (CompareAzureVersions(version, "2019-12-12") >= 0)
+ {
+ maxSize = 4194304000L; // 4000 MiB
+ }
+ else if (CompareAzureVersions(version, "2016-05-31") >= 0)
+ {
+ maxSize = 104857600L; // 100 MiB
+ }
+
+ return maxSize > MAX_MOBILE_BLOCK_SIZE ? (int)MAX_MOBILE_BLOCK_SIZE : (int) maxSize;
+ }
+
+ private int CompareAzureVersions(string a, string b)
+ {
+ var v1Parts = a.Split('-').Select(p => int.Parse(p));
+ var v2Parts = b.Split('-').Select(p => int.Parse(p));
+
+ return a[0] != b[0] ? a[0] - b[0] :
+ a[1] != b[1] ? a[1] - b[1] :
+ a[2] != b[2] ? a[2] - b[2] :
+ 0;
+ }
+ }
+}
diff --git a/src/Core/Services/BitwardenFileUploadService.cs b/src/Core/Services/BitwardenFileUploadService.cs
new file mode 100644
index 000000000..372cd4a9f
--- /dev/null
+++ b/src/Core/Services/BitwardenFileUploadService.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace Bit.Core.Services
+{
+ public class BitwardenFileUploadService
+ {
+ public BitwardenFileUploadService(ApiService apiService)
+ {
+ _apiService = apiService;
+ }
+
+ private readonly ApiService _apiService;
+
+ public async Task Upload(string encryptedFileName, byte[] encryptedFileData, Func apiCall)
+ {
+ var fd = new MultipartFormDataContent($"--BWMobileFormBoundary{DateTime.UtcNow.Ticks}")
+ {
+ { new ByteArrayContent(encryptedFileData), "data", encryptedFileName }
+ };
+
+ await apiCall(fd);
+ }
+ }
+}
diff --git a/src/Core/Services/FileUploadService.cs b/src/Core/Services/FileUploadService.cs
new file mode 100644
index 000000000..03539f8aa
--- /dev/null
+++ b/src/Core/Services/FileUploadService.cs
@@ -0,0 +1,51 @@
+using System.Threading.Tasks;
+using Bit.Core.Abstractions;
+using Bit.Core.Models.Domain;
+using Bit.Core.Models.Response;
+using Bit.Core.Enums;
+using System;
+
+namespace Bit.Core.Services {
+ public class FileUploadService : IFileUploadService
+ {
+ public FileUploadService(ApiService apiService)
+ {
+ _apiService = apiService;
+ _bitwardenFileUploadService = new BitwardenFileUploadService(apiService);
+ _azureFileUploadService = new AzureFileUploadService();
+ }
+
+ private readonly BitwardenFileUploadService _bitwardenFileUploadService;
+ private readonly AzureFileUploadService _azureFileUploadService;
+ private readonly ApiService _apiService;
+
+ public async Task UploadSendFileAsync(SendFileUploadDataResponse uploadData, CipherString fileName, byte[] encryptedFileData)
+ {
+ try
+ {
+ switch (uploadData.FileUploadType)
+ {
+ case FileUploadType.Direct:
+ await _bitwardenFileUploadService.Upload(fileName.EncryptedString, encryptedFileData,
+ fd => _apiService.PostSendFileAsync(uploadData.SendResponse.Id, uploadData.SendResponse.File.Id, fd));
+ break;
+ case FileUploadType.Azure:
+ Func> renewalCallback = async () =>
+ {
+ var response = await _apiService.RenewFileUploadUrlAsync(uploadData.SendResponse.Id, uploadData.SendResponse.File.Id);
+ return response.Url;
+ };
+ await _azureFileUploadService.Upload(uploadData.Url, encryptedFileData, renewalCallback);
+ break;
+ default:
+ throw new Exception("Unknown file upload type");
+ }
+ }
+ catch (Exception e)
+ {
+ await _apiService.DeleteSendAsync(uploadData.SendResponse.Id);
+ throw e;
+ }
+ }
+ }
+}
diff --git a/src/Core/Services/SendService.cs b/src/Core/Services/SendService.cs
index af9c586f3..ee5a3b405 100644
--- a/src/Core/Services/SendService.cs
+++ b/src/Core/Services/SendService.cs
@@ -1,11 +1,12 @@
using System;
using System.Collections.Generic;
-using System.IO;
using System.Linq;
+using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Bit.Core.Abstractions;
using Bit.Core.Enums;
+using Bit.Core.Exceptions;
using Bit.Core.Models.Data;
using Bit.Core.Models.Domain;
using Bit.Core.Models.Request;
@@ -25,11 +26,13 @@ namespace Bit.Core.Services
private readonly II18nService _i18nService;
private readonly ICryptoFunctionService _cryptoFunctionService;
private Task> _getAllDecryptedTask;
+ private readonly IFileUploadService _fileUploadService;
public SendService(
ICryptoService cryptoService,
IUserService userService,
IApiService apiService,
+ IFileUploadService fileUploadService,
IStorageService storageService,
II18nService i18nService,
ICryptoFunctionService cryptoFunctionService)
@@ -37,6 +40,7 @@ namespace Bit.Core.Services
_cryptoService = cryptoService;
_userService = userService;
_apiService = apiService;
+ _fileUploadService = fileUploadService;
_storageService = storageService;
_i18nService = i18nService;
_cryptoFunctionService = cryptoFunctionService;
@@ -195,7 +199,7 @@ namespace Bit.Core.Services
public async Task SaveWithServerAsync(Send send, byte[] encryptedFileData)
{
var request = new SendRequest(send, encryptedFileData?.LongLength);
- SendResponse response;
+ SendResponse response = default;
if (send.Id == null)
{
switch (send.Type)
@@ -204,13 +208,23 @@ namespace Bit.Core.Services
response = await _apiService.PostSendAsync(request);
break;
case SendType.File:
- var fd = new MultipartFormDataContent($"--BWMobileFormBoundary{DateTime.UtcNow.Ticks}")
- {
- { new StringContent(JsonConvert.SerializeObject(request)), "model" },
- { new ByteArrayContent(encryptedFileData), "data", send.File.FileName.EncryptedString }
- };
+ try{
+ var uploadDataResponse = await _apiService.PostFileTypeSendAsync(request);
+ response = uploadDataResponse.SendResponse;
- response = await _apiService.PostSendFileAsync(fd);
+ await _fileUploadService.UploadSendFileAsync(uploadDataResponse, send.File.FileName, encryptedFileData);
+ }
+ catch (ApiException e) when (e.Error.StatusCode == HttpStatusCode.NotFound)
+ {
+ response = await LegacyServerSendFileUpload(request, send, encryptedFileData);
+ }
+ catch (Exception e)
+ {
+ if (response != default){
+ await _apiService.DeleteSendAsync(response.Id);
+ }
+ throw e;
+ }
break;
default:
throw new NotImplementedException($"Cannot save unknown Send type {send.Type}");
@@ -227,6 +241,17 @@ namespace Bit.Core.Services
return response.Id;
}
+ [Obsolete("Mar 25 2021: This method has been deprecated in favor of direct uploads. This method still exists for backward compatibility with old server versions.")]
+ private async Task LegacyServerSendFileUpload(SendRequest request, Send send, byte[] encryptedFileData) {
+ var fd = new MultipartFormDataContent($"--BWMobileFormBoundary{DateTime.UtcNow.Ticks}")
+ {
+ { new StringContent(JsonConvert.SerializeObject(request)), "model" },
+ { new ByteArrayContent(encryptedFileData), "data", send.File.FileName.EncryptedString }
+ };
+
+ return await _apiService.PostSendFileAsync(fd);
+ }
+
public async Task UpsertAsync(params SendData[] sends)
{
var userId = await _userService.GetUserIdAsync();
diff --git a/src/Core/Utilities/CoreHelpers.cs b/src/Core/Utilities/CoreHelpers.cs
index 0799906bb..e229a5969 100644
--- a/src/Core/Utilities/CoreHelpers.cs
+++ b/src/Core/Utilities/CoreHelpers.cs
@@ -80,7 +80,7 @@ namespace Bit.Core.Utilities
return null;
}
- private static Uri GetUri(string uriString)
+ public static Uri GetUri(string uriString)
{
if (string.IsNullOrWhiteSpace(uriString))
{
diff --git a/src/Core/Utilities/ServiceContainer.cs b/src/Core/Utilities/ServiceContainer.cs
index 0ae61b84a..ec5a9c578 100644
--- a/src/Core/Utilities/ServiceContainer.cs
+++ b/src/Core/Utilities/ServiceContainer.cs
@@ -40,13 +40,14 @@ namespace Bit.Core.Utilities
var appIdService = new AppIdService(storageService);
var userService = new UserService(storageService, tokenService);
var settingsService = new SettingsService(userService, storageService);
+ var fileUploadService = new FileUploadService(apiService);
var cipherService = new CipherService(cryptoService, userService, settingsService, apiService,
storageService, i18nService, () => searchService, clearCipherCacheKey, allClearCipherCacheKeys);
var folderService = new FolderService(cryptoService, userService, apiService, storageService,
i18nService, cipherService);
var collectionService = new CollectionService(cryptoService, userService, storageService, i18nService);
- var sendService = new SendService(cryptoService, userService, apiService, storageService, i18nService,
- cryptoFunctionService);
+ var sendService = new SendService(cryptoService, userService, apiService, fileUploadService, storageService,
+ i18nService, cryptoFunctionService);
searchService = new SearchService(cipherService, sendService);
var vaultTimeoutService = new VaultTimeoutService(cryptoService, userService, platformUtilsService,
storageService, folderService, cipherService, collectionService, searchService, messagingService, tokenService,
diff --git a/test/Core.Test/Services/SendServiceTests.cs b/test/Core.Test/Services/SendServiceTests.cs
index 9df3d814f..fcdfc9ed7 100644
--- a/test/Core.Test/Services/SendServiceTests.cs
+++ b/test/Core.Test/Services/SendServiceTests.cs
@@ -21,6 +21,8 @@ using Bit.Core.Models.Request;
using Bit.Core.Test.AutoFixture;
using System.Linq.Expressions;
using Bit.Core.Models.View;
+using Bit.Core.Exceptions;
+using NSubstitute.ExceptionExtensions;
namespace Bit.Core.Test.Services
{
@@ -172,7 +174,6 @@ namespace Bit.Core.Test.Services
send.Id = null;
sutProvider.GetDependency().GetUserIdAsync().Returns(userId);
sutProvider.GetDependency().PostSendAsync(Arg.Any()).Returns(response);
- sutProvider.GetDependency().PostSendFileAsync(Arg.Any()).Returns(response);
var fileContentBytes = Encoding.UTF8.GetBytes("This is the file content");
@@ -200,40 +201,43 @@ namespace Bit.Core.Test.Services
[Theory]
[InlineCustomAutoData(new[] { typeof(SutProviderCustomization), typeof(FileSendCustomization) })]
- public async Task SaveWithServerAsync_NewFileSend_Success(SutProvider sutProvider, string userId, SendResponse response, Send send)
+ public async Task SaveWithServerAsync_NewFileSend_AzureUpload_Success(SutProvider sutProvider, string userId, SendFileUploadDataResponse response, Send send)
+ {
+ send.Id = null;
+ response.FileUploadType = FileUploadType.Azure;
+ sutProvider.GetDependency().GetUserIdAsync().Returns(userId);
+ sutProvider.GetDependency().PostFileTypeSendAsync(Arg.Any()).Returns(response);
+
+ var fileContentBytes = Encoding.UTF8.GetBytes("This is the file content");
+
+ await sutProvider.Sut.SaveWithServerAsync(send, fileContentBytes);
+
+ switch (send.Type)
+ {
+ case SendType.File:
+ await sutProvider.GetDependency().Received(1).UploadSendFileAsync(response, send.File.FileName, fileContentBytes);
+ break;
+ case SendType.Text:
+ default:
+ throw new Exception("Untested send type");
+ }
+ }
+
+ [Theory]
+ [InlineCustomAutoData(new[] { typeof(SutProviderCustomization), typeof(FileSendCustomization) })]
+ public async Task SaveWithServerAsync_NewFileSend_LegacyFallback_Success(SutProvider sutProvider, string userId, Send send, SendResponse response)
{
send.Id = null;
sutProvider.GetDependency().GetUserIdAsync().Returns(userId);
- sutProvider.GetDependency().PostSendAsync(Arg.Any()).Returns(response);
+ var error = new ErrorResponse(null, System.Net.HttpStatusCode.NotFound);
+ sutProvider.GetDependency().PostFileTypeSendAsync(Arg.Any()).Throws(new ApiException(error));
sutProvider.GetDependency().PostSendFileAsync(Arg.Any()).Returns(response);
var fileContentBytes = Encoding.UTF8.GetBytes("This is the file content");
await sutProvider.Sut.SaveWithServerAsync(send, fileContentBytes);
- Predicate formDataPredicate = fd =>
- {
- Assert.Equal(2, fd.Count()); // expect a request and file content
-
- var expectedRequest = JsonConvert.SerializeObject(new SendRequest(send, fileContentBytes?.LongLength));
- var actualRequest = fd.First().ReadAsStringAsync().GetAwaiter().GetResult();
- Assert.Equal(expectedRequest, actualRequest);
-
- var actualFileContent = fd.Skip(1).First().ReadAsByteArrayAsync().GetAwaiter().GetResult();
- Assert.Equal(fileContentBytes, actualFileContent);
- return true;
- };
-
- switch (send.Type)
- {
- case SendType.File:
- await sutProvider.GetDependency().Received(1)
- .PostSendFileAsync(Arg.Is(f => formDataPredicate(f)));
- break;
- case SendType.Text:
- default:
- throw new Exception("Untested send type");
- }
+ await sutProvider.GetDependency().Received(1).PostSendFileAsync(Arg.Any());
}
[Theory]