public async Task WalletTransferMoreThanMaximumDepositFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password1 = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
string password2 = await walletService.CreateWallet("ime", "prezime", "0605996781028", (short)BankType.BrankoBank, "1234", "123456789876543210");
string password3 = await walletService.CreateWallet("ime", "prezime", "0605996781027", (short)BankType.BrankoBank, "1234", "123456789876543210");
await walletService.Deposit("0605996781029", password1, 750000M);
await walletService.Deposit("0605996781027", password3, 750000M);
await walletService.Transfer("0605996781029", password1, "0605996781028", 300000);
//Act
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Transfer("0605996781029", password1, "0605996781028", 300000), $"Transaction would exceed wallet (0605996781028) monthly deposit limit ({Configuration["MaximalDeposit"]} RSD).");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task FailWalletTransferTest5()
{
try
{
string jmbg1 = "2904992785075";
string jmbg2 = "2904990785034";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password1 = await walletService.CreateWallet(jmbg1, "TestIme1", "TestPrezime1", (short)BankType.FirstBank, "360123456789999874", "1234");
string password2 = await walletService.CreateWallet(jmbg2, "TestIme2", "TestPrezime2", (short)BankType.FirstBank, "360123456789999889", "1224");
await walletService.Deposit(jmbg1, password1, 2000m);
Wallet wallet2 = await CoreUnitOfWork.WalletRepository.GetById(jmbg2);
wallet2.Block();
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Transfer(jmbg1, password1, 2000000m, jmbg2), $"Forbidden transfer to blocked wallet #{jmbg2}");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task GetWalletInfoNewWalletSuccessTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
WalletInfoDTO wallet = await walletService.GetWalletInfo("0605996781029", password);
//Assert
Assert.IsNotNull(wallet, "Wallet must not be null");
Assert.AreEqual("ime", wallet.FirstName, "FirstName must be 'ime'");
Assert.AreEqual("prezime", wallet.LastName, "LastName must be 'prezime'");
Assert.AreEqual("0605996781029", wallet.Jmbg, "Jmbg must be '0605996781029'");
Assert.AreEqual((short)BankType.BrankoBank, wallet.BankType, $"BankType must be '{BankType.BrankoBank}'");
Assert.AreEqual("123456789876543210", wallet.BankAccount, "BankAccount must be '123456789876543210'");
Assert.AreEqual(0, wallet.Balance, "Balance must be 0 RSD");
Assert.AreEqual(0, wallet.UsedDepositThisMonth, "UsedDepositThisMonth must be 0 RSD");
Assert.AreEqual(0, wallet.UsedWithdrawThisMonth, "UsedWithdrawThisMonth must be 0 RSD");
Assert.AreEqual(decimal.Parse(Configuration["MaximalDeposit"]), wallet.MaximalDeposit, $"MaximalDeposit must be {Configuration["MaximalDeposit"]} RSD");
Assert.AreEqual(decimal.Parse(Configuration["MaximalWithdraw"]), wallet.MaximalWithdraw, $"MaximalWithdraw must be {Configuration["MaximalDeposit"]} RSD");
Assert.AreEqual(0, wallet.TransactionDTOs.Count, "There must be no transactions on the wallet");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task SuccessGetWalletTransactionsByDateTest()
{
try
{
string jmbg = "2904992785075";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password = await walletService.CreateWallet(jmbg, "TestIme", "TestPrezime", (short)BankType.FirstBank, "360123456789999874", "1234");
await walletService.Deposit(jmbg, password, 1000m);
//Act
var walletTransactionsDTO = await walletService.GetWalletTransactionsByDate(jmbg, password, DateTime.Now);
//Assert
Wallet wallet = await CoreUnitOfWork.WalletRepository.GetFirstOrDefaultWithIncludes(w => w.JMBG == jmbg,
w => w.Transactions.Where(t => t.TransactionDateTime.Date == DateTime.Now.Date));
Assert.AreEqual(walletTransactionsDTO.JMBG, wallet.JMBG);
Assert.AreEqual(walletTransactionsDTO.Balance, wallet.Balance);
Assert.AreEqual(walletTransactionsDTO.Transactions.Count, 1);
Assert.AreEqual(walletTransactionsDTO.Transactions.Count, wallet.Transactions.Count);
Assert.AreEqual(walletTransactionsDTO.Transactions.First().Type, TransactionType.Deposit);
Assert.AreEqual(walletTransactionsDTO.Transactions.First().Amount, 1000m);
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task ThrowIfWalletAlreadyExists()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowIfWalletAlreadyExists")
.Options;
var user = new User()
{
Id = "test-user-id", IsDeleted = false
};
var wallet = new Wallet()
{
Id = "test-wallet", User = user
};
using (var context = new CasinoContext(contextOptions))
{
context.Wallets.Add(wallet);
context.SaveChanges();
var walletService = new WalletService(context);
await Assert.ThrowsExceptionAsync <EntityAlreadyExistsException>
(async() => await walletService.CreateWallet("test-user-id", 1));
}
}
public async Task CalculateTransferFeeFixedFeeSuccessTest()
{
try
{
//Arrange
Configuration["FirstTransactionFreeEachMonth"] = "False";
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
decimal fee1 = await walletService.CalculateTransferFee("0605996781029", password, 1);
decimal fee2 = await walletService.CalculateTransferFee("0605996781029", password, 5000);
decimal fee3 = await walletService.CalculateTransferFee("0605996781029", password, 9999);
//Assert
Assert.AreEqual(100, fee1, "Fee1 must be 100.00 RSD.");
Assert.AreEqual(100, fee2, "Fee2 must be 100.00 RSD.");
Assert.AreEqual(100, fee3, "Fee3 must be 100.00 RSD.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
finally
{
Configuration["FirstTransactionFreeEachMonth"] = "True";
}
}
public async Task CreateWalletIfNoneFound()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "CreateWalletIfNoneFound")
.Options;
var user = new User()
{
Id = "test-user-id", IsDeleted = false
};
var currency = new Currency()
{
Id = 1, Name = "Test-currency"
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
context.Currencies.Add(currency);
context.SaveChanges();
var walletService = new WalletService(context);
var result = await walletService.CreateWallet("test-user-id", 1);
Assert.IsNotNull(result);
Assert.AreEqual("test-user-id", result.UserId);
Assert.AreEqual(1, result.CurrencyId);
}
}
public async Task CalculateTransferFeeFirstTransferInMonthNoFeeSuccessTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
Wallet wallet = await CoreUnitOfWork.WalletRepository.GetById("0605996781029");
//Act
decimal fee1 = await walletService.CalculateTransferFee("0605996781029", password, 10000);
var date = new SqlParameter("@LastTransferDateTime", $"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
var query = DbContext.Database
.ExecuteSqlRaw("UPDATE Wallets SET LastTransferDateTime = @LastTransferDateTime", date);
DbContext.Entry(wallet).Reload();
decimal fee2 = await walletService.CalculateTransferFee("0605996781029", password, 100000);
//Assert
Assert.AreEqual(0, fee1, "Fee1 must be 0.00 RSD.");
Assert.AreEqual(1000, fee2, "Fee2 must be 1000.00 RSD.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task WalletDepositSuccessTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
await walletService.Deposit("0605996781029", password, 100000M);
//Assert
Wallet wallet = await CoreUnitOfWork.WalletRepository.GetById("0605996781029");
Assert.AreEqual(100000M, wallet.Balance, "Wallet balance must be 100000");
Assert.AreEqual(1, wallet.Transactions.Count(), $"A transaction must exist on the wallet.");
Assert.AreEqual(TransactionType.Deposit, wallet.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.Deposit).Type, $"A transaction of type {TransactionType.Deposit} must exist on the wallet.");
Assert.AreEqual(100000M, wallet.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.Deposit).Amount, $"Deposit transaction amount must be 100000.");
Assert.AreEqual(BankType.BrankoBank.ToString(), wallet.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.Deposit).Source, $"Source of the transaction should be {BankType.BrankoBank}.");
Assert.AreEqual("0605996781029", wallet.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.Deposit).Destination, $"Destination of the transaction should be 0605996781029.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task CreateWalletSuccessTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
//Act
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Assert
Wallet wallet = await CoreUnitOfWork.WalletRepository.GetById("0605996781029");
Assert.IsNotNull(wallet, "Wallet must not be null");
Assert.AreEqual(6, password.Length, "Password must be 6 characters long");
Assert.AreEqual("ime", wallet.FirstName, "FirstName must be 'ime'");
Assert.AreEqual("prezime", wallet.LastName, "LastName must be 'prezime'");
Assert.AreEqual("0605996781029", wallet.Jmbg, "Jmbg must be '0605996781029'");
Assert.AreEqual(BankType.BrankoBank, wallet.BankType, $"BankType must be '{BankType.BrankoBank}'");
Assert.AreEqual("1234", wallet.PIN, "PIN must be '1234'");
Assert.AreEqual("123456789876543210", wallet.BankAccount, "BankAccount must be '123456789876543210'");
Assert.AreEqual(0, wallet.Balance, "Balance must be 0 RSD");
Assert.AreEqual(0, wallet.UsedDepositThisMonth, "UsedDepositThisMonth must be 0 RSD");
Assert.AreEqual(0, wallet.UsedWithdrawThisMonth, "UsedWithdrawThisMonth must be 0 RSD");
Assert.AreEqual(false, wallet.IsBlocked, "Wallet must be unblocked");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
finally
{
}
}
public async Task FailCreateWalletTest4()
{
WalletService walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string walletPass = await walletService.CreateWallet("1203977780011", "Pera", "Peric", 1, "360123456", "1234");
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.CreateWallet("1203977780011", "Pera", "Peric", 1, "360123456", "1234"), $"Wallet already exists");
}
public async Task WalletWithdrawWalletBlockedFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
await walletService.Deposit("0605996781029", password, 750000M);
Wallet wallet = await CoreUnitOfWork.WalletRepository.GetById("0605996781029");
wallet.Block();
await CoreUnitOfWork.WalletRepository.Update(wallet);
await CoreUnitOfWork.SaveChangesAsync();
//Act
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Withdraw("0605996781029", password, 500000M), $"Wallet '{0605996781029}' is blocked");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task SuccessGetWalletInfoTest()
{
try
{
string jmbg = "2904992785075";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password = await walletService.CreateWallet(jmbg, "TestIme", "TestPrezime", (short)BankType.FirstBank, "360123456789999874", "1234");
//Act
var walletInfoDTO = await walletService.GetWalletInfo(jmbg, password);
//Assert
Assert.AreEqual(walletInfoDTO.JMBG, jmbg);
Assert.AreEqual(walletInfoDTO.FirstName, "TestIme");
Assert.AreEqual(walletInfoDTO.LastName, "TestPrezime");
Assert.AreEqual(walletInfoDTO.Bank, BankType.FirstBank);
Assert.AreEqual(walletInfoDTO.BankAccountNumber, "360123456789999874");
Assert.AreEqual(walletInfoDTO.Balance, 0m);
Assert.AreEqual(walletInfoDTO.IsBlocked, false);
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task SuccessWalletDepositTest()
{
try
{
string jmbg = "2904992785075";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password = await walletService.CreateWallet(jmbg, "TestIme", "TestPrezime", (short)BankType.FirstBank, "360123456789999874", "1234");
//Act
await walletService.Deposit(jmbg, password, 1000m);
//Assert
Wallet wallet = await CoreUnitOfWork.WalletRepository.GetById(jmbg);
Assert.AreEqual(1000m, wallet.Balance, "Balance must be 1000");
Assert.AreNotEqual(0, wallet.Transactions.Count(), "Transaction count must be different than 0");
Assert.AreEqual(TransactionType.Deposit, wallet.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.Deposit).Type);
Assert.AreEqual(1000m, wallet.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.Deposit).Amount, $"Transaction amount must be 10000.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task WalletTransferWithFeeSuccessTest()
{
try
{
//Arrange
Configuration["FirstTransactionFreeEachMonth"] = "False";
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password1 = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
string password2 = await walletService.CreateWallet("ime", "prezime", "0605996781028", (short)BankType.BrankoBank, "1234", "123456789876543210");
await walletService.Deposit("0605996781029", password1, 101000M);
//Act
await walletService.Transfer("0605996781029", password1, "0605996781028", 100000M);
//Assert
Wallet walletSource = await CoreUnitOfWork.WalletRepository.GetById("0605996781029");
Wallet walletDesitnation = await CoreUnitOfWork.WalletRepository.GetById("0605996781028");
Assert.AreEqual(0, walletSource.Balance, "Wallet balance must be 0");
Assert.AreEqual(TransactionType.TransferPayOut, walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayOut).Type, $"A transaction of type {TransactionType.TransferPayOut} must exist on the wallet.");
Assert.AreEqual(100000M, walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayOut).Amount, $"{TransactionType.TransferPayOut} transaction amount must be 100000.");
Assert.AreEqual("0605996781029", walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayOut).Source, $"Source of the transaction should be '0605996781029'.");
Assert.AreEqual("0605996781028", walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayOut).Destination, $"Destination of the transaction should be '0605996781028'.");
Assert.AreEqual(TransactionType.FeePayOut, walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.FeePayOut).Type, $"A transaction of type {TransactionType.FeePayOut} must exist on the wallet.");
Assert.AreEqual(1000M, walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.FeePayOut).Amount, $"{TransactionType.FeePayOut} transaction amount must be 1000.");
Assert.AreEqual("0605996781029", walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.FeePayOut).Source, $"Source of the transaction should be '0605996781029'.");
Assert.AreEqual("System", walletSource.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.FeePayOut).Destination, $"Destination of the transaction should be 'System'.");
Assert.AreEqual(100000M, walletDesitnation.Balance, "Wallet balance must be 100000");
Assert.AreEqual(TransactionType.TransferPayIn, walletDesitnation.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayIn).Type, $"A transaction of type {TransactionType.TransferPayIn} must exist on the wallet.");
Assert.AreEqual(100000M, walletDesitnation.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayIn).Amount, $"{TransactionType.TransferPayIn} transaction amount must be 100000.");
Assert.AreEqual("0605996781029", walletDesitnation.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayIn).Source, $"Source of the transaction should be '0605996781029'.");
Assert.AreEqual("0605996781028", walletDesitnation.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayIn).Destination, $"Destination of the transaction should be '0605996781028'.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
finally
{
Configuration["FirstTransactionFreeEachMonth"] = "True";
}
}
public async Task CreateWallet_WalletUnSuccessfullySavedInDb_ShouldReturnSuccess()
{
var sut = new WalletService(Mapper, _walletRepoMock.Object, _emailServiceMock.Object);
var result = await sut.CreateWallet(Fixture.Create <AddWalletDto>(), Guid.NewGuid().ToString());
result.Succedeed.Should().BeFalse();
}
public void CreateWallet_ThrowsWalletException_ReturnsFalse()
{
// Arrange
var createWalletDetails = new CreateWalletDetails {
Name = "Wallet One", Password = "******"
};
_walletManager
.Setup(callTo => callTo.CreateWallet(createWalletDetails.Password, createWalletDetails.Name, createWalletDetails.Password, It.IsAny <Mnemonic>()))
.Throws(new WalletException("Something went wrong"));
// Act
var created = _walletService.CreateWallet(createWalletDetails);
// Assert
Assert.That(created, Is.False);
}
public async Task SuccessWalletTransferWithFeeTest()
{
try
{
Configuration["IsFirstTransferFreeInMonth"] = "False";
Configuration["DaysAfterWalletCreationWithNoFee"] = "0";
string jmbg1 = "2904992785075";
string jmbg2 = "2904990785034";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password1 = await walletService.CreateWallet(jmbg1, "TestIme1", "TestPrezime1", (short)BankType.FirstBank, "360123456789999874", "1234");
string password2 = await walletService.CreateWallet(jmbg2, "TestIme2", "TestPrezime2", (short)BankType.FirstBank, "360123456789999889", "1224");
await walletService.Deposit(jmbg1, password1, 2000m);
//Act
await walletService.Transfer(jmbg1, password1, 500m, jmbg2);
//Assert
Wallet wallet1 = await CoreUnitOfWork.WalletRepository.GetById(jmbg1);
Wallet wallet2 = await CoreUnitOfWork.WalletRepository.GetById(jmbg2);
Assert.AreEqual(1400m, wallet1.Balance, "Balance must be 1400");
Assert.AreEqual(500m, wallet2.Balance, "Balance must be 500");
Assert.AreNotEqual(0, wallet1.Transactions.Count(), "Transaction count must be different than 0");
Assert.AreNotEqual(0, wallet2.Transactions.Count(), "Transaction count must be different than 0");
Assert.AreEqual(TransactionType.TransferPayOut, wallet1.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayOut).Type);
Assert.AreEqual(TransactionType.TransferPayIn, wallet2.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayIn).Type);
Assert.AreEqual(TransactionType.FeePayOut, wallet1.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.FeePayOut).Type);
Assert.AreEqual(100m, wallet1.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.FeePayOut).Amount, $"Transaction transfer fee amount must be 100.");
Assert.AreEqual(500m, wallet1.Transactions.FirstOrDefault(transaction => transaction.Type == TransactionType.TransferPayOut).Amount, $"Transaction amount must be 500.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
var accountservice = new AccountService();
var userId = Guid.Parse(accountservice.GetGuid(user.Email));
var walletService = new WalletService(userId);
var wallet = new WalletCreate
{
WalletBalance = 50000
};
if (!walletService.CreateWallet(wallet))
{
return(InternalServerError(new Exception("Error creating Wallet.")));
}
var currencyService = new CurrencyService();
var currencies = currencyService.GetCurrencies();
foreach (var currency in currencies)
{
var holdingService = new HoldingService(userId);
var holding =
new HoldingCreate()
{
CryptoHoldingBalance = 0,
CurrencyId = currency.CurrencyId,
WalletId = walletService.GetWalletId()
};
if (!holdingService.CreateHolding(holding))
{
return(InternalServerError(new Exception($"Error creating entry for Holding: {holding.CurrencyId}")));
}
}
return(Ok());
}
public async Task FailWalletTransferTest3()
{
try
{
string jmbg1 = "2904992785075";
string jmbg2 = "2904990785034";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password1 = await walletService.CreateWallet(jmbg1, "TestIme1", "TestPrezime1", (short)BankType.FirstBank, "360123456789999874", "1234");
string password2 = await walletService.CreateWallet(jmbg2, "TestIme2", "TestPrezime2", (short)BankType.FirstBank, "360123456789999889", "1224");
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Transfer(jmbg1, password1, 1000m, jmbg2), $"Not enough funds on wallet #{jmbg1}.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task FailWalletTransferTest1()
{
try
{
string jmbg1 = "2904992785075";
string jmbg2 = "2904990785034";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password1 = await walletService.CreateWallet(jmbg1, "TestIme1", "TestPrezime1", (short)BankType.FirstBank, "360123456789999874", "1234");
string password2 = await walletService.CreateWallet(jmbg2, "TestIme2", "TestPrezime2", (short)BankType.FirstBank, "360123456789999889", "1224");
await walletService.Deposit(jmbg1, password1, 2000m);
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Transfer(jmbg1, password1, 2000000m, jmbg2), $"Exceeded monthly withdraw and deposit limit ({Configuration["MaxDeposit"]} RSD).");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task ThrowIfUserNotFound()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowIfUserNotFound")
.Options;
using (var context = new CasinoContext(contextOptions))
{
var walletService = new WalletService(context);
await Assert.ThrowsExceptionAsync <EntityNotFoundException>
(async() => await walletService.CreateWallet("test-user-id", 1));
}
}
public async Task WalletTransferDestinationWalletBlockedFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password1 = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
string password2 = await walletService.CreateWallet("ime", "prezime", "0605996781028", (short)BankType.BrankoBank, "1234", "123456789876543210");
await walletService.Deposit("0605996781029", password1, 500000M);
await walletService.BlockWallet("0605996781028", Configuration["AdminPassword"]);
//Act
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Transfer("0605996781029", password1, "0605996781028", 500000), $"Wallet '{0605996781029}' is blocked");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task FailGetWalletInfoTest3()
{
try
{
string jmbg = "2904992785075";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password = await walletService.CreateWallet(jmbg, "TestIme", "TestPrezime", (short)BankType.FirstBank, "360123456789999874", "1234");
//Assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await walletService.GetWalletInfo(jmbg, null));
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task CalulateTransferFeeWrongPasswordFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
//Assert
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await walletService.CalculateTransferFee("0605996781029", "12345", 1100000M), $"No wallet for entered jmbg '{"0605996781029"}' and password pair.");;
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task UnblockWalletAlreadyBlockedFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.UnblockWallet("0605996781029", Configuration["AdminPassword"]), $"Wallet '0605996781029' is not blocked");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task BlockWalletWrongAdminPasswordFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
//Assert
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await walletService.BlockWallet("0605996781029", "654321"), $"Wrong admin password.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task FailWalletWithdrawTest3()
{
try
{
string jmbg = "2904992785075";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password = await walletService.CreateWallet(jmbg, "TestIme", "TestPrezime", (short)BankType.FirstBank, "360123456789999874", "1234");
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.Withdraw(jmbg, password, 1000m), $"Not enough funds on wallet.");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task CalulateTransferFeeLessThanOrEqualToZeroAmountFailTest()
{
try
{
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, Configuration, FeeService);
string password = await walletService.CreateWallet("ime", "prezime", "0605996781029", (short)BankType.BrankoBank, "1234", "123456789876543210");
//Act
//Assert
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await walletService.CalculateTransferFee("0605996781029", password, 0M), "Amount must be higher than 0 RSD.");;
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}
public async Task FailGetWalletTransactionsByDateTest1()
{
try
{
string jmbg = "2904992785075";
//Arrange
var walletService = new WalletService(CoreUnitOfWork, BankRoutingService, FeeService, Configuration);
string password = await walletService.CreateWallet(jmbg, "TestIme", "TestPrezime", (short)BankType.FirstBank, "360123456789999874", "1234");
//Assert
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await walletService.GetWalletTransactionsByDate(jmbg, "1234", DateTime.Now), "Invalid password");
}
catch (Exception ex)
{
Assert.Fail("Unexpected error: " + ex.Message);
}
}