public PaymentManager(ICheckingAccountRepository accountRepository, IPaymentRepository paymentRepository, IFeeRepository feeRepository, IEntryRepository entryRepository)
{
_checkingAccountRepository = accountRepository;
_paymentRepository = paymentRepository;
_feeRepository = feeRepository;
_entryRepository = entryRepository;
}
public SaleUseCases(ISaleRepository saleRepository,
IDetailRepository detailRepository,
IProductRepository productRepository,
IPriceRepository priceRepository,
IClientRepository clientRepository,
ICashRepository cashRepository,
ICreditCardRepository creditCardRepository,
IDebitCardRepository debitCardRepository,
IChequesPaymentRepository chequesPaymentRepository,
IChequeRepository chequeRepository,
IOwnFeesRepository ownFeesRepository,
IFeeRepository feeRepository,
IFeeRuleRepository feeRuleRepository,
IMapper mapper
)
{
_saleRepository = saleRepository;
_detailRepository = detailRepository;
_productRepository = productRepository;
_priceRepository = priceRepository;
_clientRepository = clientRepository;
_cashRepository = cashRepository;
_creditCardRepository = creditCardRepository;
_debitCardRepository = debitCardRepository;
_chequesPaymentRepository = chequesPaymentRepository;
_chequeRepository = chequeRepository;
_ownFeesRepository = ownFeesRepository;
_feeRepository = feeRepository;
_feeRuleRepository = feeRuleRepository;
_mapper = mapper;
}
public void GetFeeTest_TestsIfTheFeeIsasReturnedAsExpectedWhenMiddleElementsAreReached_VerifiesThroughDatabaseQueries()
{
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
AccountId accountId = new AccountId(1);
List <Fee> allFees = feeRepository.GetAllFees();
Assert.IsNotNull(allFees);
string currencyPair = allFees[0].CurrencyPair;
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(currencyPair);
List <Fee> feeByCurrencyPair = feeRepository.GetFeeByCurrencyPair(currencyPair);
Assert.IsNotNull(feeByCurrencyPair);
if (feeByCurrencyPair.Count > 4)
{
decimal amount = feeByCurrencyPair[feeByCurrencyPair.Count - 2].Amount;
Ledger ledger = new Ledger("1", DateTime.Now, LedgerType.Trade, new Currency(splittedCurrencyPair.Item2),
amount, 0, 0, 0, "1", "1", false, accountId);
fundsPersistenceRepository.SaveOrUpdate(ledger);
decimal lastElementFee = (feeByCurrencyPair[feeByCurrencyPair.Count - 2].PercentageFee / 100) * (10 * 20);
decimal feeFromService = feeCalculationService.GetFee(new Currency(splittedCurrencyPair.Item1),
new Currency(splittedCurrencyPair.Item2),
accountId, 10, 20);
Assert.AreEqual(lastElementFee, feeFromService);
}
}
public void GetFeeTest_TestsIfTheFeeIsasReturnedAsExpectedWhenFinalElementInTheTableIsReached_VerifiesThroughDatabaseQueries()
{
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
AccountId accountId = new AccountId(1);
List <Fee> allFees = feeRepository.GetAllFees();
Assert.IsNotNull(allFees);
string currencyPair = allFees[0].CurrencyPair;
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(currencyPair);
// As amount, the value is so large that it is always greater than any fee in the table
Ledger ledger = new Ledger("1", DateTime.Now, LedgerType.Trade, new Currency(splittedCurrencyPair.Item2),
2000000, 0, 0, 0, "1", "1", false, accountId);
fundsPersistenceRepository.SaveOrUpdate(ledger);
List <Fee> feeByCurrencyPair = feeRepository.GetFeeByCurrencyPair(currencyPair);
Assert.IsNotNull(feeByCurrencyPair);
decimal lastElementFee = (feeByCurrencyPair.Last().PercentageFee / 100) * (1000 * 2000);
decimal feeFromService = feeCalculationService.GetFee(new Currency(splittedCurrencyPair.Item1),
new Currency(splittedCurrencyPair.Item2),
accountId, 1000, 2000);
Assert.AreEqual(lastElementFee, feeFromService);
}
public CalculatorController(IFeeRepository feeFeeRepository, IPricingRepository pricingRepository, ILoyaltyRepository loyaltyRepository, IEquipmentService equipmentService)
{
_feeRepository = feeFeeRepository;
_pricingRepository = pricingRepository;
_loyaltyRepository = loyaltyRepository;
_equipmentService = equipmentService;
}
public PlanningAppService(IMapper mapper,
IPlanningAppRepository PlanningAppRepository,
IPlanningAppStateRepository PlanningAppStateRepository,
IProjectGeneratorRepository projectGeneratorRepository,
IStateStatusRepository stateStatusRepository,
IStateInitialiserRepository stateInitialiserRepository,
ICustomerRepository CustomerRepository,
IPlanningAppStateService planningAppStateService,
IDateService dateService,
IFeeRepository feeRepository,
UserManager <AppUser> userManager,
IUnitOfWork unitOfWork)
{
this.Mapper = mapper;
this.PlanningAppRepository = PlanningAppRepository;
this.PlanningAppStateRepository = PlanningAppStateRepository;
this.ProjectGeneratorRepository = projectGeneratorRepository;
this.StateStatusRepository = stateStatusRepository;
this.StateInitialiserRepository = stateInitialiserRepository;
this.CustomerRepository = CustomerRepository;
this.PlanningAppStateService = planningAppStateService;
this.DateService = dateService;
this.FeeRepository = feeRepository;
this.UserManager = userManager;
this.UnitOfWork = unitOfWork;
this.statusList = StateStatusRepository.GetStateStatusList().Result;
}
public CardService(ICardRepository cardRepository, IWithdrawalFeeCalculator withdrawalFeeCalculator,
IFeeRepository feeRepository, IFeeFactory feeFactory)
{
_cardRepository = cardRepository;
_withdrawalFeeCalculator = withdrawalFeeCalculator;
_feeRepository = feeRepository;
_feeFactory = feeFactory;
}
public FeeController(IFeeRepository repo, IMapper mapper, IIdentityServerRequest identityServer, IHttpContextAccessor httpContextAccessor, ILoggerService logger)
{
_repo = repo;
_mapper = mapper;
_identityServer = identityServer;
_httpContextAccessor = httpContextAccessor;
_logger = logger;
}
public void Setup()
{
_mockFeeRepository = Substitute.For <IFeeRepository>();
_mockTaxRepository = Substitute.For <ITaxRepository>();
_mockProvider = Substitute.For <IRemittanceProvider>();
_service = new TaxAndFeeService(_mockProvider, _mockTaxRepository, _mockFeeRepository);
}
public OrdersController(IOrdersRepository ordersRepo, IInvoiceGenerator invoiceGenerator,
IFeeRepository feeRepository, ICustomersRepository customersRepository)
{
OrdersRepo = ordersRepo;
InvoiceGenerator = invoiceGenerator;
FeeRepository = feeRepository;
CustomersRepository = customersRepository;
}
public CartRepository(IEquipmentRepository equipmentRepository, IFeeRepository feeRepository, ICustomersRepository customersRepository)
{
EquipmentRepository = equipmentRepository;
FeeRepository = feeRepository;
CustomersRepository = customersRepository;
Cart = new Cart(customersRepository.GetCurrentCustomer())
{
Items = new List <CartItem>()
};
}
public void Setup()
{
_feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
_persistanceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
var connection = ConfigurationManager.ConnectionStrings["MySql"].ToString();
_databaseUtility = new DatabaseUtility(connection);
_databaseUtility.Create();
_databaseUtility.Populate();
}
public PaymentManagerAndRepositoriesTest()
{
var server = new TestServer(new WebHostBuilder()
.UseStartup <Startup>());
SeedData.PopulateDatabase(server.Host.Services);
_checkingAccountRepository = (ICheckingAccountRepository)server.Host.Services.GetService(typeof(ICheckingAccountRepository));
_paymentRepository = (IPaymentRepository)server.Host.Services.GetService(typeof(IPaymentRepository));
_feeRepository = (IFeeRepository)server.Host.Services.GetService(typeof(IFeeRepository));
_entryRepository = (IEntryRepository)server.Host.Services.GetService(typeof(IEntryRepository));
}
public void SendMultipleOrdersTest_TestsIfSendingMultipleOrdersIsHandledAsExpected_VerifiesThroughTheReturnesValue()
{
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
AccountId accountId = new AccountId(123);
List <Fee> allFees = feeRepository.GetAllFees();
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(allFees.First().CurrencyPair);
Currency baseCurrency = new Currency(splittedCurrencyPair.Item1);
Currency quoteCurrency = new Currency(splittedCurrencyPair.Item2);
Balance baseCurrencyBalance = new Balance(baseCurrency, accountId, 400, 400);
fundsPersistenceRepository.SaveOrUpdate(baseCurrencyBalance);
Balance quoteCurrencyBalance = new Balance(quoteCurrency, accountId, 40000, 40000);
fundsPersistenceRepository.SaveOrUpdate(quoteCurrencyBalance);
bool validateFundsForOrder = fundsValidationService.ValidateFundsForOrder(accountId, baseCurrency,
quoteCurrency, 40, 100, "buy", "order123");
Assert.IsTrue(validateFundsForOrder);
// Get the fee corresponding to the current volume of the quote currency
decimal usdFee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, accountId, 40, 100);
Assert.Greater(usdFee, 0);
baseCurrencyBalance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, accountId);
Assert.AreEqual(400, baseCurrencyBalance.CurrentBalance);
Assert.AreEqual(400, baseCurrencyBalance.AvailableBalance);
Assert.AreEqual(0, baseCurrencyBalance.PendingBalance);
quoteCurrencyBalance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, accountId);
Assert.AreEqual(40000 - (40 * 100), quoteCurrencyBalance.AvailableBalance);
Assert.AreEqual(40000, quoteCurrencyBalance.CurrentBalance);
Assert.AreEqual(40 * 100, quoteCurrencyBalance.PendingBalance);
}
/// <summary>
/// Parameterized Constructor
/// </summary>
public FeeCalculationService(IFeeRepository feeRepository, ILedgerRepository ledgerRepository)
{
_feeRepository = feeRepository;
_ledgerRepository = ledgerRepository;
}
public FeeService(IFeeRepository customerRepository) : base(customerRepository)
{
}
public CartController(ICartRepository cartRepo, IOrdersRepository ordersRepository, IFeeRepository feeRepository)
{
CartRepo = cartRepo;
OrdersRepository = ordersRepository;
FeeRepository = feeRepository;
}
public FindByIdFeesQueryHandler(IFeeRepository feeRepository)
{
this.feeRepository = feeRepository ?? throw new ArgumentNullException(nameof(feeRepository));
}
//private StoreContext db = new StoreContext();
public FeesController()
{
this.rep = new FeeRepository(new StoreContext());
}
public FeeEventHandler(IFeeRepository repository)
{
_repository = repository;
}
public static Fee CreateFee(this IFeeRepository repo, Fee item) => repo.CreateFeeAsync(item).WrapResult();
public CreateFeeCommandHandler(IFeeRepository feeRepository)
{
this.feeRepository = feeRepository ?? throw new ArgumentNullException(nameof(feeRepository));
}
public static IEnumerable <Fee> ListFees(this IFeeRepository repo) => repo.ListFeesAsync().WrapResult();
public HomeController(IFeeRepository fees, ISpreadsheetManagementService spreadsheet)
{
_fees = fees;
_managementService = spreadsheet;
}
public CreateLoanCommandHandler(ILoanRepository loanRepository, IRateRepository rateRepository, IFeeRepository feeRepository)
{
this.loanRepository = loanRepository ?? throw new ArgumentNullException(nameof(loanRepository));
this.rateRepository = rateRepository ?? throw new ArgumentNullException(nameof(rateRepository));
this.feeRepository = feeRepository ?? throw new ArgumentNullException(nameof(feeRepository));
}
public TaxAndFeeService(IRemittanceProvider provider, ITaxRepository taxRepository, IFeeRepository feeRepository)
{
_provider = provider;
_taxRepository = taxRepository;
_feeRepository = feeRepository;
}
public FeeService(IFeeRepository feeRepository)
{
_feeRepository = feeRepository;
}
public FeeService(IFeeRepository <Fee> feeRepository) : base(feeRepository)
{
}
public void Scenario1Test_TestsFundsValidationServiceOperationsInaRandomOrderToProceedInTheDesiredExpectenacy_VerifiesThroughDatabaseQuery()
{
// Deposit --> Order Validations --> Trade --> Withdraw
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositIdGeneratorService depositIdGeneratorService = (IDepositIdGeneratorService)ContextRegistry.GetContext()["DepositIdGeneratorService"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(feeRepository.GetAllFees().First().CurrencyPair);
Currency baseCurrency = new Currency(splittedCurrencyPair.Item1);
Currency quoteCurrency = new Currency(splittedCurrencyPair.Item2);
AccountId user1Account = new AccountId(1);
AccountId user2Account = new AccountId(2);
decimal baseDepositAmount = 1.4m;
decimal quoteDepositAmount = 1000;
Balance user1QuoteInitialBalance = new Balance(quoteCurrency, user1Account, quoteDepositAmount, quoteDepositAmount);
Balance user2QuoteInitialBalance = new Balance(quoteCurrency, user2Account, quoteDepositAmount, quoteDepositAmount);
fundsPersistenceRepository.SaveOrUpdate(user1QuoteInitialBalance);
fundsPersistenceRepository.SaveOrUpdate(user2QuoteInitialBalance);
// Deposit
Deposit deposit1 = new Deposit(baseCurrency, depositIdGeneratorService.GenerateId(), DateTime.Now,
DepositType.Default, baseDepositAmount, 0, TransactionStatus.Pending, user1Account,
new TransactionId("1"), new BitcoinAddress("bitcoin1"));
deposit1.IncrementConfirmations(7);
fundsPersistenceRepository.SaveOrUpdate(deposit1);
Deposit deposit2 = new Deposit(baseCurrency, depositIdGeneratorService.GenerateId(), DateTime.Now,
DepositType.Default, baseDepositAmount, 0, TransactionStatus.Pending, user2Account,
new TransactionId("3"), new BitcoinAddress("bitcoin3"));
deposit2.IncrementConfirmations(7);
fundsPersistenceRepository.SaveOrUpdate(deposit2);
// Retrieve Base Currency balance for user 1
bool depositResponse = fundsValidationService.DepositConfirmed(deposit1);
Assert.IsTrue(depositResponse);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(deposit1.Amount, balance.CurrentBalance);
Assert.AreEqual(deposit1.Amount, balance.AvailableBalance);
Assert.AreEqual(balance.PendingBalance, 0);
// Retrieve Quote Currency balance for user 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(user1QuoteInitialBalance.CurrentBalance, balance.CurrentBalance);
Assert.AreEqual(user1QuoteInitialBalance.AvailableBalance, balance.AvailableBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Retrieve BTC balance for user 2
depositResponse = fundsValidationService.DepositConfirmed(deposit2);
Assert.IsTrue(depositResponse);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(deposit2.Amount, balance.CurrentBalance);
Assert.AreEqual(deposit2.Amount, balance.AvailableBalance);
Assert.AreEqual(balance.PendingBalance, 0);
// Retrieve USD balance for user 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(user2QuoteInitialBalance.CurrentBalance, balance.CurrentBalance);
Assert.AreEqual(user2QuoteInitialBalance.AvailableBalance, balance.AvailableBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Order Validation for User 1's Account
decimal volume = 1.2m;
decimal price = 590;
string buy = "buy";
string sell = "sell";
string buyOrderId = "buy123";
string sellOrderId = "sell123";
bool validationResponse = fundsValidationService.ValidateFundsForOrder(user1Account, baseCurrency, quoteCurrency,
volume, price, buy, buyOrderId);
Assert.IsTrue(validationResponse);
decimal user1Fee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, user1Account, volume, price);
decimal user2Fee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, user2Account, volume, price);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Quote Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount - (volume * price), balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount, balance.CurrentBalance);
Assert.AreEqual(volume * price, balance.PendingBalance);
// Validation of User 2's order
validationResponse = fundsValidationService.ValidateFundsForOrder(user2Account, baseCurrency, quoteCurrency,
volume, price, sell, sellOrderId);
Assert.IsTrue(validationResponse);
// Base Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount - volume, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount, balance.CurrentBalance);
Assert.AreEqual(volume, balance.PendingBalance);
// Quote Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount, balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
string tradeId = "tradeid123";
bool tradeExecutedResponse = fundsValidationService.TradeExecuted(baseCurrency.Name, quoteCurrency.Name,
volume, price, DateTime.Now, tradeId, user1Account.Value, user2Account.Value, buyOrderId, sellOrderId);
Assert.IsTrue(tradeExecutedResponse);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Quote Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount - (volume * price) - user1Fee, balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount - (volume * price) - user1Fee, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Base Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount - (volume), balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount - (volume), balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// Quote Currency Balance for User Account 2
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, user2Account);
Assert.IsNotNull(balance);
Assert.AreEqual(quoteDepositAmount + (volume * price) - user2Fee, balance.AvailableBalance);
Assert.AreEqual(quoteDepositAmount + (volume * price) - user2Fee, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
decimal withdrawAmount = 0.3M;
// Withdraw Base Currency
Withdraw validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(user1Account,
baseCurrency, withdrawAmount, new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
Assert.IsNotNull(validateFundsForWithdrawal);
WithdrawFees withdrawFee = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(baseCurrency.Name);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume, balance.CurrentBalance);
Assert.AreEqual(withdrawAmount, balance.PendingBalance);
bool withdrawalExecuted = fundsValidationService.WithdrawalExecuted(validateFundsForWithdrawal);
Assert.IsTrue(withdrawalExecuted);
// Base Currency Balance for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
// EXCEPTION OCCURS HERE when the user tries to withdraw more than their remaining limit
// Withdraw will fail because the amount requested is greater than the maximum limit threshold
validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(user1Account,
baseCurrency, baseDepositAmount + volume /*Excluding previous withdrawal amount*/,
new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
Assert.IsNull(validateFundsForWithdrawal);
// Base Currency for User Account 1
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, user1Account);
Assert.IsNotNull(balance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.AvailableBalance);
Assert.AreEqual(baseDepositAmount + volume - withdrawAmount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
}
public static Fee GetFeeById(this IFeeRepository repo, string feeId) => repo.GetFeeByIdAsync(feeId).WrapResult();
