public void AssignDepositLimitsTest_ChecksThatDepositLimitsAreAssignedProperlyWhenLevel1IsNotVerifiedAndBalanceIsAlreadyPresent_VerifiesThroughReturnedValues()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
StubTierLevelRetrievalService tierLevelRetrieval = (StubTierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"];
tierLevelRetrieval.SetTierLevel("Tier 0");
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 0", LimitsCurrency.Default.ToString());
Assert.IsNotNull(depositLimit);
Assert.AreEqual(0, depositLimit.DailyLimit);
Assert.AreEqual(0, depositLimit.MonthlyLimit);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
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(0, depositLimitThresholds.CurrentBalance);
Assert.AreEqual(0, depositLimitThresholds.MaximumDeposit);
}
public void AssignWithdrawLimitsTest_TestsIfWithdrawLimitsGetAsignedProperlyWhenTier1IsNotVerified_VerifiesThroughReturnedValue()
{
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel0);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", LimitsCurrency.Default.ToString());
Assert.IsNotNull(withdrawLimit);
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(0, withdrawLimitRepresentation.DailyLimit);
Assert.AreEqual(0, withdrawLimitRepresentation.MonthlyLimit);
Assert.AreEqual(0, withdrawLimitRepresentation.DailyLimitUsed);
Assert.AreEqual(0, withdrawLimitRepresentation.MonthlyLimitUsed);
Assert.AreEqual(0, withdrawLimitRepresentation.CurrentBalance);
Assert.AreEqual(withdrawFees.Fee, withdrawLimitRepresentation.Fee);
Assert.AreEqual(withdrawFees.MinimumAmount, withdrawLimitRepresentation.MinimumAmount);
Assert.AreEqual(0, withdrawLimitRepresentation.Withheld);
Assert.AreEqual(0, withdrawLimitRepresentation.MaximumWithdraw);
}
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 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);
}
public void DepositAddressCreationFailedTest_TestsIfDepositAddressIsActuallyNotCreatedIfTier1IsNotVerified_VerfiesThroughExceptionRaised()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel0);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
depositApplicationService.GenarateNewAddress(new GenerateNewAddressCommand(accountId.Value, currency.Name));
}
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 WithdrawFailedTest_TestsIfWithdrawFailsWhenTirLevelIsNotHighEnough_VerifiesThroughDatabaseQueries()
{
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel0);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
decimal amount = 1.02m;
withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(accountId.Value, currency.Name,
currency.IsCryptoCurrency,
bitcoinAddress.Value, amount));
}
public void AssignWithdrawLimitsTest_TestsIfWithdrawLimitsGetAsignedProperlyWhenInvalidTierLevelIsSpecified_VerifiesThroughReturnedValue()
{
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel("Tier 6");
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
WithdrawFees withdrawFees = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name);
Assert.IsNotNull(withdrawFees);
withdrawApplicationService.GetWithdrawLimitThresholds(accountId.Value, currency.Name);
}
public void AssignDepositLimitsTest_ChecksThatDepositLimitsAreNotAssignedWhenNoDepositLimitIsFound_VerifiesThroughReturnedValues()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
StubTierLevelRetrievalService tierLevelRetrieval = (StubTierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"];
// Specify invalid tier level
tierLevelRetrieval.SetTierLevel("Tier 6");
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 0", LimitsCurrency.Default.ToString());
Assert.IsNotNull(depositLimit);
Assert.AreEqual(0, depositLimit.DailyLimit);
Assert.AreEqual(0, depositLimit.MonthlyLimit);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
// Exception occurs here because there is no such level as Tier 6
depositApplicationService.GetThresholdLimits(accountId.Value, currency.Name);
}
public void DepositArrivedStandaloneTest_ChecksThatNewDepositInstanceIsCreatedAsExpectedWhenANewTrnasactionComesIn_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"];
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");
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 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);
}
public void DepositAddressCreationSuccessTest_TestsIfDepositAddressIsActuallyCreatedIfTier1IsVerified_VerfiesThroughReturnValueAndDatabaseQuery()
{
IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"];
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
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);
DepositAddressRepresentation addressResponse = depositApplicationService.GenarateNewAddress(new GenerateNewAddressCommand(accountId.Value, currency.Name));
Assert.IsNotNull(addressResponse);
Assert.AreEqual(AddressStatus.New.ToString(), addressResponse.Status);
List <DepositAddress> depositAddresses = depositAddressRepository.GetDepositAddressByAccountIdAndCurrency(accountId, currency.Name);
Assert.AreEqual(1, depositAddresses.Count);
Assert.AreEqual(accountId.Value, depositAddresses.Single().AccountId.Value);
Assert.AreEqual(currency.Name, depositAddresses.Single().Currency.Name);
Assert.AreEqual(AddressStatus.New, depositAddresses.Single().Status);
}
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 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 void WithdrawExecutedEventTest_ChecksThatTheEventIsProperlyRaisedAndHandledWhenWithdrawIsSubmittedToTheNetwork_VerifiesThroughRaisedEvent()
{
// Withdraw is submitted and upon submission to network an event is raised confirming withdrawal execution which
// is handled and balance is updated. This whole process of events firing and balance validation is checked by this
// test case
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"];
IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"];
IClientInteractionService clientInteractionService = (IClientInteractionService)ContextRegistry.GetContext()["ClientInteractionService"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
AccountId accountId = new AccountId(123);
Currency currency = new Currency(CurrencyConstants.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);
bool withdrawEventRaised = false;
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
Withdraw receivedWithdraw = null;
clientInteractionService.WithdrawExecuted += delegate(Withdraw incomingWithdraw)
{
withdrawEventRaised = true;
receivedWithdraw = incomingWithdraw;
manualResetEvent.Set();
};
CommitWithdrawResponse commitWithdrawResponse = withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount));
Assert.IsNotNull(commitWithdrawResponse);
Assert.IsTrue(commitWithdrawResponse.CommitSuccessful);
manualResetEvent.WaitOne();
// Apply assertions after event has been handled
Assert.IsTrue(withdrawEventRaised);
Assert.IsNotNull(receivedWithdraw);
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.Confirmed, withdraw.Status);
Assert.AreEqual(receivedWithdraw.AccountId.Value, withdraw.AccountId.Value);
Assert.AreEqual(receivedWithdraw.TransactionId.Value, withdraw.TransactionId.Value);
Assert.AreEqual(receivedWithdraw.BitcoinAddress.Value, withdraw.BitcoinAddress.Value);
Assert.AreEqual(receivedWithdraw.Currency.Name, withdraw.Currency.Name);
Assert.AreEqual(TransactionStatus.Confirmed, withdraw.Status);
Assert.AreEqual(receivedWithdraw.Amount, withdraw.Amount);
Assert.AreEqual(receivedWithdraw.WithdrawId, withdraw.WithdrawId);
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) - (amount), balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
}