public void DepositEvaluationScenario1Test_VerifiesIfTheEvaluationOfTheLimitsIsBeingDOneProperly_VerifiesThourhgPropetyValues()
{
IDepositLimitEvaluationService depositLimitEvaluationService = new DepositLimitEvaluationService();
Currency currency = new Currency("XBT");
string depositId = "depositid123";
AccountId accountId = new AccountId(123);
decimal dailyLimit = 1000;
decimal monthlyLimit = 5000;
List <Ledger> ledgers = new List <Ledger>();
DepositLimit depositLimit = new DepositLimit("Tier 0", dailyLimit, monthlyLimit);
bool evaluationResponse = depositLimitEvaluationService.EvaluateDepositLimit(900, ledgers, depositLimit);
Assert.IsTrue(evaluationResponse);
Assert.AreEqual(1000, depositLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(0, depositLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(0, depositLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(1000, depositLimitEvaluationService.MaximumDeposit);
Ledger ledger = new Ledger("ledgeris1", DateTime.Now.AddMinutes(-1), LedgerType.Deposit, currency,
900, 0, 900, null, null, null, depositId, accountId);
ledgers.Add(ledger);
evaluationResponse = depositLimitEvaluationService.EvaluateDepositLimit(200, ledgers, depositLimit);
Assert.IsFalse(evaluationResponse);
Assert.AreEqual(1000, depositLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(900, depositLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(900, depositLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(100, depositLimitEvaluationService.MaximumDeposit);
}
/// <summary>
/// Returns true if DepositLimitInfo instances are equal
/// </summary>
/// <param name="other">Instance of DepositLimitInfo to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(DepositLimitInfo other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
DepositLimit == other.DepositLimit ||
DepositLimit != null &&
DepositLimit.Equals(other.DepositLimit)
) &&
(
InputCoinType == other.InputCoinType ||
InputCoinType != null &&
InputCoinType.Equals(other.InputCoinType)
) &&
(
OutputCoinType == other.OutputCoinType ||
OutputCoinType != null &&
OutputCoinType.Equals(other.OutputCoinType)
));
}
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 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);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public MockDepositLimitRepository()
{
DepositLimit depositLimit1 = new DepositLimit("Tier 0", 1000, 5000);
DepositLimit depositLimit2 = new DepositLimit("Tier 1", 1000, 5000);
_depositLimits.Add(depositLimit1);
_depositLimits.Add(depositLimit2);
}
public void DepositEvaluationScenario4Test_VerifiesIfTheEvaluationOfTheLimitsIsBeingDOneProperly_VerifiesThourhgPropetyValues()
{
// Scenario: DailyLimit = 400/1000, MonthlyLimit = 4500/5000 with older deposits present
IDepositLimitEvaluationService depositLimitEvaluationService = new DepositLimitEvaluationService();
Currency currency = new Currency("XBT", true);
string depositId = "depositid123";
AccountId accountId = new AccountId(123);
decimal dailyLimit = 1000;
decimal monthlyLimit = 5000;
List <Ledger> ledgers = new List <Ledger>();
Ledger ledger = new Ledger("ledgerid1", DateTime.Now.AddDays(-29), LedgerType.Deposit, currency,
4100, 0, 1000, null, null, null, depositId, accountId);
Ledger ledger2 = new Ledger("ledgerid2", DateTime.Now.AddMinutes(-1), LedgerType.Deposit, currency,
400, 0, 1000, null, null, null, depositId, accountId);
ledgers.Add(ledger);
ledgers.Add(ledger2);
DepositLimit depositLimit = new DepositLimit("Tier 0", dailyLimit, monthlyLimit);
bool evaluationResponse = depositLimitEvaluationService.EvaluateDepositLimit(400, ledgers, depositLimit);
Assert.IsTrue(evaluationResponse);
Assert.AreEqual(1000, depositLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(400, depositLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(4500, depositLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(500, depositLimitEvaluationService.MaximumDeposit);
evaluationResponse = depositLimitEvaluationService.EvaluateDepositLimit(600, ledgers, depositLimit);
Assert.IsFalse(evaluationResponse);
Assert.AreEqual(1000, depositLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(400, depositLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(4500, depositLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(500, depositLimitEvaluationService.MaximumDeposit);
evaluationResponse = depositLimitEvaluationService.EvaluateDepositLimit(500, ledgers, depositLimit);
Assert.IsTrue(evaluationResponse);
Assert.AreEqual(1000, depositLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(400, depositLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(4500, depositLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(500, depositLimitEvaluationService.MaximumDeposit);
Ledger ledger3 = new Ledger("ledgerid3", DateTime.Now.AddHours(-30), LedgerType.Deposit, currency,
500, 0, 1000, null, null, null, depositId, accountId);
ledgers.Add(ledger3);
evaluationResponse = depositLimitEvaluationService.EvaluateDepositLimit(1, ledgers, depositLimit);
Assert.IsFalse(evaluationResponse);
Assert.AreEqual(1000, depositLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(400, depositLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(5000, depositLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(0, depositLimitEvaluationService.MaximumDeposit);
}
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 SaveDepositLimitAndRetreiveByTierLevelTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
DepositLimit depositLimit = new DepositLimit("tierlevel1", 500, 4000);
_persistanceRepository.SaveOrUpdate(depositLimit);
DepositLimit retrievedDepositLimit = _depositLimitRepository.GetDepositLimitByTierLevel("tierlevel1");
Assert.IsNotNull(retrievedDepositLimit);
Assert.AreEqual(depositLimit.DailyLimit, retrievedDepositLimit.DailyLimit);
Assert.AreEqual(depositLimit.MonthlyLimit, retrievedDepositLimit.MonthlyLimit);
}
/// <summary>
/// Assign the deposit limits
/// </summary>
/// <param name="baseCurrency"></param>
/// <param name="tierLevel"></param>
/// <param name="depositLedgers"></param>
public void AssignDepositLimits(string baseCurrency, string tierLevel, IList <Ledger> depositLedgers)
{
// If the admin has specified the limits to be calculated as the currency itself
if (_adminDefinedLimitsCurrency == LimitsCurrency.Default.ToString())
{
Log.Debug(string.Format("Limits representation Currency is Default(Digital)"));
// Get the Current Deposit limits for this user
DepositLimit depositLimit = _depositLimitRepository.GetLimitByTierLevelAndCurrency(tierLevel,
_adminDefinedLimitsCurrency);
if (depositLimit != null)
{
// Check if the current Deposit transaction is within the Deposit limits
_depositLimitEvaluationService.AssignDepositLimits(depositLedgers, depositLimit);
}
else
{
throw new InvalidOperationException(
string.Format("No Deposit Limit found for Tier: Tier Level = " + tierLevel));
}
}
// If the admin has specified that limtis must be calculated in a FIAT currency
else
{
Log.Debug(string.Format("Limits representation Currency = {0}", _adminDefinedLimitsCurrency));
// Get the Current Deposit limits for this user which will be in a FIAT currency
DepositLimit depositLimit = _depositLimitRepository.GetLimitByTierLevelAndCurrency(tierLevel,
_adminDefinedLimitsCurrency);
if (depositLimit != null)
{
// Get the best bid and best ask
Tuple <decimal, decimal> bestBidBestAsk = _bboCrossContextService.GetBestBidBestAsk(baseCurrency, _adminDefinedLimitsCurrency);
// Return reponse that if the user is allowed to deposit the specified limit of not
// NOTE: If there is no best bid and best ask, then the limits will be speficied in the defauly crypto currency itself
_depositLimitEvaluationService.AssignDepositLimits(depositLedgers, depositLimit,
bestBidBestAsk.Item1, bestBidBestAsk.Item2);
}
else
{
throw new InvalidOperationException(
string.Format("No Deposit Limit found for Tier: Tier Level = " + tierLevel));
}
}
}
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);
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (DepositLimit != null)
{
hashCode = hashCode * 59 + DepositLimit.GetHashCode();
}
if (InputCoinType != null)
{
hashCode = hashCode * 59 + InputCoinType.GetHashCode();
}
if (OutputCoinType != null)
{
hashCode = hashCode * 59 + OutputCoinType.GetHashCode();
}
return(hashCode);
}
}
/// <summary>
/// Evaluate the limits for Deposit
/// </summary>
/// <param name="tierLevel"></param>
/// <param name="amount"></param>
/// <param name="depositLedgers"></param>
/// <param name="baseCurrency"> </param>
/// <returns></returns>
public bool EvaluateDepositLimits(string baseCurrency, string tierLevel, decimal amount,
IList <Ledger> depositLedgers)
{
// If the admin has specified the limits to be calculated as the currency itself
if (_adminDefinedLimitsCurrency == LimitsCurrency.Default.ToString())
{
// Get the Current Deposit limits for this user
DepositLimit depositLimit = _depositLimitRepository.GetLimitByTierLevelAndCurrency(tierLevel,
_adminDefinedLimitsCurrency);
if (depositLimit != null)
{
// Check if the current Deposit transaction is within the Deposit limits
return(_depositLimitEvaluationService.EvaluateDepositLimit(amount, depositLedgers, depositLimit));
}
throw new InvalidOperationException(string.Format("No Deposit Limit found for Tier: Tier Level = {0} & " +
"CurrencyType = {1}", tierLevel, _adminDefinedLimitsCurrency));
}
// If the admin has specified that limtis must be calculated in a FIAT currency
else
{
// Get the Current Deposit limits for this user which will be in a FIAT currency
DepositLimit depositLimit = _depositLimitRepository.GetLimitByTierLevelAndCurrency(tierLevel,
_adminDefinedLimitsCurrency);
if (depositLimit != null)
{
// Convert the currency to FIAT
decimal amountInFiat = ConvertCurrencyToFiat(baseCurrency, amount);
// Return reponse that if the user is allowed to deposit the specified limit of not
// NOTE: If there is no best bid and best ask, then the limits will be speficied in the defauly crypto currency itself
return(_depositLimitEvaluationService.EvaluateDepositLimit(amountInFiat, depositLedgers,
depositLimit,
_bestBidBestAsk.Item1,
_bestBidBestAsk.Item2));
}
throw new InvalidOperationException(string.Format("No Deposit Limit found for Tier: Tier Level = {0} & " +
"CurrencyType = {1}", tierLevel, _adminDefinedLimitsCurrency));
}
}
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 bool AssignDepositLimits(IList <Ledger> depositLedgers, DepositLimit depositLimit, decimal bestBid, decimal bestAsk)
{
throw new NotImplementedException();
}
public bool EvaluateDepositLimit(decimal amountInUsd, IList <Ledger> depositLedgers, DepositLimit depositLimit, decimal bestBid, decimal bestAsk)
{
throw new NotImplementedException();
}
public bool AssignDepositLimits(IList <Ledger> depositLedgers, DepositLimit depositLimit)
{
throw new NotImplementedException();
}
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 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);
}
