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 ThrowArgumentNullException_WhenWithdrawCardDateIsExpired()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowArgumentNullException_WhenWithdrawCardDateIsExpired")
.Options;
string cardNumber = "0000000000000000";
double amount = 100.2;
var newBankCard = new BankCard()
{
Id = cardNumber,
Expiration = new DateTime(2017, 2, 2)
};
using (var context = new CasinoContext(contextOptions))
{
var cardService = new CardService(context);
await context.BankCards.AddAsync(newBankCard);
await context.SaveChangesAsync();
await Assert.ThrowsExceptionAsync <CardExpirationException>(
() => cardService.Withdraw(cardNumber, amount)
);
}
}
public async Task WidthdrawSucessuly()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "WidthdrawSucessuly")
.Options;
string cardId = "0000000000000000";
double amount = 100.2;
var newBankCard = new BankCard()
{
Id = cardId,
Expiration = new DateTime(2019, 2, 2)
};
using (var context = new CasinoContext(contextOptions))
{
var cardService = new CardService(context);
await context.BankCards.AddAsync(newBankCard);
await context.SaveChangesAsync();
await cardService.Withdraw(cardId, amount);
Assert.IsTrue(newBankCard.MoneyRetrieved == amount);
}
}
public TransactionService(CasinoContext dbContext, ICurrencyRateApiService currencyService)
{
ServiceValidator.ObjectIsNotEqualNull(dbContext);
this.dbContext = dbContext;
this.currencyService = currencyService;
}
public async Task ReturnResultOne()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ReturnZeroCount")
.Options;
var type = "Win";
var transactionType = new TransactionType()
{
Id = 1,
Name = type
};
var transaction = new Transaction()
{
TransactionType = transactionType
};
using (var context = new CasinoContext(contextOptions))
{
context.Transactions.Add(transaction);
await context.SaveChangesAsync();
var adminService = new AdminDashboardService(context);
var result = await adminService.GetTotaTransactionsByTypeCount(type);
Assert.AreEqual(1, result);
}
}
public async Task ThrowIfUserIsAdmin()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowIfUserIsAdmin")
.Options;
var user = new User()
{
Id = "invalid-user", Locked = false
};
var role = new IdentityUserRole <string>()
{
RoleId = "1", UserId = "invalid-user"
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
context.UserRoles.Add(role);
context.SaveChanges();
var userService = new UserService(context);
await Assert.ThrowsExceptionAsync <InvalidAdministratorOperationException>
(async() => await userService.LockUser("invalid-user"));
}
}
public async Task RetrieveWalletIfExists()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "RetrieveWalletIfExists")
.Options;
var user = new User()
{
Id = "valid-user"
};
var wallet = new Wallet()
{
Id = "wallet-test", User = user, CurrencyId = 1
};
using (var context = new CasinoContext(contextOptions))
{
context.Wallets.Add(wallet);
context.SaveChanges();
var walletService = new WalletService(context);
var result = await walletService.RetrieveWallet("valid-user");
Assert.IsNotNull(result);
Assert.AreEqual("wallet-test", result.Id);
Assert.AreEqual(1, result.CurrencyId);
}
}
public async Task ReturnUserWhenCorrectParametersArePassed_AndUserIdIsInDb()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ReturnUserWhenCorrectParametersArePassed_AndUserIdIsInDb")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
var userId = "user-id";
var transactionsData = new Transaction()
{
UserId = userId,
TransactionType = new TransactionType()
};
using (var context = new CasinoContext(contextOptions))
{
var transactionService = new TransactionService(context, currencyServiceMock.Object);
context.Transactions.Add(transactionsData);
await context.SaveChangesAsync();
var result = await transactionService.GetUserTransactions(userId);
Assert.AreEqual(1, result.Count());
Assert.IsInstanceOfType(result, typeof(IEnumerable <Transaction>));
}
}
public async Task AddCardSucessfull()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "AddCardSucessfull")
.Options;
string cardNumber = new string('0', 16);
string userId = "userId";
DateTime expiration = new DateTime(2019, 11, 10);
using (var context = new CasinoContext(contextOptions))
{
var cardService = new CardService(context);
await cardService.AddCard(cardNumber, userId, expiration);
var card = await context.BankCards
.Where(c => c.CardNumber == cardNumber)
.FirstAsync();
Assert.AreEqual(cardNumber, card.CardNumber);
Assert.IsNotNull(context.BankCards.FirstOrDefault(ca => ca.CardNumber == cardNumber));
}
}
public async Task SucesGetAllCards()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "SucesGetAllCards")
.Options;
string userId = "userId";
var newBankCard = new BankCard()
{
UserId = "userId",
};
DateTime expiration = new DateTime(2019, 11, 10);
using (var context = new CasinoContext(contextOptions))
{
var cardService = new CardService(context);
await context.BankCards.AddAsync(newBankCard);
await context.SaveChangesAsync();
var card = await cardService.GetAllCards(userId);
Assert.AreEqual(1, card.Count());
}
}
public async Task CorrectlyUnLockWithValidParameters()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "CorrectlyUnLockWithValidParameters")
.Options;
var user = new User()
{
Id = "test-user-id", Locked = true
};
var role = new IdentityUserRole <string>()
{
RoleId = "2", UserId = "test-user-id"
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
context.UserRoles.Add(role);
context.SaveChanges();
var userService = new UserService(context);
var result = await userService.UnLockUser("test-user-id");
Assert.IsFalse(result.Locked);
Assert.IsNotNull(context.Users.FirstOrDefault(us => !us.Locked && us.Id == "test-user-id"));
}
}
public async Task CorrectlyRemoveOldRoleWithValidId()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "CorrectlyRemoveOldRoleWithValidId")
.Options;
var user = new User()
{
Id = "valid-user"
};
var role = new IdentityUserRole <string>()
{
UserId = "valid-user", RoleId = "2"
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
context.UserRoles.Add(role);
context.SaveChanges();
var userService = new UserService(context);
var result = await userService.PromoteUser("valid-user");
Assert.IsNull(context.UserRoles.FirstOrDefault(ur => ur.UserId == result.Id && ur.RoleId == "2"));
Assert.AreEqual(1, context.UserRoles.Count());
}
}
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 SucesRemoveingCard()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "SucesGetAllCard")
.Options;
string cardNumber = "0000000000000000";
var newBankCard = new BankCard()
{
CardNumber = cardNumber
};
DateTime expiration = new DateTime(2019, 11, 10);
using (var context = new CasinoContext(contextOptions))
{
var cardService = new CardService(context);
await context.BankCards.AddAsync(newBankCard);
await context.SaveChangesAsync();
var card = await cardService.RemoveCard(cardNumber);
Assert.IsInstanceOfType(card, typeof(BankCard));
Assert.IsTrue(card.CardNumber == cardNumber);
Assert.IsTrue(card.IsDeleted == true);
}
}
public async Task ThrowEntityNotFoundException_WhenCardWithGivenIdIsNotFoundInDatabase()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowEntityNotFoundException_WhenCardWithGivenIdIsNotFoundInDatabase")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
string userId = "userId";
string cardId = "cardId";
double amountInUserCurrency = 50.05;
string description = "1234567890";
using (var context = new CasinoContext(contextOptions))
{
var usre = new User()
{
Id = userId
};
context.SaveChanges();
var transactionService = new TransactionService(context, currencyServiceMock.Object);
await Assert.ThrowsExceptionAsync <EntityNotFoundException>(() => transactionService.AddWithdrawTransaction(userId, cardId, amountInUserCurrency, description));
}
}
public async Task DepositSuccesfully()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "DepositSuccesfully")
.Options;
string cardNumber = "0000000000000000";
double amount = 100.2;
var newBankCard = new BankCard()
{
Id = cardNumber,
Expiration = new DateTime(2019, 2, 2)
};
using (var context = new CasinoContext(contextOptions))
{
var cardService = new CardService(context);
await context.BankCards.AddAsync(newBankCard);
await context.SaveChangesAsync();
await cardService.Deposit(cardNumber, amount);
Assert.IsTrue(newBankCard.MoneyAdded == amount);
}
}
public async Task Add_Stake_WithCorrectAmountOfCurrency()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "Add_Stake_WithCorrectAmountOfCurrency")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
var baseCurrency = "USD";
var currency = 1.50;
var serviceReturn = new ConcurrentDictionary <string, double>();
serviceReturn.TryAdd(baseCurrency, currency);
currencyServiceMock.Setup(s => s.GetRatesAsync()).Returns(Task.FromResult(serviceReturn));
string userId = "userId";
double amountInUserCurrency = 50;
string description = "1234567890";
var user = new User()
{
Id = userId,
Wallet = new Wallet()
{
Id = "walledId",
Currency = new Currency()
{
Id = 1,
Name = baseCurrency
},
DisplayBalance = 750,
NormalisedBalance = 500
}
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
await context.SaveChangesAsync();
var transactionService = new TransactionService(context, currencyServiceMock.Object);
var savedTransaction = await transactionService.AddStakeTransaction(userId, amountInUserCurrency, description);
var originalAmount = savedTransaction.OriginalAmount;
var normalisedAmount = savedTransaction.NormalisedAmount;
var userAmount = context.Users.Find(userId).Wallet.NormalisedBalance;
var userDisplayAmount = context.Users.Find(userId).Wallet.DisplayBalance;
var winTransaction = savedTransaction.TransactionTypeId;
Assert.AreEqual(amountInUserCurrency, originalAmount);
Assert.AreEqual(amountInUserCurrency / currency, normalisedAmount);
Assert.AreEqual(500 - amountInUserCurrency / currency, userAmount);
Assert.AreEqual(750 - amountInUserCurrency, userDisplayAmount);
Assert.IsTrue(winTransaction == 2);
}
}
public List <SPResult> ExecuteSP(DateTime date)
{
System.Data.SqlClient.SqlParameter param = new System.Data.SqlClient.SqlParameter("@data", date.Date);
db = new CasinoContext();
var result = db.Database.SqlQuery <SPResult>("pr_report @data", new object[] { param }).ToList();
return(result);
}
public async Task ThrowWhenInsufficientFundsForOperation()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowWhenInsufficientFundsForOperation")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
var baseCurrency = "USD";
var currency = 1.50;
string cardId = "cardId";
var serviceReturn = new ConcurrentDictionary <string, double>();
serviceReturn.TryAdd(baseCurrency, currency);
currencyServiceMock.Setup(s => s.GetRatesAsync()).Returns(Task.FromResult(serviceReturn));
string userId = "userId";
double amountInUserCurrency = 50;
string description = "1234567890";
var user = new User()
{
Id = userId,
Wallet = new Wallet()
{
Id = "walledId",
Currency = new Currency()
{
Id = 1,
Name = baseCurrency
},
},
Cards = new List <BankCard>()
{
new BankCard()
{
Id = "cardId"
}
}
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
await context.SaveChangesAsync();
var transactionService = new TransactionService(context, currencyServiceMock.Object);
await Assert.ThrowsExceptionAsync <InsufficientFundsException>(
() => transactionService.AddWithdrawTransaction(userId, cardId, amountInUserCurrency, description));
}
}
public void CreateInstance_WhenCorrectParametersArePassed()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "CreateInstance_WhenCorrectParametersArePassed")
.Options;
using (var context = new CasinoContext(contextOptions))
{
var service = new CardService(context);
Assert.IsInstanceOfType(service, typeof(CardService));
}
}
public async Task ThrowIfUserNotFound()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "EditUserAliasShouldThrowIfUserNotFound")
.Options;
using (var context = new CasinoContext(contextOptions))
{
var userService = new UserService(context);
await Assert.ThrowsExceptionAsync <EntityNotFoundException>
(async() => await userService.EditUserAlias("test-user-alias", "test-user-id"));
}
}
public async Task ThrowIfWalletNotFound()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowIfWalletNotFound")
.Options;
using (var context = new CasinoContext(contextOptions))
{
var walletService = new WalletService(context);
await Assert.ThrowsExceptionAsync <EntityNotFoundException>
(async() => await walletService.RetrieveWallet("invalid-user"));
}
}
public async Task ThrowEntityCurrencyNotFoundException_WhenUserUseUnMaitainableCurrency()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "DepositThrowEntityCurrencyNotFoundException_WhenUserUseUnMaitainableCurrency")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
var serviceReturn = new ConcurrentDictionary <string, double>();
serviceReturn.TryAdd("USD", 4);
currencyServiceMock.Setup(s => s.GetRatesAsync()).Returns(Task.FromResult(serviceReturn));
string userId = "userId";
string cardId = "cardId";
double amountInUserCurrency = 50.05;
string description = "1234567890";
var user = new User()
{
Id = userId,
Wallet = new Wallet()
{
Id = "walledId",
Currency = new Currency()
{
Id = 1,
Name = "GBP"
}
},
Cards = new List <BankCard>()
{
new BankCard()
{
Id = "cardId"
}
}
};
using (var context = new CasinoContext(contextOptions))
{
context.Users.Add(user);
await context.SaveChangesAsync();
var transactionService = new TransactionService(context, currencyServiceMock.Object);
await Assert.ThrowsExceptionAsync <EntityCurrencyNotFoundException>(()
=> transactionService.AddDepositTransaction(userId, cardId, amountInUserCurrency, description));
}
}
public async Task ReturnUserTransactionsCorrectParametersArePassed_AndUserIdIsInDb()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ReturnUserTransactionshenCorrectParametersArePassed_AndUserIdIsInDb")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
var userId = "user-id";
var type = "Win";
var currency = "USD";
var transactionsData = new Transaction()
{
Id = userId,
UserId = userId,
User = new User()
{
Id = userId,
Wallet = new Wallet()
{
Currency = new Currency()
{
Name = currency
}
},
},
TransactionType = new TransactionType()
{
Name = type
}
};
using (var context = new CasinoContext(contextOptions))
{
var transactionService = new TransactionService(context, currencyServiceMock.Object);
context.Transactions.Add(transactionsData);
await context.SaveChangesAsync();
var result = await transactionService.RetrieveUserTransaction(userId);
Assert.IsInstanceOfType(result, typeof(Transaction));
Assert.IsTrue(result.UserId.Equals(userId));
Assert.IsTrue(result.TransactionType.Name.Equals(type));
Assert.IsTrue(result.User.Id.Equals(userId));
Assert.IsTrue(result.User.Wallet.Currency.Name.Equals(currency));
}
}
public async Task ThrowIfUserNotFound()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowIfUserNotFound")
.Options;
using (var context = new CasinoContext(contextOptions))
{
var userService = new UserService(context);
await Assert.ThrowsExceptionAsync <EntityNotFoundException>
(async() => await userService.PromoteUser("invalid-user"));
}
}
public void CreateInstance_WhenCorrectParametersArePassed()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "CreateInstance_WhenCorrectParametersArePassed")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
using (var context = new CasinoContext(contextOptions))
{
var service = new TransactionService(context, currencyServiceMock.Object);
Assert.IsInstanceOfType(service, typeof(TransactionService));
}
}
public async Task ReturnOneYearMontsValueByMonthDTO()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ReturnOneYearMontsValueByMonthDTO")
.Options;
using (var context = new CasinoContext(contextOptions))
{
var adminService = new AdminDashboardService(context);
var date = DateTime.Parse("12/14/2018");
var result = await adminService.GetYearTransactions(date);
Assert.AreEqual(12, result.ValuesByMonth.Count);
}
}
public async Task ReturnAllTransactions()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ReturnAllTransactions")
.Options;
var currencyServiceMock = new Mock <ICurrencyRateApiService>();
var serviceReturn = new ConcurrentDictionary <string, double>();
string userId = "userId";
double amountInUserCurrency = 50;
string description = "1234567890";
var transactionType = new TransactionType()
{
Id = 1
};
var newTransaction = new Transaction()
{
UserId = userId,
OriginalAmount = amountInUserCurrency,
Description = description,
TransactionTypeId = 1,
TransactionType = transactionType
};
using (var context = new CasinoContext(contextOptions))
{
context.Transactions.Add(newTransaction);
await context.SaveChangesAsync();
var transactionService = new TransactionService(context, currencyServiceMock.Object);
var transactions = await transactionService.GetAllTransactionsTable().ToListAsync();
Assert.AreEqual(1, transactions.Count());
Assert.IsTrue(transactions.First(u => u.UserId == userId).UserId == userId);
Assert.IsTrue(transactions.First(u => u.UserId == userId).OriginalAmount == amountInUserCurrency);
Assert.IsTrue(transactions.First(u => u.UserId == userId).Description == description);
}
}
public async Task ThrowArgumentNullException_WhenUserIDIsNull()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowArgumentNullException_WhenUserIDIsNull")
.Options;
string userId = null;
using (var context = new CasinoContext(contextOptions))
{
var transactionService = new CardService(context);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(
() => transactionService.GetAllCards(userId)
);
}
}
public async Task ThrowArgumentNullException_WhenRemoveCardNumberNotFoundInDb()
{
var contextOptions = new DbContextOptionsBuilder <CasinoContext>()
.UseInMemoryDatabase(databaseName: "ThrowArgumentNullException_WhenRemoveCardNumberNotFoundInDb")
.Options;
string cardNumber = "0000000000000000";
using (var context = new CasinoContext(contextOptions))
{
var transactionService = new CardService(context);
await Assert.ThrowsExceptionAsync <EntityNotFoundException>(
() => transactionService.RemoveCard(cardNumber)
);
}
}
