/// <summary> /// Add new Address /// </summary> /// <param name="addAddressCommand"></param> /// <returns></returns> public WithdrawAddressResponse AddAddress(AddAddressCommand addAddressCommand) { if (addAddressCommand.BitcoinAddress.Length < 26 || addAddressCommand.BitcoinAddress.Length > 34) { return(new WithdrawAddressResponse(false, "Invalid address")); } List <WithdrawAddress> withdrawAddresses = _withdrawAddressRepository.GetWithdrawAddressByAccountIdAndCurrency( new AccountId(addAddressCommand.AccountId), new Currency(addAddressCommand.Currency)); foreach (var address in withdrawAddresses) { if (address.BitcoinAddress.Value == addAddressCommand.BitcoinAddress || address.Description == addAddressCommand.Description) { return(new WithdrawAddressResponse(false, "Duplicate Entry")); } } // Create a new address and save in the database WithdrawAddress withdrawAddress = new WithdrawAddress(new Currency(addAddressCommand.Currency), new BitcoinAddress(addAddressCommand.BitcoinAddress), addAddressCommand.Description, new AccountId(addAddressCommand.AccountId), DateTime.Now); _fundsPersistenceRepository.SaveOrUpdate(withdrawAddress); DepositAddress depositAddress = _depositAddressRepository.GetDepositAddressByAddress(new BitcoinAddress(addAddressCommand.BitcoinAddress)); if (depositAddress != null) { depositAddress.StatusUsed(); _fundsPersistenceRepository.SaveOrUpdate(depositAddress); } return(new WithdrawAddressResponse(true, "Address Saved")); }
public void SaveDepositAddressesAndRetreiveByAccountIdTest_SavesObjectsToDatabase_ChecksIfTheyAreAsExpected() { DepositAddress deposit = new DepositAddress(new Currency("XBT", true), new BitcoinAddress("iambitcoin123"), AddressStatus.New, DateTime.Now, new AccountId(1)); _persistanceRepository.SaveOrUpdate(deposit); DepositAddress deposit2 = new DepositAddress(new Currency("XBT", true), new BitcoinAddress("iambitcoin123"), AddressStatus.New, DateTime.Now, new AccountId(1)); Thread.Sleep(500); _persistanceRepository.SaveOrUpdate(deposit2); List <DepositAddress> retrievedDepositAddressList = _depositAddressRepository.GetDepositAddressByAccountId(new AccountId(1)); Assert.IsNotNull(retrievedDepositAddressList); Assert.AreEqual(2, retrievedDepositAddressList.Count); Assert.AreEqual(deposit.BitcoinAddress.Value, retrievedDepositAddressList[0].BitcoinAddress.Value); Assert.AreEqual(deposit.Status, retrievedDepositAddressList[0].Status); Assert.AreEqual(deposit.AccountId.Value, retrievedDepositAddressList[0].AccountId.Value); Assert.AreEqual(deposit.BitcoinAddress.Value, retrievedDepositAddressList[1].BitcoinAddress.Value); Assert.AreEqual(deposit2.Status, retrievedDepositAddressList[1].Status); Assert.AreEqual(deposit2.AccountId.Value, retrievedDepositAddressList[1].AccountId.Value); }
public void SaveWithdrawAddressesAndRetreiveByAccountIdTest_SavesMultipleObjectsToDatabase_ChecksIfRetreivedOutputIsAsExpected() { WithdrawAddress withdrawAddress = new WithdrawAddress(new Currency("XBT", true), new BitcoinAddress("iambitcoin123"), "Description is for dummies", new AccountId(1), DateTime.Now); _persistanceRepository.SaveOrUpdate(withdrawAddress); WithdrawAddress deposit2 = new WithdrawAddress(new Currency("XBT", true), new BitcoinAddress("321nioctibmai"), "Description is for champs", new AccountId(1), DateTime.Now); Thread.Sleep(500); _persistanceRepository.SaveOrUpdate(deposit2); List <WithdrawAddress> retrievedWithdrawAddressList = _withdrawAddressRepository.GetWithdrawAddressByAccountId(new AccountId(1)); Assert.IsNotNull(retrievedWithdrawAddressList); Assert.AreEqual(2, retrievedWithdrawAddressList.Count); Assert.AreEqual(withdrawAddress.BitcoinAddress.Value, retrievedWithdrawAddressList[0].BitcoinAddress.Value); Assert.AreEqual(withdrawAddress.Description, retrievedWithdrawAddressList[0].Description); Assert.AreEqual(withdrawAddress.AccountId.Value, retrievedWithdrawAddressList[0].AccountId.Value); Assert.AreEqual(deposit2.BitcoinAddress.Value, retrievedWithdrawAddressList[1].BitcoinAddress.Value); Assert.AreEqual(deposit2.Description, retrievedWithdrawAddressList[1].Description); Assert.AreEqual(deposit2.AccountId.Value, retrievedWithdrawAddressList[1].AccountId.Value); }
public void SaveWithdrawLimitAndRetreiveByTierLevelTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected() { WithdrawLimit withdrawLimit = new WithdrawLimit("tierlevel1", 4000, 500); _persistanceRepository.SaveOrUpdate(withdrawLimit); WithdrawLimit retrievedWithdrawLimit = _withdrawLimitRepository.GetWithdrawLimitByTierLevel("tierlevel1"); Assert.IsNotNull(retrievedWithdrawLimit); Assert.AreEqual(withdrawLimit.DailyLimit, retrievedWithdrawLimit.DailyLimit); Assert.AreEqual(withdrawLimit.MonthlyLimit, retrievedWithdrawLimit.MonthlyLimit); }
public void SaveWithdrawFeesAndRetreiveByCurrencyNameTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected() { WithdrawFees withdrawFees = new WithdrawFees(new Currency("LTC", true), 4000, 500); _persistanceRepository.SaveOrUpdate(withdrawFees); WithdrawFees retrievedWithdrawFees = _withdrawFeesRepository.GetWithdrawFeesByCurrencyName("LTC"); Assert.IsNotNull(retrievedWithdrawFees); Assert.AreEqual(withdrawFees.MinimumAmount, retrievedWithdrawFees.MinimumAmount); Assert.AreEqual(withdrawFees.Fee, retrievedWithdrawFees.Fee); }
public void SaveFeeAndRetreiveByCurrencyPairNameTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected() { Fee fee = new Fee("LTC/BTC", 4000, 500); _persistanceRepository.SaveOrUpdate(fee); List <Fee> retrievedFee = _feeRepository.GetFeeByCurrencyPair("LTC/BTC"); Assert.IsNotNull(retrievedFee); Assert.AreEqual(fee.PercentageFee, retrievedFee[0].PercentageFee); Assert.AreEqual(fee.Amount, retrievedFee[0].Amount); }
public void SaveWithdrawalAndRetreiveByIdTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected() { Withdraw withdraw = new Withdraw(new Currency("LTC", true), "1234", DateTime.Now, WithdrawType.Bitcoin, 2000, 0.005m, TransactionStatus.Pending, new AccountId(1), new BitcoinAddress("bitcoin123")); _persistanceRepository.SaveOrUpdate(withdraw); Withdraw retrievedDeposit = _withdrawRepository.GetWithdrawByWithdrawId("1234"); Assert.IsNotNull(retrievedDeposit); int id = retrievedDeposit.Id; retrievedDeposit.SetAmount(777); _persistanceRepository.SaveOrUpdate(retrievedDeposit); retrievedDeposit = _withdrawRepository.GetWithdrawById(id); Assert.AreEqual(withdraw.Currency.Name, retrievedDeposit.Currency.Name); Assert.AreEqual(withdraw.WithdrawId, retrievedDeposit.WithdrawId); Assert.AreEqual(withdraw.Type, retrievedDeposit.Type); Assert.AreEqual(777, retrievedDeposit.Amount); Assert.AreEqual(withdraw.Fee, retrievedDeposit.Fee); Assert.AreEqual(withdraw.Status, retrievedDeposit.Status); Assert.AreEqual(withdraw.AccountId.Value, retrievedDeposit.AccountId.Value); }
public void SaveDepositAddressesAndRetreiveByAccountIdTest_SavesObjectsToDatabase_ChecksIfTheyAreAsExpected() { Balance balance = new Balance(new Currency("LTC", true), new AccountId(1), 5000, 4000); _persistanceRepository.SaveOrUpdate(balance); Balance retrievedDepositAddressList = _balanceRepository.GetBalanceByCurrencyAndAccountId(balance.Currency, balance.AccountId); Assert.IsNotNull(retrievedDepositAddressList); Assert.AreEqual(balance.AvailableBalance, retrievedDepositAddressList.AvailableBalance); Assert.AreEqual(balance.CurrentBalance, retrievedDepositAddressList.CurrentBalance); Assert.AreEqual(balance.PendingBalance, retrievedDepositAddressList.PendingBalance); }
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); }
public void WithdrawFailedTest_TestsIfWithdrawFailsBecauseOfNotEnoughBalance_VerifiesThroughDatabaseQueries() { IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"]; StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService; IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; Assert.IsNotNull(tierLevelRetrievalService); tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1); AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1, LimitsCurrency.Default.ToString()); Assert.IsNotNull(withdrawLimit); decimal amount = withdrawLimit.DailyLimit + 0.001M; Balance balance = new Balance(currency, accountId, amount - 1, amount - 1); fundsPersistenceRepository.SaveOrUpdate(balance); withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount)); }
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 DepositArrivedAndConfirmedTest_ChecksThatANewDepositInstanceIsCreatedAndConfirmedAsExpected_VerifiesThroughDatabaseQuery() { IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); string category = BitcoinConstants.ReceiveCategory; DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default"); Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later"); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); // Provide the amount which is greater than the daily limit transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, depositLimit.DailyLimit - 0.01M, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); // Deposit Transaction first arrival Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, deposit.Amount); Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(TransactionStatus.Pending, deposit.Status); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); // Deposit Confirmation depositApplicationService.OnDepositConfirmed(transactionId.Value, 7); deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, deposit.Amount); Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(TransactionStatus.Confirmed, deposit.Status); // Balance instance now will have been created balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, balance.AvailableBalance); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, balance.CurrentBalance); Assert.AreEqual(0, balance.PendingBalance); Assert.IsFalse(balance.IsFrozen); }
public void TestBalanceQueryService_WhenAccountIdIsSupplied_ItShouldReturnListOfBalanceDetails() { IFundsPersistenceRepository repository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; Balance balance = new Balance(new Currency("BTC"), new AccountId(1), 1000, 1000); Balance balance2 = new Balance(new Currency("LTC"), new AccountId(1), 2000, 2000); repository.SaveOrUpdate(balance); repository.SaveOrUpdate(balance2); IBalanceQueryService _balanceQueryService = (IBalanceQueryService)ContextRegistry.GetContext()["BalanceQueryService"]; List <BalanceDetails> balanceDetailses = _balanceQueryService.GetBalances(new AccountId(1)); Assert.NotNull(balanceDetailses); Assert.AreEqual(2, balanceDetailses.Count); Assert.AreEqual(balanceDetailses[0].Currency, "BTC"); Assert.AreEqual(balanceDetailses[0].Balance, 1000); Assert.AreEqual(balanceDetailses[1].Currency, "LTC"); Assert.AreEqual(balanceDetailses[1].Balance, 2000); }
public void DepositArrivedStandaloneFailedTest_TestsIfTheOperationIsAbortedWhenAmountIshigherThanThresholdLimit_VerifiesThroughQueryingDatabaseIsntances() { // Tests the event handler DepositArrived by directly sending data IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService; Assert.IsNotNull(tierLevelRetrievalService); tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1); AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1, LimitsCurrency.Default.ToString()); decimal amount = depositLimit.DailyLimit + 0.001M; string category = BitcoinConstants.ReceiveCategory; DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId); Assert.AreEqual(ledgers.Count, 0); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(amount, deposit.Amount); Assert.AreEqual(currency.Name, deposit.Currency.Name); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value); Assert.AreEqual(TransactionStatus.Frozen, deposit.Status); // Confirm that the balance for the user has been frozen for this account balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.IsTrue(balance.IsFrozen); }
/// <summary> /// Creates a ledger entry for one currency of one of the two order sids of a trade /// </summary> /// <param name="currency"></param> /// <param name="amount"></param> /// <param name="amountInUsd"> </param> /// <param name="fee"></param> /// <param name="balance"></param> /// <param name="executionDate"></param> /// <param name="orderId"></param> /// <param name="tradeId"></param> /// <param name="accountId"></param> /// <param name="isBaseCurrencyInTrade"> </param> /// <returns></returns> public bool CreateLedgerEntry(Currency currency, decimal amount, decimal amountInUsd, decimal fee, decimal balance, DateTime executionDate, string orderId, string tradeId, AccountId accountId, bool isBaseCurrencyInTrade) { try { Ledger ledger = new Ledger(_ledgerIdGeneraterService.GenerateLedgerId(), executionDate, LedgerType.Trade, currency, amount, amountInUsd, fee, balance, tradeId, orderId, isBaseCurrencyInTrade, accountId); _fundsPersistenceRepository.SaveOrUpdate(ledger); Log.Debug(string.Format("Ledger Trade Transaction saved: Currency = {0} | Account ID = {1} | " + "Amount = {2} | Fee = {3} | Balance = {4} | TradeID = {5} | OrderID = {6}", currency.Name, accountId.Value, amount, fee, balance, tradeId, orderId)); return(true); } catch (Exception exception) { Log.Error(exception); return(false); } }
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); }
public void DepositAndWithdrawTest_TestsIfThingsGoAsExpectedWhenWithdrawIsMadeAfterDeposit_ChecksBalanceToVerify() { // Scenario: Confirmed Deposit --> Withdraw --> Check Balance 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"]; AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); // Deposit Deposit deposit = new Deposit(currency, depositIdGeneratorService.GenerateId(), DateTime.Now, DepositType.Default, 1.4m, 0, TransactionStatus.Pending, accountId, new TransactionId("123"), new BitcoinAddress("bitcoin123")); deposit.IncrementConfirmations(7); fundsPersistenceRepository.SaveOrUpdate(deposit); // Retrieve balance Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); bool depositResponse = fundsValidationService.DepositConfirmed(deposit); Assert.IsTrue(depositResponse); // Check balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual(balance.CurrentBalance, deposit.Amount); Assert.AreEqual(balance.AvailableBalance, deposit.Amount); Assert.AreEqual(balance.PendingBalance, 0); // Withdraw Withdraw validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(accountId, currency, 1.3M, new TransactionId("transaction123"), new BitcoinAddress("bitcoin123")); Assert.IsNotNull(validateFundsForWithdrawal); bool withdrawalExecuted = fundsValidationService.WithdrawalExecuted(validateFundsForWithdrawal); Assert.IsTrue(withdrawalExecuted); WithdrawFees withdrawFee = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name); // Check balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual(Math.Round(1.4M - 1.3M, 5), Math.Round(balance.CurrentBalance, 5)); Assert.AreEqual(Math.Round(1.4M - 1.3M, 5), Math.Round(balance.AvailableBalance, 5)); Assert.AreEqual(0, balance.PendingBalance); }
public void SaveWithdrawFeesAndRetreiveByIdTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected() { WithdrawFees retrievedWithdrawFees = _withdrawFeesRepository.GetWithdrawFeesByCurrencyName("LTC"); Assert.IsNotNull(retrievedWithdrawFees); int id = retrievedWithdrawFees.Id; _persistanceRepository.SaveOrUpdate(retrievedWithdrawFees); retrievedWithdrawFees = _withdrawFeesRepository.GetWithdrawFeesById(id); Assert.Greater(retrievedWithdrawFees.MinimumAmount, 0); Assert.Greater(retrievedWithdrawFees.Fee, 0); }
public void OnDepositConfirmed(string transactionId, int confirmations) { Log.Debug(string.Format("Deposit Confirmation Event received: Transaction ID = {0}, Confirmations = {1}", transactionId, confirmations)); // Get all deposits Deposit deposit = _depositRepository.GetDepositByTransactionId(new TransactionId(transactionId)); if (deposit != null) { // Set the confirmations deposit.SetConfirmations(confirmations); Log.Debug(string.Format("Confirmations set: Deposit ID = {0}, Confirmations = {1}", deposit.DepositId, deposit.Confirmations)); try { // If enough confirmations are not available for the current deposit yet if (deposit.Confirmations < 7) { Log.Debug(string.Format("Deposit Confirmations updated: Transaction ID = {0}, Confirmations = {1}", transactionId, confirmations)); // Save in database _fundsPersistenceRepository.SaveOrUpdate(deposit); } // If enough confirmations are available, forward to the FundsValidationService to proceed with the // ledger transation of this deposit else { Log.Debug(string.Format("7 Confirmations received: Transaction ID = {0}", transactionId)); _fundsValidationService.DepositConfirmed(deposit); Log.Debug(string.Format("Deposit Verified: Transaction ID = {0}, Confirmations = {1}," + " Currency = {2}, Date Received = {3}, Address = {4}, Account ID = {5}", transactionId, confirmations, deposit.Currency.Name, deposit.Date, deposit.BitcoinAddress, deposit.AccountId.Value)); } } catch (Exception ex) { Log.Error("Error while adding Confirmations to deposit: " + ex.Message); } } else { Log.Error(string.Format("Could not finds deposit in database: Transaction ID = {0}", transactionId)); } }
public void WithdrawSuccessfulTest_TestsIfWithdrawIsSuccessfulWhenTierLevelIsHighEnough_VerifiesThroughDatabaseQueries() { IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"]; IWithdrawRepository withdrawRepository = (IWithdrawRepository)ContextRegistry.GetContext()["WithdrawRepository"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"]; StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService; IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"]; Assert.IsNotNull(tierLevelRetrievalService); tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1); AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1, LimitsCurrency.Default.ToString()); Assert.IsNotNull(withdrawLimit); decimal amount = withdrawLimit.DailyLimit; Balance balance = new Balance(currency, accountId, amount + 1, amount + 1); fundsPersistenceRepository.SaveOrUpdate(balance); CommitWithdrawResponse commitWithdrawResponse = withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount)); Assert.IsNotNull(commitWithdrawResponse); Assert.IsTrue(commitWithdrawResponse.CommitSuccessful); Withdraw withdraw = withdrawRepository.GetWithdrawByWithdrawId(commitWithdrawResponse.WithdrawId); Assert.IsNotNull(withdraw); Assert.AreEqual(accountId.Value, withdraw.AccountId.Value); Assert.AreEqual(currency.Name, withdraw.Currency.Name); Assert.AreEqual(currency.IsCryptoCurrency, withdraw.Currency.IsCryptoCurrency); Assert.AreEqual(amount - withdraw.Fee, withdraw.Amount); Assert.AreEqual(TransactionStatus.Pending, withdraw.Status); WithdrawFees withdrawFees = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name); Assert.IsNotNull(withdrawFees); balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual((amount + 1) - (amount), balance.AvailableBalance); Assert.AreEqual(amount + 1, balance.CurrentBalance); Assert.AreEqual(amount, balance.PendingBalance); }
public void AssignWithdrawLimitsTest_TestsIfWithdrawLimitsGetAsignedProperlyWhenTier1IsVerifiedAndBalanceIsMoreThanDailyLimit_VerifiesThroughReturnedValue() { IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"]; IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"]; StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService; Assert.IsNotNull(tierLevelRetrievalService); tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1); AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", LimitsCurrency.Default.ToString()); Assert.IsNotNull(withdrawLimit); decimal amount = withdrawLimit.DailyLimit + 0.001M; Balance balance = new Balance(currency, accountId, amount, amount); fundsPersistenceRepository.SaveOrUpdate(balance); WithdrawFees withdrawFees = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name); Assert.IsNotNull(withdrawFees); WithdrawLimitRepresentation withdrawLimitRepresentation = withdrawApplicationService.GetWithdrawLimitThresholds(accountId.Value, currency.Name); Assert.IsNotNull(withdrawLimitRepresentation); Assert.AreEqual(currency.Name, withdrawLimitRepresentation.Currency); Assert.AreEqual(accountId.Value, withdrawLimitRepresentation.AccountId); Assert.AreEqual(withdrawLimit.DailyLimit, withdrawLimitRepresentation.DailyLimit); Assert.AreEqual(withdrawLimit.DailyLimit, withdrawLimitRepresentation.DailyLimit); Assert.AreEqual(withdrawLimit.MonthlyLimit, withdrawLimitRepresentation.MonthlyLimit); Assert.AreEqual(0, withdrawLimitRepresentation.DailyLimitUsed); Assert.AreEqual(0, withdrawLimitRepresentation.MonthlyLimitUsed); Assert.AreEqual(amount, withdrawLimitRepresentation.CurrentBalance); Assert.AreEqual(withdrawFees.Fee, withdrawLimitRepresentation.Fee); Assert.AreEqual(withdrawFees.MinimumAmount, withdrawLimitRepresentation.MinimumAmount); Assert.AreEqual(0, withdrawLimitRepresentation.Withheld); Assert.AreEqual(withdrawLimit.DailyLimit, withdrawLimitRepresentation.MaximumWithdraw); }
public void SaveDepositAndRetreiveByIdTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected() { Deposit deposit = new Deposit(new Currency("LTC", true), "1234", DateTime.Now, DepositType.Default, 2000, 0.005m, TransactionStatus.Pending, new AccountId(1), new TransactionId("transact123"), new BitcoinAddress("address123")); _persistanceRepository.SaveOrUpdate(deposit); Deposit retrievedDeposit = _depositRepository.GetDepositByDepositId("1234"); Assert.IsNotNull(retrievedDeposit); int id = retrievedDeposit.Id; retrievedDeposit.SetAmount(777); _persistanceRepository.SaveOrUpdate(retrievedDeposit); retrievedDeposit = _depositRepository.GetDepositById(id); Assert.AreEqual(deposit.Currency.Name, retrievedDeposit.Currency.Name); Assert.AreEqual(deposit.DepositId, retrievedDeposit.DepositId); Assert.AreEqual(deposit.Type, retrievedDeposit.Type); Assert.AreEqual(777, retrievedDeposit.Amount); Assert.AreEqual(deposit.Fee, retrievedDeposit.Fee); Assert.AreEqual(deposit.Status, retrievedDeposit.Status); Assert.AreEqual(deposit.AccountId.Value, retrievedDeposit.AccountId.Value); }
public void DepositArrivedFailTest_VerifiesThatNewDepositWithAMountGreaterThanLimitsIsSuspendedAndAccountBalanceFrozen_VerifiesThroughDatabaseQuery() { IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); string category = BitcoinConstants.ReceiveCategory; DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default"); Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later"); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); // Provide the amount which is greater than the daily limit transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, depositLimit.DailyLimit + 0.001M, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(TransactionStatus.Frozen, deposit.Status); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.IsTrue(balance.IsFrozen); }
public void AssignDepositLimits2Test_ChecksThatDepositLimitsAreAssignedProperlyWhenLevel1IsVerifiedAndBalanceIsAlreadyPresent_VerifiesThroughReturnedValues() { IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", LimitsCurrency.Default.ToString()); AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); decimal balanceAmount = 100; Balance balance = new Balance(currency, accountId, balanceAmount, balanceAmount); fundsPersistenceRepository.SaveOrUpdate(balance); DepositLimitThresholdsRepresentation depositLimitThresholds = depositApplicationService.GetThresholdLimits(accountId.Value, currency.Name); Assert.IsNotNull(depositLimitThresholds); Assert.AreEqual(depositLimit.DailyLimit, depositLimitThresholds.DailyLimit); Assert.AreEqual(depositLimit.MonthlyLimit, depositLimitThresholds.MonthlyLimit); Assert.AreEqual(0, depositLimitThresholds.DailyLimitUsed); Assert.AreEqual(0, depositLimitThresholds.MonthlyLimitUsed); Assert.AreEqual(balanceAmount, depositLimitThresholds.CurrentBalance); Assert.AreEqual(depositLimit.DailyLimit, depositLimitThresholds.MaximumDeposit); }
public void DepositArrivedStandaloneTest_TestsIfTheOperationProceedsAsExpectedWHenANewDepositArrives_VerifiesThroughQueryingDatabaseIsntances() { // Tests the event handler DepositArrived by directly sending data IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; StubTierLevelRetrievalService tierLevelRetrieval = (StubTierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"]; tierLevelRetrieval.SetTierLevel(TierConstants.TierLevel1); AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1, LimitsCurrency.Default.ToString()); decimal amount = depositLimit.DailyLimit - 0.001M; string category = BitcoinConstants.ReceiveCategory; DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId); Assert.AreEqual(ledgers.Count, 0); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); ManualResetEvent manualResetEvent = new ManualResetEvent(false); manualResetEvent.WaitOne(2000); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(deposit.Amount, amount); Assert.AreEqual(deposit.Currency.Name, currency.Name); Assert.IsTrue(deposit.Currency.IsCryptoCurrency); Assert.AreEqual(deposit.TransactionId.Value, transactionId.Value); Assert.AreEqual(deposit.BitcoinAddress.Value, bitcoinAddress.Value); Assert.AreEqual(deposit.Status, TransactionStatus.Pending); depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress); Assert.IsNotNull(depositAddress); Assert.AreEqual(depositAddress.Status, AddressStatus.Used); balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId); Assert.AreEqual(ledgers.Count, 0); }
public bool ValidateFundsForOrder(AccountId accountId, Currency baseCurrency, Currency quoteCurrency, decimal volume, decimal price, string orderSide, string orderId) { Balance baseCurrencyBalance = GetBalanceForAccountId(accountId, baseCurrency); Balance quoteCurrencyBalance = GetBalanceForAccountId(accountId, quoteCurrency); if (baseCurrencyBalance != null && quoteCurrency != null) { if (orderSide.Equals("buy", StringComparison.OrdinalIgnoreCase)) { // If the order is a buy order, then we need to figure out if we have enough balance in the quote // currency of the currency pairto carry out the order. If we are trading XBT/USD, // If 1 XBT = 101 USD, then if we want to buy 8 XBT coins, then, 8 XBT = 8*101 USD // So we need askPrice(XBT/USD) * Volume(Volume of the order) // Also, we need to check the Available Balance(balance that does not contain pending balance) if (quoteCurrencyBalance.AvailableBalance >= price * volume) { quoteCurrencyBalance.AddPendingTransaction(orderId, PendingTransactionType.Order, -(price * volume)); _fundsPersistenceRepository.SaveOrUpdate(quoteCurrencyBalance); return(true); } } else if (orderSide.Equals("sell", StringComparison.OrdinalIgnoreCase)) { // If we are trading for XBT/USD and want to sell XBT, then we need to check if the Available // balance(does not contain pending balance) for XBT is enough for the order to take place if (baseCurrencyBalance.AvailableBalance >= volume) { baseCurrencyBalance.AddPendingTransaction(orderId, PendingTransactionType.Order, -volume); _fundsPersistenceRepository.SaveOrUpdate(baseCurrencyBalance); return(true); } } } return(false); }
public void SaveLedgerAndRetreiveByIdTest_SavesAnObjectToDatabaseAndGetsThePrimaryKeyIdForDatabase_ChecksIfTheOutputIsAsExpected() { Ledger ledger = new Ledger("1234", DateTime.Now, LedgerType.Trade, new Currency("LTC", true), 1000.543m, 0.005m, 23000, "trade123", "order123", null, null, new AccountId(1)); _persistanceRepository.SaveOrUpdate(ledger); Ledger retrievedLedger = _ledgerRepository.GetLedgerByLedgerId("1234"); Assert.IsNotNull(retrievedLedger); int id = retrievedLedger.Id; _persistanceRepository.SaveOrUpdate(retrievedLedger); retrievedLedger = _ledgerRepository.GetLedgerById(id); Assert.AreEqual(ledger.Currency.Name, retrievedLedger.Currency.Name); Assert.AreEqual(ledger.LedgerId, retrievedLedger.LedgerId); Assert.AreEqual(ledger.LedgerType, retrievedLedger.LedgerType); Assert.AreEqual(ledger.Amount, retrievedLedger.Amount); Assert.AreEqual(ledger.Fee, retrievedLedger.Fee); Assert.AreEqual(ledger.Balance, retrievedLedger.Balance); Assert.AreEqual(ledger.TradeId, retrievedLedger.TradeId); Assert.AreEqual(ledger.OrderId, retrievedLedger.OrderId); Assert.AreEqual(ledger.AccountId.Value, retrievedLedger.AccountId.Value); Assert.IsNull(retrievedLedger.WithdrawId); Assert.IsNull(retrievedLedger.DepositId); }
public void DepositConfirmedTest_TestsIfTheOperationProceedsAsExpectedWhenADepositIsConfirmed_VerifiesThroughQueryingDatabaseIsntances() { IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"]; StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService; if (tierLevelRetrievalService != null) { tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1); } AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); decimal amount = 1.02m; string category = BitcoinConstants.ReceiveCategory; DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId); Assert.AreEqual(ledgers.Count, 0); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(deposit.Amount, amount); Assert.AreEqual(deposit.Currency.Name, currency.Name); Assert.IsTrue(deposit.Currency.IsCryptoCurrency); Assert.AreEqual(deposit.TransactionId.Value, transactionId.Value); Assert.AreEqual(deposit.BitcoinAddress.Value, bitcoinAddress.Value); Assert.AreEqual(TransactionStatus.Pending, deposit.Status); depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress); Assert.IsNotNull(depositAddress); Assert.AreEqual(AddressStatus.Used, depositAddress.Status); balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId); Assert.AreEqual(0, ledgers.Count); depositApplicationService.OnDepositConfirmed(transactionId.Value, 7); deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(deposit.Status, TransactionStatus.Confirmed); balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual(amount, balance.AvailableBalance); Assert.AreEqual(amount, balance.CurrentBalance); Assert.AreEqual(0, balance.PendingBalance); ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId); Assert.AreEqual(1, ledgers.Count); var ledger = ledgers.SingleOrDefault(); Assert.IsNotNull(ledger); Assert.AreEqual(LedgerType.Deposit, ledger.LedgerType); Assert.AreEqual(accountId.Value, ledger.AccountId.Value); Assert.AreEqual(amount, ledger.Amount); Assert.AreEqual(deposit.DepositId, ledger.DepositId); Assert.AreEqual(0, ledger.Fee); }
public void DepositCheckNewTransactionsTest_TestIfDepositHandlingIsDoneAsExpected_VerifiesThroughReturnedValue() { // Submits withdraw to own address, after the first NewTransactionInterval has been elapsed. // Checks if new deposit has been created by the DepositAPplicationService and DepositAddress marked used if (_shouldRunTests) { ICoinClientService coinClientService = (ICoinClientService)ContextRegistry.GetContext()["BitcoinClientService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; Currency currency = new Currency("BTC", true); AccountId accountId = new AccountId(1); string newAddress = coinClientService.CreateNewAddress(); BitcoinAddress bitcoinAddress = new BitcoinAddress(newAddress); DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); // Check that there is no deposit with htis address present List <Deposit> deposits = depositRepository.GetDepositsByBitcoinAddress(bitcoinAddress); Assert.AreEqual(0, deposits.Count); ManualResetEvent manualResetEvent = new ManualResetEvent(false); // Wait for the first interval to elapse, and then withdraw, because only then we will be able to figure if a // new transaction has been received manualResetEvent.WaitOne(Convert.ToInt32(coinClientService.PollingInterval + 3000)); manualResetEvent.Reset(); bool eventFired = false; coinClientService.DepositArrived += delegate(string curr, List <Tuple <string, string, decimal, string> > pendingList) { eventFired = true; manualResetEvent.Set(); }; Withdraw withdraw = new Withdraw(currency, Guid.NewGuid().ToString(), DateTime.Now, WithdrawType.Bitcoin, Amount, 0.001m, TransactionStatus.Pending, accountId, new BitcoinAddress(newAddress)); string withdrawTransactionId = coinClientService.CommitWithdraw(withdraw.BitcoinAddress.Value, withdraw.Amount); Assert.IsNotNull(withdrawTransactionId); Assert.IsFalse(string.IsNullOrEmpty(withdrawTransactionId)); manualResetEvent.WaitOne(); Assert.IsTrue(eventFired); depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress); Assert.IsNotNull(depositAddress); Assert.AreEqual(AddressStatus.Used, depositAddress.Status); // See If DepositApplicationService created the deposit instance deposits = depositRepository.GetDepositsByBitcoinAddress(bitcoinAddress); Deposit deposit = deposits.Single(); Assert.IsNotNull(deposit); Assert.AreEqual(Amount, deposit.Amount); Assert.AreEqual(currency.Name, deposit.Currency.Name); Assert.IsFalse(string.IsNullOrEmpty(deposit.TransactionId.Value)); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(DepositType.Default, deposit.Type); Assert.AreEqual(0, deposit.Confirmations); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(TransactionStatus.Pending, deposit.Status); Assert.AreEqual(withdrawTransactionId, deposit.TransactionId.Value); } }
public void DepositArrivedAndConfirmedEventTest_TestsThatDepositArrivedEventIsHandledAsExpected_VerifiesThroughRaisedEvent() { // Withdraw is submitted and events are actually raised from the CoinClientService // Over the limit deposit so account and deposit are frozen IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IWithdrawRepository withdrawRepository = (IWithdrawRepository)ContextRegistry.GetContext()["WithdrawRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"]; AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default"); Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later"); decimal amount = depositLimit.DailyLimit - 0.001M; ManualResetEvent manualResetEvent = new ManualResetEvent(false); Balance balance = new Balance(currency, accountId, 10, 10); fundsPersistenceRepository.SaveOrUpdate(balance); CommitWithdrawResponse commitWithdrawResponse = withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand( accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount)); Assert.IsNotNull(commitWithdrawResponse); Assert.IsTrue(commitWithdrawResponse.CommitSuccessful); // Get the interval after which the withdraw will be submitted. Once submitted to the StubClientService, the events // of DepositArrived will be raised and handled in Deposit APplicationService, which will create a new Deposit // instance and save in database int withdrawInterval = Convert.ToInt16(ConfigurationManager.AppSettings.Get("WithdrawSubmitInterval")); manualResetEvent.WaitOne(withdrawInterval + 2000); Withdraw withdraw = withdrawRepository.GetWithdrawByWithdrawId(commitWithdrawResponse.WithdrawId); Assert.IsNotNull(withdraw); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(amount - withdraw.Fee, deposit.Amount); Assert.AreEqual(withdraw.TransactionId.Value, deposit.TransactionId.Value); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(TransactionStatus.Confirmed, deposit.Status); balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); // Balance instance now will have been created balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual(0, balance.PendingBalance); Assert.IsFalse(balance.IsFrozen); }