Esempio n. 1
0
        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,
     });
 }
Esempio n. 3
0
        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);
        }
Esempio n. 4
0
        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);
        }
Esempio n. 5
0
 public async Task ReadAsStreamAsync_InvalidServerResponse_ThrowsIOException(
     TransferType transferType,
     TransferError transferError)
 {
     await StartTransferTypeAndErrorServer(transferType, transferError, async uri =>
     {
         await Assert.ThrowsAsync <IOException>(() => ReadAsStreamHelper(uri));
     });
 }
Esempio n. 6
0
 public async Task ReadAsStreamAsync_ValidServerResponse_Success(
     TransferType transferType,
     TransferError transferError)
 {
     await StartTransferTypeAndErrorServer(transferType, transferError, async uri =>
     {
         await ReadAsStreamHelper(uri);
     });
 }
Esempio n. 7
0
        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));
        }
Esempio n. 8
0
        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);
        }
Esempio n. 14
0
        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);
                    }
            });
        }
Esempio n. 15
0
        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);
        }
Esempio n. 18
0
 public OperatorData InComingError(TransferError error)
 => Copy(failed: error);
Esempio n. 19
0
        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);
        }
Esempio n. 20
0
        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);
        }