public async Task Needs2FABecauseNewDeviceAsync_ReturnsTrue(SutProvider <UserService> sutProvider, User user) { user.Id = Guid.NewGuid(); user.EmailVerified = true; const string deviceIdToCheck = "7b01b586-b210-499f-8d52-0c3fdaa646fc"; const string deviceIdInRepo = "ea29126c-91b7-4cc4-8ce6-00105b37f64a"; sutProvider.GetDependency <IDeviceRepository>() .GetManyByUserIdAsync(user.Id) .Returns(Task.FromResult <ICollection <Device> >(new List <Device> { new Device { Identifier = deviceIdInRepo } })); Assert.True(await sutProvider.Sut.Needs2FABecauseNewDeviceAsync(user, deviceIdToCheck, "password")); }
public async Task DeleteWithServerAsync_Success(SutProvider <SendService> sutProvider, string userId, IEnumerable <SendData> sendDatas) { var initialSendDatas = sendDatas.ToDictionary(d => d.Id, d => d); var idToDelete = initialSendDatas.First().Key; var expectedSends = initialSendDatas.Skip(1).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); sutProvider.GetDependency <IUserService>().GetUserIdAsync().Returns(userId); sutProvider.GetDependency <IStorageService>() .GetAsync <Dictionary <string, SendData> >(Arg.Any <string>()).Returns(initialSendDatas); await sutProvider.Sut.DeleteWithServerAsync(idToDelete); await sutProvider.GetDependency <IApiService>().Received(1).DeleteSendAsync(idToDelete); await sutProvider.GetDependency <IStorageService>().Received(1) .SaveAsync(GetSendKey(userId), Arg.Is <Dictionary <string, SendData> >(s => TestHelper.AssertEqualExpectedPredicate(expectedSends)(s))); }
// SendOptionsPolicy.DisableHideEmail check private void SaveSendAsync_DisableHideEmail_Setup(SendType sendType, bool canManagePolicies, SutProvider <SendService> sutProvider, Send send, List <Policy> policies) { send.Id = default; send.Type = sendType; send.HideEmail = true; var dataObj = new SendOptionsPolicyData(); dataObj.DisableHideEmail = true; policies.First().Type = PolicyType.SendOptions; policies.First().Enabled = true; policies.First().Data = JsonConvert.SerializeObject(dataObj); sutProvider.GetDependency <IPolicyRepository>().GetManyByUserIdAsync(send.UserId.Value).Returns(policies); sutProvider.GetDependency <ICurrentContext>().ManagePolicies(Arg.Any <Guid>()).Returns(canManagePolicies); }
public async Task DeleteAsync_Success(int numberToDelete, SutProvider <SendService> sutProvider, string userId, IEnumerable <SendData> sendDatas) { var actualSendDataDict = sendDatas.ToDictionary(d => d.Id, d => d); sutProvider.GetDependency <IUserService>().GetUserIdAsync().Returns(userId); sutProvider.GetDependency <IStorageService>() .GetAsync <Dictionary <string, SendData> >(GetSendKey(userId)).Returns(actualSendDataDict); var idsToDelete = actualSendDataDict.Take(numberToDelete).Select(kvp => kvp.Key).ToArray(); var expectedSends = actualSendDataDict.Skip(numberToDelete).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); await sutProvider.Sut.DeleteAsync(idsToDelete); await sutProvider.GetDependency <IStorageService>().Received(1) .SaveAsync(GetSendKey(userId), Arg.Is <Dictionary <string, SendData> >(s => TestHelper.AssertEqualExpectedPredicate(expectedSends)(s))); }
public async Task SaveWithServerAsync_PrefersFileUploadService(SutProvider <CipherService> sutProvider, Cipher cipher, string fileName, EncByteArray data, AttachmentUploadDataResponse uploadDataResponse, EncString encKey) { var encFileName = new EncString(fileName); sutProvider.GetDependency <ICryptoService>().EncryptAsync(fileName, Arg.Any <SymmetricCryptoKey>()) .Returns(encFileName); sutProvider.GetDependency <ICryptoService>().EncryptToBytesAsync(data.Buffer, Arg.Any <SymmetricCryptoKey>()) .Returns(data); sutProvider.GetDependency <ICryptoService>().MakeEncKeyAsync(Arg.Any <SymmetricCryptoKey>()).Returns(new Tuple <SymmetricCryptoKey, EncString>(null, encKey)); sutProvider.GetDependency <IApiService>().PostCipherAttachmentAsync(cipher.Id, Arg.Any <AttachmentRequest>()) .Returns(uploadDataResponse); await sutProvider.Sut.SaveAttachmentRawWithServerAsync(cipher, fileName, data.Buffer); await sutProvider.GetDependency <IFileUploadService>().Received(1) .UploadCipherAttachmentFileAsync(uploadDataResponse, encFileName, data); }
public async void SaveSendAsync_ExistingSend_Updates(SutProvider <SendService> sutProvider, Send send) { send.Id = Guid.NewGuid(); var now = DateTime.UtcNow; await sutProvider.Sut.SaveSendAsync(send); Assert.True(send.RevisionDate - now < TimeSpan.FromSeconds(1)); await sutProvider.GetDependency <ISendRepository>() .Received(1) .UpsertAsync(send); await sutProvider.GetDependency <IPushNotificationService>() .Received(1) .PushSyncSendUpdateAsync(send); }
public async Task ShareManyAsync_CorrectRevisionDate_Passes(string revisionDateString, SutProvider <CipherService> sutProvider, IEnumerable <Cipher> ciphers, Organization organization, List <Guid> collectionIds) { sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organization.Id) .Returns(new Organization { PlanType = Enums.PlanType.EnterpriseAnnually, MaxStorageGb = 100 }); var cipherInfos = ciphers.Select(c => (c, string.IsNullOrEmpty(revisionDateString) ? null : (DateTime?)c.RevisionDate)); var sharingUserId = ciphers.First().UserId.Value; await sutProvider.Sut.ShareManyAsync(cipherInfos, organization.Id, collectionIds, sharingUserId); await sutProvider.GetDependency <ICipherRepository>().Received(1).UpdateCiphersAsync(sharingUserId, Arg.Is <IEnumerable <Cipher> >(arg => arg.Except(ciphers).IsNullOrEmpty())); }
public async Task ShareManyAsync_FreeOrgWithAttachment_Throws(SutProvider <CipherService> sutProvider, IEnumerable <Cipher> ciphers, Guid organizationId, List <Guid> collectionIds) { sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organizationId).Returns(new Organization { PlanType = Enums.PlanType.Free }); ciphers.FirstOrDefault().Attachments = "{\"attachment1\":{\"Size\":\"250\",\"FileName\":\"superCoolFile\"," + "\"Key\":\"superCoolFile\",\"ContainerName\":\"testContainer\",\"Validated\":false}}"; var cipherInfos = ciphers.Select(c => (c, (DateTime?)c.RevisionDate)); var sharingUserId = ciphers.First().UserId.Value; var exception = await Assert.ThrowsAsync <BadRequestException>( () => sutProvider.Sut.ShareManyAsync(cipherInfos, organizationId, collectionIds, sharingUserId)); Assert.Contains("This organization cannot use attachments", exception.Message); }
public async void UpdateFileToExistingSendAsync_Success(SutProvider <SendService> sutProvider, Send send) { var fileContents = "Test file content"; var sendFileData = new SendFileData { Id = "TEST", Size = fileContents.Length, }; send.Type = SendType.File; send.Data = JsonConvert.SerializeObject(sendFileData); sutProvider.GetDependency <ISendFileStorageService>() .ValidateFileAsync(send, sendFileData.Id, sendFileData.Size, Arg.Any <long>()) .Returns((true, sendFileData.Size)); await sutProvider.Sut.UploadFileToExistingSendAsync(new MemoryStream(Encoding.UTF8.GetBytes(fileContents)), send); }
public async Task ValidateSponsorshipAsync_Valid(PlanType planType, Organization sponsoredOrg, OrganizationSponsorship existingSponsorship, Organization sponsoringOrg, SutProvider <ValidateSponsorshipCommand> sutProvider) { sponsoringOrg.PlanType = planType; sponsoringOrg.Enabled = true; existingSponsorship.SponsoringOrganizationId = sponsoringOrg.Id; sutProvider.GetDependency <IOrganizationSponsorshipRepository>() .GetBySponsoredOrganizationIdAsync(sponsoredOrg.Id).Returns(existingSponsorship); sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(sponsoredOrg.Id).Returns(sponsoredOrg); sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(sponsoringOrg.Id).Returns(sponsoringOrg); var result = await sutProvider.Sut.ValidateSponsorshipAsync(sponsoredOrg.Id); Assert.True(result); await AssertDidNotRemoveSponsoredPaymentAsync(sutProvider); await AssertDidNotDeleteSponsorshipAsync(sutProvider); }
public async void SaveSendAsync_DisableHideEmail_CantManagePolicies_success(SendType sendType, SutProvider <SendService> sutProvider, Send send, List <Policy> policies) { SaveSendAsync_DisableHideEmail_Setup(sendType, canManagePolicies: false, sutProvider, send, policies); var policyData = new SendOptionsPolicyData(); policyData.DisableHideEmail = false; var policyDataSerialized = JsonConvert.SerializeObject(policyData); foreach (var policy in policies.Where(p => p.Type == PolicyType.SendOptions)) { policies.First().Enabled = true; policies.First().Data = policyDataSerialized; } await sutProvider.Sut.SaveSendAsync(send); await sutProvider.GetDependency <ISendRepository>().Received(1).CreateAsync(send); }
public void SendCanBeAccessed_Success(SutProvider <SendService> sutProvider, Send send) { var now = DateTime.UtcNow; send.MaxAccessCount = 10; send.AccessCount = 5; send.ExpirationDate = now.AddYears(1); send.DeletionDate = now.AddYears(1); send.Disabled = false; sutProvider.GetDependency <IPasswordHasher <User> >() .VerifyHashedPassword(Arg.Any <User>(), send.Password, "TEST") .Returns(PasswordVerificationResult.Success); var(grant, passwordRequiredError, passwordInvalidError) = sutProvider.Sut.SendCanBeAccessed(send, "TEST"); Assert.True(grant); Assert.False(passwordRequiredError); Assert.False(passwordInvalidError); }
public async Task OrgImportCreateNewUsers(SutProvider <OrganizationService> sutProvider, Guid userId, Organization org, List <OrganizationUserUserDetails> existingUsers, List <ImportedOrganizationUser> newUsers) { org.UseDirectory = true; newUsers.Add(new ImportedOrganizationUser { Email = existingUsers.First().Email, ExternalId = existingUsers.First().ExternalId }); var expectedNewUsersCount = newUsers.Count - 1; sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(org.Id).Returns(org); sutProvider.GetDependency <IOrganizationUserRepository>().GetManyDetailsByOrganizationAsync(org.Id) .Returns(existingUsers); sutProvider.GetDependency <IOrganizationUserRepository>().GetCountByOrganizationIdAsync(org.Id) .Returns(existingUsers.Count); await sutProvider.Sut.ImportAsync(org.Id, userId, null, newUsers, null, false); await sutProvider.GetDependency <IOrganizationUserRepository>().DidNotReceiveWithAnyArgs() .UpsertAsync(default);
public async Task SaveWithServerAsync_ThrowsOnBadRequestApiException(SutProvider <CipherService> sutProvider, Cipher cipher, string fileName, EncByteArray data, EncString encKey) { sutProvider.GetDependency <ICryptoService>().EncryptAsync(fileName, Arg.Any <SymmetricCryptoKey>()) .Returns(new EncString(fileName)); sutProvider.GetDependency <ICryptoService>().EncryptToBytesAsync(data.Buffer, Arg.Any <SymmetricCryptoKey>()) .Returns(data); sutProvider.GetDependency <ICryptoService>().MakeEncKeyAsync(Arg.Any <SymmetricCryptoKey>()) .Returns(new Tuple <SymmetricCryptoKey, EncString>(null, encKey)); var expectedException = new ApiException(new ErrorResponse { StatusCode = HttpStatusCode.BadRequest }); sutProvider.GetDependency <IApiService>().PostCipherAttachmentAsync(cipher.Id, Arg.Any <AttachmentRequest>()) .Throws(expectedException); var actualException = await Assert.ThrowsAsync <ApiException>(async() => await sutProvider.Sut.SaveAttachmentRawWithServerAsync(cipher, fileName, data.Buffer)); Assert.Equal(expectedException.Error.StatusCode, actualException.Error.StatusCode); }
public async Task SaveWithServerAsync_FallsBackToLegacyFormData(HttpStatusCode statusCode, SutProvider <CipherService> sutProvider, Cipher cipher, string fileName, EncByteArray data, CipherResponse response, EncString encKey) { sutProvider.GetDependency <ICryptoService>().EncryptAsync(fileName, Arg.Any <SymmetricCryptoKey>()) .Returns(new EncString(fileName)); sutProvider.GetDependency <ICryptoService>().EncryptToBytesAsync(data.Buffer, Arg.Any <SymmetricCryptoKey>()) .Returns(data); sutProvider.GetDependency <ICryptoService>().MakeEncKeyAsync(Arg.Any <SymmetricCryptoKey>()).Returns(new Tuple <SymmetricCryptoKey, EncString>(null, encKey)); sutProvider.GetDependency <IApiService>().PostCipherAttachmentAsync(cipher.Id, Arg.Any <AttachmentRequest>()) .Throws(new ApiException(new ErrorResponse { StatusCode = statusCode })); sutProvider.GetDependency <IApiService>().PostCipherAttachmentLegacyAsync(cipher.Id, Arg.Any <MultipartFormDataContent>()) .Returns(response); await sutProvider.Sut.SaveAttachmentRawWithServerAsync(cipher, fileName, data.Buffer); await sutProvider.GetDependency <IApiService>().Received(1) .PostCipherAttachmentLegacyAsync(cipher.Id, Arg.Any <MultipartFormDataContent>()); }
// Send Options Policy - Disable Hide Email check private void SaveSendAsync_HideEmail_Setup(bool disableHideEmailAppliesToUser, SutProvider <SendService> sutProvider, Send send, Policy policy) { send.HideEmail = true; var sendOptions = new SendOptionsPolicyData { DisableHideEmail = disableHideEmailAppliesToUser }; policy.Data = JsonSerializer.Serialize(sendOptions, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, }); sutProvider.GetDependency <IPolicyRepository>().GetManyByTypeApplicableToUserIdAsync( Arg.Any <Guid>(), PolicyType.SendOptions).Returns(new List <Policy> { policy, }); }
public async Task GetAllDecryptedAsync_Success(SutProvider <SendService> sutProvider, string userId, IEnumerable <SendData> sendDatas) { var sendDataDict = sendDatas.ToDictionary(d => d.Id, d => d); sutProvider.GetDependency <ICryptoService>().HasKeyAsync().Returns(true); ServiceContainer.Register("cryptoService", sutProvider.GetDependency <ICryptoService>()); sutProvider.GetDependency <II18nService>().StringComparer.Returns(StringComparer.CurrentCulture); sutProvider.GetDependency <IUserService>().GetUserIdAsync().Returns(userId); sutProvider.GetDependency <IStorageService>().GetAsync <Dictionary <string, SendData> >(GetSendKey(userId)).Returns(sendDataDict); var actual = await sutProvider.Sut.GetAllDecryptedAsync(); Assert.Equal(sendDataDict.Count, actual.Count); foreach (var(actualView, expectedId) in actual.Zip(sendDataDict.Select(s => s.Key))) { // Note Send -> SendView is tested in SendTests Assert.Equal(expectedId, actualView.Id); } ServiceContainer.Reset(); }
public async Task ShareManyAsync_PaidOrgWithAttachment_Passes(SutProvider <CipherService> sutProvider, IEnumerable <Cipher> ciphers, Guid organizationId, List <Guid> collectionIds) { sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organizationId) .Returns(new Organization { PlanType = Enums.PlanType.EnterpriseAnnually, MaxStorageGb = 100 }); ciphers.FirstOrDefault().Attachments = "{\"attachment1\":{\"Size\":\"250\",\"FileName\":\"superCoolFile\"," + "\"Key\":\"superCoolFile\",\"ContainerName\":\"testContainer\",\"Validated\":false}}"; var cipherInfos = ciphers.Select(c => (c, (DateTime?)c.RevisionDate)); var sharingUserId = ciphers.First().UserId.Value; await sutProvider.Sut.ShareManyAsync(cipherInfos, organizationId, collectionIds, sharingUserId); await sutProvider.GetDependency <ICipherRepository>().Received(1).UpdateCiphersAsync(sharingUserId, Arg.Is <IEnumerable <Cipher> >(arg => arg.Except(ciphers).IsNullOrEmpty())); }
public async Task GetOrganizationApiKey_HasOne_Returns(SutProvider <GetOrganizationApiKeyCommand> sutProvider, Guid id, Guid organizationId, OrganizationApiKeyType keyType) { sutProvider.GetDependency <IOrganizationApiKeyRepository>() .GetManyByOrganizationIdTypeAsync(organizationId, keyType) .Returns(new List <OrganizationApiKey> { new OrganizationApiKey { Id = id, OrganizationId = organizationId, ApiKey = "test", Type = keyType, RevisionDate = DateTime.Now.AddDays(-1), }, }); var apiKey = await sutProvider.Sut.GetOrganizationApiKeyAsync(organizationId, keyType); Assert.NotNull(apiKey); Assert.Equal(id, apiKey.Id); }
public async Task UpdateLicenseAsync_Success(SutProvider <UserService> sutProvider, User user, UserLicense userLicense) { using var tempDir = new TempDirectory(); var now = DateTime.UtcNow; userLicense.Issued = now.AddDays(-10); userLicense.Expires = now.AddDays(10); userLicense.Version = 1; userLicense.Premium = true; user.EmailVerified = true; user.Email = userLicense.Email; sutProvider.GetDependency <Settings.IGlobalSettings>().SelfHosted = true; sutProvider.GetDependency <Settings.IGlobalSettings>().LicenseDirectory = tempDir.Directory; sutProvider.GetDependency <ILicensingService>() .VerifyLicense(userLicense) .Returns(true); await sutProvider.Sut.UpdateLicenseAsync(user, userLicense); var filePath = Path.Combine(tempDir.Directory, "user", $"{user.Id}.json"); Assert.True(File.Exists(filePath)); var document = JsonDocument.Parse(File.OpenRead(filePath)); var root = document.RootElement; Assert.Equal(JsonValueKind.Object, root.ValueKind); // Sort of a lazy way to test that it is indented but not sure of a better way Assert.Contains('\n', root.GetRawText()); AssertHelper.AssertJsonProperty(root, "LicenseKey", JsonValueKind.String); AssertHelper.AssertJsonProperty(root, "Id", JsonValueKind.String); AssertHelper.AssertJsonProperty(root, "Premium", JsonValueKind.True); var versionProp = AssertHelper.AssertJsonProperty(root, "Version", JsonValueKind.Number); Assert.Equal(1, versionProp.GetInt32()); }
public async Task Needs2FABecauseNewDeviceAsync_ReturnsTrue(SutProvider <UserService> sutProvider, User user) { user.EmailVerified = true; user.TwoFactorProviders = null; user.UnknownDeviceVerificationEnabled = true; const string deviceIdToCheck = "7b01b586-b210-499f-8d52-0c3fdaa646fc"; const string deviceIdInRepo = "ea29126c-91b7-4cc4-8ce6-00105b37f64a"; sutProvider.GetDependency <IDeviceRepository>() .GetManyByUserIdAsync(user.Id) .Returns(Task.FromResult <ICollection <Device> >(new List <Device> { new Device { Identifier = deviceIdInRepo } })); sutProvider.GetDependency <Settings.IGlobalSettings>().TwoFactorAuth.EmailOnNewDeviceLogin.Returns(true); Assert.True(await sutProvider.Sut.Needs2FABecauseNewDeviceAsync(user, deviceIdToCheck, "password")); }
public async Task Post_Success(Guid orgId, SutProvider <CollectionsController> sutProvider) { sutProvider.GetDependency <ICurrentContext>() .CreateNewCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .EditAnyCollection(orgId) .Returns(false); var collectionRequest = new CollectionRequestModel { Name = "encrypted_string", ExternalId = "my_external_id" }; _ = await sutProvider.Sut.Post(orgId, collectionRequest); await sutProvider.GetDependency <ICollectionService>() .Received(1) .SaveAsync(Arg.Any <Collection>(), Arg.Any <IEnumerable <SelectionReadOnly> >(), null); }
public async void UpdateFileToExistingSendAsync_InvalidSize(SutProvider <SendService> sutProvider, Send send) { var fileContents = "Test file content"; var sendFileData = new SendFileData { Id = "TEST", Size = fileContents.Length, }; send.Type = SendType.File; send.Data = JsonSerializer.Serialize(sendFileData); sutProvider.GetDependency <ISendFileStorageService>() .ValidateFileAsync(send, sendFileData.Id, sendFileData.Size, Arg.Any <long>()) .Returns((false, sendFileData.Size)); var badRequest = await Assert.ThrowsAsync <BadRequestException>(() => sutProvider.Sut.UploadFileToExistingSendAsync(new MemoryStream(Encoding.UTF8.GetBytes(fileContents)), send) ); }
public async Task SaveWithServerAsync_NewFileSend_AzureUpload_Success(SutProvider <SendService> sutProvider, string userId, SendFileUploadDataResponse response, Send send) { send.Id = null; response.FileUploadType = FileUploadType.Azure; sutProvider.GetDependency <IUserService>().GetUserIdAsync().Returns(userId); sutProvider.GetDependency <IApiService>().PostFileTypeSendAsync(Arg.Any <SendRequest>()).Returns(response); var fileContentBytes = new EncByteArray(Encoding.UTF8.GetBytes("This is the file content")); await sutProvider.Sut.SaveWithServerAsync(send, fileContentBytes); switch (send.Type) { case SendType.File: await sutProvider.GetDependency <IFileUploadService>().Received(1).UploadSendFileAsync(response, send.File.FileName, fileContentBytes); break; case SendType.Text: default: throw new Exception("Untested send type"); } }
public async Task RestoreManyAsync_UpdatesCiphers(Guid restoringUserId, IEnumerable <CipherDetails> ciphers, SutProvider <CipherService> sutProvider) { var previousRevisionDate = DateTime.UtcNow; foreach (var cipher in ciphers) { cipher.RevisionDate = previousRevisionDate; } var revisionDate = previousRevisionDate + TimeSpan.FromMinutes(1); sutProvider.GetDependency <ICipherRepository>().RestoreAsync(Arg.Any <IEnumerable <Guid> >(), restoringUserId) .Returns(revisionDate); await sutProvider.Sut.RestoreManyAsync(ciphers, restoringUserId); foreach (var cipher in ciphers) { Assert.Null(cipher.DeletedDate); Assert.Equal(revisionDate, cipher.RevisionDate); } }
public async Task InviteUser_Passes(Organization organization, OrganizationUserInvite invite, OrganizationUser invitor, SutProvider <OrganizationService> sutProvider) { invitor.Permissions = JsonSerializer.Serialize(new Permissions() { ManageUsers = true }, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, }); var organizationRepository = sutProvider.GetDependency <IOrganizationRepository>(); var organizationUserRepository = sutProvider.GetDependency <IOrganizationUserRepository>(); var eventService = sutProvider.GetDependency <IEventService>(); organizationRepository.GetByIdAsync(organization.Id).Returns(organization); organizationUserRepository.GetManyByUserAsync(invitor.UserId.Value).Returns(new List <OrganizationUser> { invitor }); await sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, null, invite); }
public async Task SaveWithServerAsync_NewFileSend_Success(SutProvider <SendService> sutProvider, string userId, SendResponse response, Send send) { send.Id = null; sutProvider.GetDependency <IUserService>().GetUserIdAsync().Returns(userId); sutProvider.GetDependency <IApiService>().PostSendAsync(Arg.Any <SendRequest>()).Returns(response); sutProvider.GetDependency <IApiService>().PostSendFileAsync(Arg.Any <MultipartFormDataContent>()).Returns(response); var fileContentBytes = Encoding.UTF8.GetBytes("This is the file content"); await sutProvider.Sut.SaveWithServerAsync(send, fileContentBytes); Predicate <MultipartFormDataContent> 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 <IApiService>().Received(1) .PostSendFileAsync(Arg.Is <MultipartFormDataContent>(f => formDataPredicate(f))); break; case SendType.Text: default: throw new Exception("Untested send type"); } }
public async Task GetAllDecryptedAsync_Success(SutProvider <SendService> sutProvider, string userId, IEnumerable <SendData> sendDatas) { // TODO restore this once race condition is fixed or GHA can re-run jobs on individual platforms return; var sendDataDict = sendDatas.ToDictionary(d => d.Id, d => d); sutProvider.GetDependency <ICryptoService>().HasKeyAsync().Returns(true); ServiceContainer.Register("cryptoService", sutProvider.GetDependency <ICryptoService>()); sutProvider.GetDependency <II18nService>().StringComparer.Returns(StringComparer.CurrentCulture); sutProvider.GetDependency <IStateService>().GetActiveUserIdAsync().Returns(userId); sutProvider.GetDependency <IStateService>().GetEncryptedSendsAsync().Returns(sendDataDict); var actual = await sutProvider.Sut.GetAllDecryptedAsync(); Assert.Equal(sendDataDict.Count, actual.Count); foreach (var(actualView, expectedId) in actual.Zip(sendDataDict.Select(s => s.Key))) { // Note Send -> SendView is tested in SendTests Assert.Equal(expectedId, actualView.Id); } ServiceContainer.Reset(); }
public async Task Put_Success(Guid orgId, Guid collectionId, Guid userId, CollectionRequestModel collectionRequest, SutProvider <CollectionsController> sutProvider) { sutProvider.GetDependency <ICurrentContext>() .ViewAssignedCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .EditAssignedCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .UserId .Returns(userId); sutProvider.GetDependency <ICollectionRepository>() .GetByIdAsync(collectionId, userId) .Returns(new CollectionDetails { OrganizationId = orgId, }); _ = await sutProvider.Sut.Put(orgId, collectionId, collectionRequest); }
public async Task RestoreAsync_UpdatesCipher(Guid restoringUserId, Cipher cipher, SutProvider <CipherService> sutProvider) { sutProvider.GetDependency <ICipherRepository>().GetCanEditByIdAsync(restoringUserId, cipher.Id).Returns(true); var initialRevisionDate = new DateTime(1970, 1, 1, 0, 0, 0); cipher.DeletedDate = initialRevisionDate; cipher.RevisionDate = initialRevisionDate; await sutProvider.Sut.RestoreAsync(cipher, restoringUserId, cipher.OrganizationId.HasValue); Assert.Null(cipher.DeletedDate); Assert.NotEqual(initialRevisionDate, cipher.RevisionDate); }