public void GetFeeTest_TestsIfTheFeeIsasReturnedAsExpectedWhenMiddleElementsAreReached_VerifiesThroughDatabaseQueries()
{
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
AccountId accountId = new AccountId(1);
List <Fee> allFees = feeRepository.GetAllFees();
Assert.IsNotNull(allFees);
string currencyPair = allFees[0].CurrencyPair;
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(currencyPair);
List <Fee> feeByCurrencyPair = feeRepository.GetFeeByCurrencyPair(currencyPair);
Assert.IsNotNull(feeByCurrencyPair);
if (feeByCurrencyPair.Count > 4)
{
decimal amount = feeByCurrencyPair[feeByCurrencyPair.Count - 2].Amount;
Ledger ledger = new Ledger("1", DateTime.Now, LedgerType.Trade, new Currency(splittedCurrencyPair.Item2),
amount, 0, 0, 0, "1", "1", false, accountId);
fundsPersistenceRepository.SaveOrUpdate(ledger);
decimal lastElementFee = (feeByCurrencyPair[feeByCurrencyPair.Count - 2].PercentageFee / 100) * (10 * 20);
decimal feeFromService = feeCalculationService.GetFee(new Currency(splittedCurrencyPair.Item1),
new Currency(splittedCurrencyPair.Item2),
accountId, 10, 20);
Assert.AreEqual(lastElementFee, feeFromService);
}
}
public void GetFeeTest_TestsIfTheFeeIsasReturnedAsExpectedWhenFinalElementInTheTableIsReached_VerifiesThroughDatabaseQueries()
{
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
AccountId accountId = new AccountId(1);
List <Fee> allFees = feeRepository.GetAllFees();
Assert.IsNotNull(allFees);
string currencyPair = allFees[0].CurrencyPair;
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(currencyPair);
// As amount, the value is so large that it is always greater than any fee in the table
Ledger ledger = new Ledger("1", DateTime.Now, LedgerType.Trade, new Currency(splittedCurrencyPair.Item2),
2000000, 0, 0, 0, "1", "1", false, accountId);
fundsPersistenceRepository.SaveOrUpdate(ledger);
List <Fee> feeByCurrencyPair = feeRepository.GetFeeByCurrencyPair(currencyPair);
Assert.IsNotNull(feeByCurrencyPair);
decimal lastElementFee = (feeByCurrencyPair.Last().PercentageFee / 100) * (1000 * 2000);
decimal feeFromService = feeCalculationService.GetFee(new Currency(splittedCurrencyPair.Item1),
new Currency(splittedCurrencyPair.Item2),
accountId, 1000, 2000);
Assert.AreEqual(lastElementFee, feeFromService);
}
/// <summary>
/// Receives trade when events are raised
/// </summary>
/// <param name="trade"></param>
void OnTradeArrived(Trade trade)
{
_persistanceRepository.SaveOrUpdate(ReadModelAdapter.GetTradeReadModel(trade));
_ohlcCalculation.CalculateAndPersistOhlc(trade);
_tickerInfoCalculation.CalculateTickerInfo(trade);
Tuple <string, string> currencies = CurrencySplitterService.SplitCurrencyPair(trade.CurrencyPair);
// Update the balance on hte Funds BC
_balanceValidationService.TradeExecuted(currencies.Item1, currencies.Item2, trade.ExecutedVolume.Value,
trade.ExecutionPrice.Value, trade.ExecutionTime, trade.TradeId.Id, trade.BuyOrder.TraderId.Id,
trade.SellOrder.TraderId.Id, trade.BuyOrder.OrderId.Id, trade.SellOrder.OrderId.Id);
}
public NewOrderRepresentation CreateOrder(CreateOrderCommand orderCommand)
{
IOrderIdGenerator orderIdGenerator = ContextRegistry.GetContext()["OrderIdGenerator"] as IOrderIdGenerator;
Tuple <string, string> splittedCurrencyPairs = CurrencySplitterService.SplitCurrencyPair(orderCommand.Pair);
Order order = OrderFactory.CreateOrder(orderCommand.TraderId, orderCommand.Pair,
orderCommand.Type, orderCommand.Side, orderCommand.Volume, orderCommand.Price, orderIdGenerator);
if (_balanceValidationService.FundsConfirmation(order.TraderId.Id, splittedCurrencyPairs.Item1,
splittedCurrencyPairs.Item2, order.Volume.Value, order.Price.Value, order.OrderSide.ToString(),
order.OrderId.Id))
{
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order));
return(new NewOrderRepresentation(order));
}
throw new InvalidOperationException("Not Enough Balance for Trader with ID: " + orderCommand.TraderId);
}
public void SendMultipleOrdersTest_TestsIfSendingMultipleOrdersIsHandledAsExpected_VerifiesThroughTheReturnesValue()
{
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
AccountId accountId = new AccountId(123);
List <Fee> allFees = feeRepository.GetAllFees();
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(allFees.First().CurrencyPair);
Currency baseCurrency = new Currency(splittedCurrencyPair.Item1);
Currency quoteCurrency = new Currency(splittedCurrencyPair.Item2);
Balance baseCurrencyBalance = new Balance(baseCurrency, accountId, 400, 400);
fundsPersistenceRepository.SaveOrUpdate(baseCurrencyBalance);
Balance quoteCurrencyBalance = new Balance(quoteCurrency, accountId, 40000, 40000);
fundsPersistenceRepository.SaveOrUpdate(quoteCurrencyBalance);
bool validateFundsForOrder = fundsValidationService.ValidateFundsForOrder(accountId, baseCurrency,
quoteCurrency, 40, 100, "buy", "order123");
Assert.IsTrue(validateFundsForOrder);
// Get the fee corresponding to the current volume of the quote currency
decimal usdFee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, accountId, 40, 100);
Assert.Greater(usdFee, 0);
baseCurrencyBalance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, accountId);
Assert.AreEqual(400, baseCurrencyBalance.CurrentBalance);
Assert.AreEqual(400, baseCurrencyBalance.AvailableBalance);
Assert.AreEqual(0, baseCurrencyBalance.PendingBalance);
quoteCurrencyBalance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, accountId);
Assert.AreEqual(40000 - (40 * 100), quoteCurrencyBalance.AvailableBalance);
Assert.AreEqual(40000, quoteCurrencyBalance.CurrentBalance);
Assert.AreEqual(40 * 100, quoteCurrencyBalance.PendingBalance);
}
/// <summary>
/// Handles the event of change in orders
/// </summary>
/// <param name="order"></param>
void OnOrderStatusChanged(Order order)
{
_persistanceRepository.SaveOrUpdate(ReadModelAdapter.GetOrderReadModel(order));
// If the order has been cancelled, send the info to Funds BC so that the funds can be updated
if (order.OrderState == OrderState.Cancelled)
{
// First split the curreny pair into base and quote currency
Tuple <string, string> splittedCurrencyPair =
CurrencySplitterService.SplitCurrencyPair(order.CurrencyPair);
if (!string.IsNullOrEmpty(splittedCurrencyPair.Item1) &&
!string.IsNullOrEmpty(splittedCurrencyPair.Item2))
{
// Send to the Infrastructure service which will communicate cross Bounded Context
_balanceValidationService.OrderCancelled(splittedCurrencyPair.Item1, splittedCurrencyPair.Item2,
order.TraderId.Id, order.OrderSide.ToString(),
order.OrderId.Id,
order.OpenQuantity.Value, order.Price.Value);
}
}
}
public void Scenario1Test_TestsFundsValidationServiceOperationsInaRandomOrderToProceedInTheDesiredExpectenacy_VerifiesThroughDatabaseQuery()
{
// Deposit --> Order Validations --> Trade --> Withdraw
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositIdGeneratorService depositIdGeneratorService = (IDepositIdGeneratorService)ContextRegistry.GetContext()["DepositIdGeneratorService"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(feeRepository.GetAllFees().First().CurrencyPair);
Currency baseCurrency = new Currency(splittedCurrencyPair.Item1);
Currency quoteCurrency = new Currency(splittedCurrencyPair.Item2);
AccountId user1Account = new AccountId(1);
AccountId user2Account = new AccountId(2);
decimal baseDepositAmount = 1.4m;
decimal quoteDepositAmount = 1000;
Balance user1QuoteInitialBalance = new Balance(quoteCurrency, user1Account, quoteDepositAmount, quoteDepositAmount);
Balance user2QuoteInitialBalance = new Balance(quoteCurrency, user2Account, quoteDepositAmount, quoteDepositAmount);
fundsPersistenceRepository.SaveOrUpdate(user1QuoteInitialBalance);
fundsPersistenceRepository.SaveOrUpdate(user2QuoteInitialBalance);
// Deposit
Deposit deposit1 = new Deposit(baseCurrency, depositIdGeneratorService.GenerateId(), DateTime.Now,
DepositType.Default, baseDepositAmount, 0, TransactionStatus.Pending, user1Account,
new TransactionId("1"), new BitcoinAddress("bitcoin1"));
deposit1.IncrementConfirmations(7);
fundsPersistenceRepository.SaveOrUpdate(deposit1);
Deposit deposit2 = new Deposit(baseCurrency, depositIdGeneratorService.GenerateId(), DateTime.Now,
DepositType.Default, baseDepositAmount, 0, TransactionStatus.Pending, user2Account,
new TransactionId("3"), new BitcoinAddress("bitcoin3"));
deposit2.IncrementConfirmations(7);
fundsPersistenceRepository.SaveOrUpdate(deposit2);
// Retrieve Base Currency balance for user 1
bool depositResponse = fundsValidationService.DepositConfirmed(deposit1);
Assert.IsTrue(depositResponse);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(deposit1.Amount, balance.CurrentBalance);
Assert.AreEqual(deposit1.Amount, balance.AvailableBalance);
Assert.AreEqual(balance.PendingBalance, 0);
// Retrieve Quote Currency balance for user 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(user1QuoteInitialBalance.CurrentBalance, balance.CurrentBalance);
Assert.AreEqual(user1QuoteInitialBalance.AvailableBalance, balance.AvailableBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Retrieve BTC balance for user 2
depositResponse = fundsValidationService.DepositConfirmed(deposit2);
Assert.IsTrue(depositResponse);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(deposit2.Amount, balance.CurrentBalance);
Assert.AreEqual(deposit2.Amount, balance.AvailableBalance);
Assert.AreEqual(balance.PendingBalance, 0);
// Retrieve USD balance for user 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(user2QuoteInitialBalance.CurrentBalance, balance.CurrentBalance);
Assert.AreEqual(user2QuoteInitialBalance.AvailableBalance, balance.AvailableBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Order Validation for User 1's Account
decimal volume = 1.2m;
decimal price = 590;
string buy = "buy";
string sell = "sell";
string buyOrderId = "buy123";
string sellOrderId = "sell123";
bool validationResponse = fundsValidationService.ValidateFundsForOrder(user1Account, baseCurrency, quoteCurrency,
volume, price, buy, buyOrderId);
Assert.IsTrue(validationResponse);
decimal user1Fee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, user1Account, volume, price);
decimal user2Fee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, user2Account, volume, price);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Quote Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount - (volume * price), balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount, balance.CurrentBalance);
Assert.AreEqual(volume * price, balance.PendingBalance);
// Validation of User 2's order
validationResponse = fundsValidationService.ValidateFundsForOrder(user2Account, baseCurrency, quoteCurrency,
volume, price, sell, sellOrderId);
Assert.IsTrue(validationResponse);
// Base Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount - volume, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount, balance.CurrentBalance);
Assert.AreEqual(volume, balance.PendingBalance);
// Quote Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount, balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
string tradeId = "tradeid123";
bool tradeExecutedResponse = fundsValidationService.TradeExecuted(baseCurrency.Name, quoteCurrency.Name,
volume, price, DateTime.Now, tradeId, user1Account.Value, user2Account.Value, buyOrderId, sellOrderId);
Assert.IsTrue(tradeExecutedResponse);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Quote Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount - (volume * price) - user1Fee, balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount - (volume * price) - user1Fee, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Base Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount - (volume), balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount - (volume), balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Quote Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount + (volume * price) - user2Fee, balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount + (volume * price) - user2Fee, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
decimal withdrawAmount = 0.3M;
// Withdraw Base Currency
Withdraw validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(user1Account,
baseCurrency, withdrawAmount, new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
Assert.IsNotNull(validateFundsForWithdrawal);
WithdrawFees withdrawFee = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(baseCurrency.Name);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume, balance.CurrentBalance);
Assert.AreEqual(withdrawAmount, balance.PendingBalance);
bool withdrawalExecuted = fundsValidationService.WithdrawalExecuted(validateFundsForWithdrawal);
Assert.IsTrue(withdrawalExecuted);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// EXCEPTION OCCURS HERE when the user tries to withdraw more than their remaining limit
// Withdraw will fail because the amount requested is greater than the maximum limit threshold
validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(user1Account,
baseCurrency, baseDepositAmount + volume /*Excluding previous withdrawal amount*/,
new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
Assert.IsNull(validateFundsForWithdrawal);
// Base Currency for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
}
