public static Task StartTransferTypeAndErrorServer( TransferType transferType, TransferError transferError, out IPEndPoint localEndPoint) { return(CreateServerAsync((server, url) => AcceptSocketAsync(server, async(client, stream, reader, writer) => { // Read past request headers. string line; while (!string.IsNullOrEmpty(line = reader.ReadLine())) { ; } // Determine response transfer headers. string transferHeader = null; string content = "This is some response content."; if (transferType == TransferType.ContentLength) { transferHeader = transferError == TransferError.ContentLengthTooLarge ? $"Content-Length: {content.Length + 42}\r\n" : $"Content-Length: {content.Length}\r\n"; } else if (transferType == TransferType.Chunked) { transferHeader = "Transfer-Encoding: chunked\r\n"; } // Write response header await writer.WriteAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false); await writer.WriteAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false); await writer.WriteAsync("Content-Type: text/plain\r\n").ConfigureAwait(false); if (!string.IsNullOrEmpty(transferHeader)) { await writer.WriteAsync(transferHeader).ConfigureAwait(false); } await writer.WriteAsync("\r\n").ConfigureAwait(false); // Write response body if (transferType == TransferType.Chunked) { string chunkSizeInHex = string.Format( "{0:x}\r\n", content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0)); await writer.WriteAsync(chunkSizeInHex).ConfigureAwait(false); await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false); if (transferError != TransferError.MissingChunkTerminator) { await writer.WriteAsync("0\r\n\r\n").ConfigureAwait(false); } } else { await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false); } await writer.FlushAsync().ConfigureAwait(false); client.Shutdown(SocketShutdown.Both); }), out localEndPoint)); }
public static TransferResultModel Failed(TransferError error) { return(new TransferResultModel { Error = error, }); }
public async Task CustomerTriesToTransferAsset_ErrorOnPbf_ErrorReturned(TransferError pbfError, TransferErrorCodes wmError) { _customerProfileMock .Setup(x => x.CustomerProfiles.GetByCustomerIdAsync(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>())) .ReturnsAsync(new CustomerProfileResponse { Profile = new CustomerProfile { Email = "*****@*****.**", } }); _transfersRepositoryMock .Setup(x => x.AddAsync(It.IsAny<ITransfer>())) .Returns(Task.CompletedTask); _blockchainFacadeMock .Setup(x => x.TransfersApi.TransferAsync(It.IsAny<TransferRequestModel>())) .ReturnsAsync(new TransferResponseModel { Error = pbfError }); _walletManagementServiceMock .Setup(x => x.IsCustomerWalletBlockedAsync(It.IsAny<string>())) .ReturnsAsync(false); var transferService = CreateSutInstance(); var result = await transferService.TransferBalanceAsync( Guid.NewGuid().ToString(), FakeSenderCustomerId, FakeRecipientCustomerId, 1); Assert.NotNull(result); Assert.Equal(wmError, result.ErrorCode); }
public static Task StartTransferTypeAndErrorServer( TransferType transferType, TransferError transferError, out IPEndPoint localEndPoint) { return CreateServerAsync((server, url) => AcceptSocketAsync(server, async (client, stream, reader, writer) => { // Read past request headers. string line; while (!string.IsNullOrEmpty(line = reader.ReadLine())) ; // Determine response transfer headers. string transferHeader = null; string content = "This is some response content."; if (transferType == TransferType.ContentLength) { transferHeader = transferError == TransferError.ContentLengthTooLarge ? $"Content-Length: {content.Length + 42}\r\n" : $"Content-Length: {content.Length}\r\n"; } else if (transferType == TransferType.Chunked) { transferHeader = "Transfer-Encoding: chunked\r\n"; } // Write response header await writer.WriteAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false); await writer.WriteAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false); await writer.WriteAsync("Content-Type: text/plain\r\n").ConfigureAwait(false); if (!string.IsNullOrEmpty(transferHeader)) { await writer.WriteAsync(transferHeader).ConfigureAwait(false); } await writer.WriteAsync("\r\n").ConfigureAwait(false); // Write response body if (transferType == TransferType.Chunked) { string chunkSizeInHex = string.Format( "{0:x}\r\n", content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0)); await writer.WriteAsync(chunkSizeInHex).ConfigureAwait(false); await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false); if (transferError != TransferError.MissingChunkTerminator) { await writer.WriteAsync("0\r\n\r\n").ConfigureAwait(false); } } else { await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false); } await writer.FlushAsync().ConfigureAwait(false); client.Shutdown(SocketShutdown.Both); }), out localEndPoint); }
public async Task ReadAsStreamAsync_InvalidServerResponse_ThrowsIOException( TransferType transferType, TransferError transferError) { await StartTransferTypeAndErrorServer(transferType, transferError, async uri => { await Assert.ThrowsAsync <IOException>(() => ReadAsStreamHelper(uri)); }); }
public async Task ReadAsStreamAsync_ValidServerResponse_Success( TransferType transferType, TransferError transferError) { await StartTransferTypeAndErrorServer(transferType, transferError, async uri => { await ReadAsStreamHelper(uri); }); }
public OperatorData Failed(IActorRef parent, FailReason reason, string?errorData) { var failed = new TransferError(OperationId, reason, errorData); TargetManager.Tell(failed, parent); parent.Tell(failed.ToFailed()); return(Copy(failed: failed)); }
public static Task StartTransferTypeAndErrorServer( TransferType transferType, TransferError transferError, Func <Uri, Task> clientFunc) { return(LoopbackServer.CreateClientAndServerAsync( clientFunc, server => server.AcceptConnectionAsync(async connection => { // Read past request headers. await connection.ReadRequestHeaderAsync(); // Determine response transfer headers. string transferHeader = null; string content = "This is some response content."; if (transferType == TransferType.ContentLength) { transferHeader = transferError == TransferError.ContentLengthTooLarge ? $"Content-Length: {content.Length + 42}\r\n" : $"Content-Length: {content.Length}\r\n"; } else if (transferType == TransferType.Chunked) { transferHeader = "Transfer-Encoding: chunked\r\n"; } // Write response header TextWriter writer = connection.Writer; await writer.WriteAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false); await writer.WriteAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false); await writer.WriteAsync("Content-Type: text/plain\r\n").ConfigureAwait(false); if (!string.IsNullOrEmpty(transferHeader)) { await writer.WriteAsync(transferHeader).ConfigureAwait(false); } await writer.WriteAsync("\r\n").ConfigureAwait(false); // Write response body if (transferType == TransferType.Chunked) { string chunkSizeInHex = string.Format( "{0:x}\r\n", content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0)); await writer.WriteAsync(chunkSizeInHex).ConfigureAwait(false); await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false); if (transferError != TransferError.MissingChunkTerminator) { await writer.WriteAsync("0\r\n\r\n").ConfigureAwait(false); } } else { await writer.WriteAsync($"{content}").ConfigureAwait(false); } }))); }
public async Task TransferToInternalAsync_InvalidInputParameters_ReturnsFail( string privateWalletAddress, string publicWalletAddress, long amount, TransferError expectedError) { var sut = CreateSutInstance(); var result = await sut.TransferToInternalAsync(privateWalletAddress, publicWalletAddress, amount, 123); Assert.Equal(expectedError, result.Error); }
public async Task TransferAsync_InvalidInputParameters_ReturnsFail( string senderId, string recipientId, long amount, TransferError expectedError) { var sut = CreateSutInstance(); var result = await sut.P2PTransferAsync(senderId, recipientId, amount, FakeTransferId); Assert.Equal(expectedError, result.Error); }
public async Task GenericTransferAsync_InvalidInputParameters_ReturnsFail( string senderId, string recipientWalletAddress, long amount, string additionalData, TransferError expectedError) { var sut = CreateSutInstance(); var result = await sut.GenericTransferAsync(senderId, recipientWalletAddress, amount, FakeTransferId, additionalData); Assert.Equal(expectedError, result.Error); }
public async Task TransferToExternalAsync_InvalidInputParameters_ReturnsFail( string senderId, string recipientWalletAddress, long amount, long fee, TransferError expectedError) { var sut = CreateSutInstance(); var result = await sut.TransferToExternalAsync(senderId, recipientWalletAddress, amount, fee, FakeTransferId); Assert.Equal(expectedError, result.Error); }
public async Task CustomerTriesToMakePaymentTransfer_ErrorFromPbf_ErrorReturned (TransferError pbfError, PaymentTransfersErrorCodes expectedError) { _cpClient.Setup(x => x.CustomerProfiles.GetByCustomerIdAsync(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>())) .ReturnsAsync(new CustomerProfileResponse { Profile = new CustomerProfile.Client.Models.Responses.CustomerProfile() }); _wmClient .Setup(x => x.Api.GetCustomerWalletBlockStateAsync(It.IsAny <string>())) .ReturnsAsync(new CustomerWalletBlockStatusResponse { Status = CustomerWalletActivityStatus.Active }); _campaignClient.Setup(x => x.BurnRules.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(new BurnRuleResponse { ErrorCode = CampaignServiceErrorCodes.None, Vertical = Vertical.RealEstate }); _eligibilityEngineClientMock.Setup(x => x.ConversionRate.GetAmountBySpendRuleAsync(It.IsAny <ConvertAmountBySpendRuleRequest>())) .ReturnsAsync(new ConvertAmountBySpendRuleResponse { ErrorCode = EligibilityEngineErrors.None, Amount = ValidAmount }); _pbfClientMock.Setup(x => x.GenericTransfersApi.GenericTransferAsync(It.IsAny <GenericTransferRequestModel>())) .ReturnsAsync(new TransferResponseModel { Error = pbfError }); var requestDto = new PaymentTransferDto { CustomerId = FakeCustomerId, SpendRuleId = FakeCampaignId, AmountInFiat = ValidAmount }; var sut = CreateSutInstance(); var result = await sut.PaymentTransferAsync(requestDto); Assert.Equal(expectedError, result); }
public async Task ReadAsStreamAsync_StreamCanReadIsFalseAfterDispose( TransferType transferType, TransferError transferError) { await StartTransferTypeAndErrorServer(transferType, transferError, async uri => { using (HttpClient client = CreateHttpClient()) using (HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead)) { Stream stream = await response.Content.ReadAsStreamAsync(); Assert.True(stream.CanRead); stream.Dispose(); Assert.False(stream.CanRead); } }); }
public void Transfer(double pAmount, int pFromAcctNumber, int pToAcctNumber, Guid pOrderGuid, int pCustomerId) { using (TransactionScope lScope = new TransactionScope()) using (BankEntityModelContainer lContainer = new BankEntityModelContainer()) { try { Account lFromAcct = GetAccountFromNumber(pFromAcctNumber); Account lToAcct = GetAccountFromNumber(pToAcctNumber); lFromAcct.Withdraw(pAmount); lToAcct.Deposit(pAmount); lContainer.Attach(lFromAcct); lContainer.Attach(lToAcct); lContainer.ObjectStateManager.ChangeObjectState(lFromAcct, System.Data.EntityState.Modified); lContainer.ObjectStateManager.ChangeObjectState(lToAcct, System.Data.EntityState.Modified); var lItem = new TransferComplete { OrderGuid = pOrderGuid, CustomerId = pCustomerId }; var lVisitor = new TransferCompleteToTransferCompleteMessage(); lItem.Accept(lVisitor); PublisherServiceClient lClient = new PublisherServiceClient(); lClient.Publish(lVisitor.Result); } catch (Exception lException) { Console.WriteLine("Error occured while transferring money: " + lException.Message); var lItem = new TransferError { OrderGuid = pOrderGuid }; var lVisitor = new TransferErrorToTransferErrorMessage(); lItem.Accept(lVisitor); PublisherServiceClient lClient = new PublisherServiceClient(); lClient.Publish(lVisitor.Result); } lContainer.SaveChanges(); lScope.Complete(); } }
public async Task TransferToExternalAsync_IsDuplicateCheck_WorksCorrectly(bool isDuplicate, TransferError expectedError) { const long amount = 100; _walletsServiceMock .Setup(x => x.GetCustomerWalletAsync(It.IsAny <string>())) .ReturnsAsync(CustomerWalletAddressResultModel.Succeeded(FakeWalletAddress)); _balanceServiceMock .Setup(x => x.GetAsync(It.IsAny <string>())) .ReturnsAsync(CustomerBalanceResultModel.Succeeded(amount, FakeStakedAmount)); _deduplicationLogMock .Setup(x => x.IsDuplicateAsync(It.IsAny <string>())) .ReturnsAsync(isDuplicate); var sut = CreateSutInstance(); var result = await sut.TransferToExternalAsync(FakeSenderCustomerId, FakeWalletAddress, amount, 0, FakeTransferId); Assert.Equal(expectedError, result.Error); }
public async Task TransferToInternalAsync_IsDuplicateCheck_WorksCorrectly(bool isDuplicate, TransferError expectedError) { const long amount = 100; _deduplicationLogMock .Setup(x => x.IsDuplicateAsync(It.IsAny <string>())) .ReturnsAsync(isDuplicate); var sut = CreateSutInstance(); var result = await sut.TransferToInternalAsync(FakeWalletAddress, FakeRecipientCustomerId, amount, 123); Assert.Equal(expectedError, result.Error); }
public OperatorData InComingError(TransferError error) => Copy(failed: error);
public static Task StartServer( TransferType transferType, TransferError transferError, out IPEndPoint serverEndPoint) { var server = new TcpListener(IPAddress.Loopback, 0); Task serverTask = ((Func <Task>)async delegate { server.Start(); using (var client = await server.AcceptSocketAsync()) using (var stream = new NetworkStream(client)) using (var reader = new StreamReader(stream, Encoding.ASCII)) { // Read past request headers. string line; while (!string.IsNullOrEmpty(line = reader.ReadLine())) { ; } // Determine response transfer headers. string transferHeader = null; string content = "This is some response content."; if (transferType == TransferType.ContentLength) { if (transferError == TransferError.ContentLengthTooLarge) { transferHeader = $"Content-Length: {content.Length + 42}\r\n"; } else { transferHeader = $"Content-Length: {content.Length}\r\n"; } } else if (transferType == TransferType.Chunked) { transferHeader = "Transfer-Encoding: chunked\r\n"; } // Write response. using (var writer = new StreamWriter(stream, Encoding.ASCII)) { writer.Write("HTTP/1.1 200 OK\r\n"); writer.Write($"Date: {DateTimeOffset.UtcNow:R}\r\n"); writer.Write("Content-Type: text/plain\r\n"); if (!string.IsNullOrEmpty(transferHeader)) { writer.Write(transferHeader); } writer.Write("\r\n"); if (transferType == TransferType.Chunked) { string chunkSizeInHex = string.Format( "{0:x}\r\n", content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0)); writer.Write(chunkSizeInHex); writer.Write($"{content}\r\n"); if (transferError != TransferError.MissingChunkTerminator) { writer.Write("0\r\n\r\n"); } } else { writer.Write($"{content}\r\n"); } writer.Flush(); } client.Shutdown(SocketShutdown.Both); } })(); serverEndPoint = (IPEndPoint)server.LocalEndpoint; return(serverTask); }
public static Task StartServer( TransferType transferType, TransferError transferError, out IPEndPoint serverEndPoint) { var server = new TcpListener(IPAddress.Loopback, 0); Task serverTask = ((Func<Task>)async delegate { server.Start(); using (var client = await server.AcceptSocketAsync()) using (var stream = new NetworkStream(client)) using (var reader = new StreamReader(stream, Encoding.ASCII)) { // Read past request headers. string line; while (!string.IsNullOrEmpty(line = reader.ReadLine())) ; // Determine response transfer headers. string transferHeader = null; string content = "This is some response content."; if (transferType == TransferType.ContentLength) { if (transferError == TransferError.ContentLengthTooLarge) { transferHeader = $"Content-Length: {content.Length + 42}\r\n"; } else { transferHeader = $"Content-Length: {content.Length}\r\n"; } } else if (transferType == TransferType.Chunked) { transferHeader = "Transfer-Encoding: chunked\r\n"; } // Write response. using (var writer = new StreamWriter(stream, Encoding.ASCII)) { writer.Write("HTTP/1.1 200 OK\r\n"); writer.Write($"Date: {DateTimeOffset.UtcNow:R}\r\n"); writer.Write("Content-Type: text/plain\r\n"); if (!string.IsNullOrEmpty(transferHeader)) { writer.Write(transferHeader); } writer.Write("\r\n"); if (transferType == TransferType.Chunked) { string chunkSizeInHex = string.Format( "{0:x}\r\n", content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0)); writer.Write(chunkSizeInHex); writer.Write($"{content}\r\n"); if (transferError != TransferError.MissingChunkTerminator) { writer.Write("0\r\n\r\n"); } } else { writer.Write($"{content}\r\n"); } writer.Flush(); } client.Shutdown(SocketShutdown.Both); } })(); serverEndPoint = (IPEndPoint)server.LocalEndpoint; return serverTask; }
public async Task TransferAsync_BalanceServiceReturnsError_ReturnsFail(CustomerBalanceError balanceError, TransferError expectedError) { _walletsServiceMock .Setup(x => x.GetCustomerWalletAsync(It.IsAny <string>())) .ReturnsAsync(CustomerWalletAddressResultModel.Succeeded(FakeWalletAddress)); _balanceServiceMock .Setup(x => x.GetAsync(It.IsAny <string>())) .ReturnsAsync(CustomerBalanceResultModel.Failed(balanceError)); var sut = CreateSutInstance(); var result = await sut.P2PTransferAsync(FakeSenderCustomerId, FakeRecipientCustomerId, 1, FakeTransferId); Assert.Equal(expectedError, result.Error); }