public async Task CashSwap()
{
AccountEntity testAccount1 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
Assert.NotNull(testAccount1);
BalanceDTO accountBalance1Asset1 = testAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance1Asset1);
BalanceDTO accountBalance1Asset2 = testAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.NotNull(accountBalance1Asset2);
AccountEntity testAccount2 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId2);
Assert.NotNull(testAccount2);
BalanceDTO accountBalance2Asset1 = testAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance2Asset1);
BalanceDTO accountBalance2Asset2 = testAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.NotNull(accountBalance2Asset2);
//Attempt invalid swap
double badSwapAmount1 = accountBalance1Asset1.Balance + 0.7;
double badSwapAmount2 = accountBalance2Asset2.Balance - 0.2; // this one isn't bad, but the transaction should still fail
string badSwapId = Guid.NewGuid().ToString();
MeResponseModel badSwapResponse = await this.Consumer.Client.SwapAsync(badSwapId,
testAccount1.Id, this.TestAsset1, badSwapAmount1,
testAccount2.Id, this.TestAsset2, badSwapAmount2);
Assert.True(badSwapResponse.Status == MeStatusCodes.LowBalance);
//Attempt a valid swap
double swapAmount1 = Math.Round(accountBalance1Asset1.Balance / 10, this.AssetPrecission);
double swapAmount2 = Math.Round(accountBalance2Asset2.Balance / 10, this.AssetPrecission);
string swapId = Guid.NewGuid().ToString();
MeResponseModel swapReseponse = await this.Consumer.Client.SwapAsync(swapId,
testAccount1.Id, this.TestAsset1, swapAmount1,
testAccount2.Id, this.TestAsset2, swapAmount2);
Assert.True(swapReseponse.Status == MeStatusCodes.Ok);
CashSwapOperation message = (CashSwapOperation)await this.WaitForRabbitMQ <CashSwapOperation>(o => o.id == swapId);
Assert.True(message.asset1 == this.TestAsset1);
Assert.True(message.asset2 == this.TestAsset2);
Assert.True(message.clientId1 == testAccount1.Id);
Assert.True(message.clientId2 == testAccount2.Id);
if (Double.TryParse(message.volume1, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedVolume))
{
Assert.True(parsedVolume == swapAmount1);
}
if (Double.TryParse(message.volume2, NumberStyles.Float, CultureInfo.InvariantCulture, out parsedVolume))
{
Assert.True(parsedVolume == swapAmount2);
}
CashSwapEntity checkCashSwapOperation = (CashSwapEntity)await this.CashSwapRepository.TryGetAsync(c => c.ExternalId == swapId);
Assert.True(checkCashSwapOperation.AssetId1 == this.TestAsset1);
Assert.True(checkCashSwapOperation.AssetId2 == this.TestAsset2);
Assert.True(checkCashSwapOperation.ClientId1 == testAccount1.Id);
Assert.True(checkCashSwapOperation.ClientId2 == testAccount2.Id);
Assert.True(checkCashSwapOperation.Amount1 == swapAmount1);
Assert.True(checkCashSwapOperation.Amount2 == swapAmount2);
AccountEntity checkTestAccount1 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
BalanceDTO checkAccountBalance1Asset1 = checkTestAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
BalanceDTO checkAccountBalance1Asset2 = checkTestAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
AccountEntity checkTestAccount2 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId2);
BalanceDTO checkAccountBalance2Asset1 = checkTestAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
BalanceDTO checkAccountBalance2Asset2 = checkTestAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.True(Math.Round(checkAccountBalance1Asset1.Balance, this.AssetPrecission) == Math.Round(accountBalance1Asset1.Balance - swapAmount1, this.AssetPrecission));
Assert.True(Math.Round(checkAccountBalance2Asset1.Balance, this.AssetPrecission) == Math.Round(accountBalance2Asset1.Balance + swapAmount1, this.AssetPrecission));
Assert.True(Math.Round(checkAccountBalance1Asset2.Balance, this.AssetPrecission) == Math.Round(accountBalance1Asset2.Balance + swapAmount2, this.AssetPrecission));
Assert.True(Math.Round(checkAccountBalance2Asset2.Balance, this.AssetPrecission) == Math.Round(accountBalance2Asset2.Balance - swapAmount2, this.AssetPrecission));
// Attempt swap back
string swapBackId = Guid.NewGuid().ToString();
MeResponseModel swapBackReseponse = await this.Consumer.Client.SwapAsync(swapBackId,
testAccount2.Id, this.TestAsset1, swapAmount1,
testAccount1.Id, this.TestAsset2, swapAmount2);
Assert.True(swapBackReseponse.Status == MeStatusCodes.Ok);
message = (CashSwapOperation)await this.WaitForRabbitMQ <CashSwapOperation>(o => o.id == swapBackId);
Assert.True(message.asset1 == this.TestAsset1);
Assert.True(message.asset2 == this.TestAsset2);
Assert.True(message.clientId1 == testAccount2.Id);
Assert.True(message.clientId2 == testAccount1.Id);
if (Double.TryParse(message.volume1, NumberStyles.Float, CultureInfo.InvariantCulture, out parsedVolume))
{
Assert.True(parsedVolume == swapAmount1);
}
if (Double.TryParse(message.volume2, NumberStyles.Float, CultureInfo.InvariantCulture, out parsedVolume))
{
Assert.True(parsedVolume == swapAmount2);
}
checkCashSwapOperation = (CashSwapEntity)await this.CashSwapRepository.TryGetAsync(c => c.ExternalId == swapBackId);
Assert.True(checkCashSwapOperation.AssetId1 == this.TestAsset1);
Assert.True(checkCashSwapOperation.AssetId2 == this.TestAsset2);
Assert.True(checkCashSwapOperation.ClientId1 == testAccount2.Id);
Assert.True(checkCashSwapOperation.ClientId2 == testAccount1.Id);
Assert.True(checkCashSwapOperation.Amount1 == swapAmount1);
Assert.True(checkCashSwapOperation.Amount2 == swapAmount2);
checkTestAccount1 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
checkAccountBalance1Asset1 = checkTestAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
checkAccountBalance1Asset2 = checkTestAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
checkTestAccount2 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId2);
checkAccountBalance2Asset1 = checkTestAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
checkAccountBalance2Asset2 = checkTestAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
// balances should be back to their initial state
Assert.True(accountBalance1Asset1.Balance == checkAccountBalance1Asset1.Balance);
Assert.True(accountBalance1Asset2.Balance == checkAccountBalance1Asset2.Balance);
Assert.True(accountBalance2Asset1.Balance == checkAccountBalance2Asset1.Balance);
Assert.True(accountBalance2Asset2.Balance == checkAccountBalance2Asset2.Balance);
}
public async Task CashTransfer()
{
AccountEntity testAccount1 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
Assert.NotNull(testAccount1);
BalanceDTO accountBalance1 = testAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance1);
AccountEntity testAccount2 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId2);
Assert.NotNull(testAccount2);
BalanceDTO accountBalance2 = testAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance2);
//Attempt invalid transfer
double badTransferAmount = accountBalance1.Balance + 0.7;
string badTransferId = Guid.NewGuid().ToString();
MeResponseModel badTransferResponse = await this.Consumer.Client.TransferAsync(badTransferId, testAccount1.Id, testAccount2.Id, this.TestAsset1, badTransferAmount);
Assert.NotNull(badTransferResponse);
Assert.True(badTransferResponse.Status == MeStatusCodes.LowBalance);
//Transfer from Test acc 1 to Test acc 2
double transferAmount = Math.Round(accountBalance1.Balance / 10, this.AssetPrecission);
string transferId = Guid.NewGuid().ToString();
MeResponseModel transferResponse = await this.Consumer.Client.TransferAsync(transferId, testAccount1.Id, testAccount2.Id, this.TestAsset1, transferAmount);
Assert.NotNull(transferResponse);
Assert.True(transferResponse.Status == MeStatusCodes.Ok);
CashTransferOperation message = (CashTransferOperation)await this.WaitForRabbitMQ <CashTransferOperation>(o => o.id == transferId);
Assert.NotNull(message);
Assert.True(message.asset == this.TestAsset1);
Assert.True(message.fromClientId == testAccount1.Id);
Assert.True(message.toClientId == testAccount2.Id);
if (Double.TryParse(message.volume, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedMsgAmount))
{
Assert.True(parsedMsgAmount == transferAmount);
}
CashSwapEntity checkCashSwapOperation = (CashSwapEntity)await this.CashSwapRepository.TryGetAsync(c => c.ExternalId == transferId);
Assert.True(checkCashSwapOperation.Amount == transferAmount);
Assert.True(checkCashSwapOperation.AssetId == this.TestAsset1);
Assert.True(checkCashSwapOperation.FromClientId == testAccount1.Id);
Assert.True(checkCashSwapOperation.ToClientId == testAccount2.Id);
AccountEntity checkTestAccount1 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
BalanceDTO checkAccountBalance1 = checkTestAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
AccountEntity checkTestAccount2 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId2);
BalanceDTO checkAccountBalance2 = checkTestAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.True(Math.Round(checkAccountBalance1.Balance, this.AssetPrecission) == Math.Round(accountBalance1.Balance - transferAmount, this.AssetPrecission)); // TODO get asset accuracy
Assert.True(Math.Round(checkAccountBalance2.Balance, this.AssetPrecission) == Math.Round(accountBalance2.Balance + transferAmount, this.AssetPrecission)); // TODO get asset accuracy
//Transfer same amount from Test acc 2 to Test acc 1
string transferBackId = Guid.NewGuid().ToString();
MeResponseModel transferBackResponse = await this.Consumer.Client.TransferAsync(transferBackId, testAccount2.Id, testAccount1.Id, this.TestAsset1, transferAmount);
Assert.NotNull(transferBackResponse);
Assert.True(transferBackResponse.Status == MeStatusCodes.Ok);
message = (CashTransferOperation)await this.WaitForRabbitMQ <CashTransferOperation>(o => o.id == transferBackId);
Assert.NotNull(message);
Assert.True(message.asset == this.TestAsset1);
Assert.True(message.fromClientId == testAccount2.Id);
Assert.True(message.toClientId == testAccount1.Id);
if (Double.TryParse(message.volume, NumberStyles.Float, CultureInfo.InvariantCulture, out parsedMsgAmount))
{
Assert.True(parsedMsgAmount == transferAmount);
}
CashSwapEntity checkCashSwapBackOperation = (CashSwapEntity)await this.CashSwapRepository.TryGetAsync(c => c.ExternalId == transferBackId);
Assert.True(checkCashSwapBackOperation.Amount == transferAmount);
Assert.True(checkCashSwapBackOperation.AssetId == this.TestAsset1);
Assert.True(checkCashSwapBackOperation.FromClientId == testAccount2.Id);
Assert.True(checkCashSwapBackOperation.ToClientId == testAccount1.Id);
checkTestAccount1 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
checkAccountBalance1 = checkTestAccount1.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
checkTestAccount2 = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId2);
checkAccountBalance2 = checkTestAccount2.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
//balances should be back to their initial state after 2 transfers back and forward
Assert.True(accountBalance1.Balance == checkAccountBalance1.Balance);
Assert.True(accountBalance2.Balance == checkAccountBalance2.Balance);
}
