public async Task UpdateUser_WhenParamatersAreValidAndUserExists() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "UpdateUser_WhenParamatersAreValidAndUserExistsToggleAdmin") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); await actContext.AddAsync(testRole); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); await command.ToggleAdmin(testUser.Id); var adminUser = await assertContext.Users.Where(user => user.Id == testUser.Id).FirstAsync(); Assert.AreEqual(GlobalConstants.AdminRole.ToString(), adminUser.Role.ToString()); } }
public async Task ReturnCorrectData_WhenParamatersAreValidAndUserExists() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnCorrectData_WhenParamatersAreValidAndUserExistsToggleAdmin") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); await actContext.AddAsync(testRole); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); var result = await command.ToggleAdmin(testUser.Id); Assert.IsInstanceOfType(result, typeof(UserDTO)); Assert.IsFalse(result.Deleted); Assert.AreEqual(testUser.UserName, result.Username); Assert.AreEqual(testUser.Id, result.UserId); Assert.IsTrue(result.Admin); } }
public async Task ReturnCorrectData_WhenNoParametersArePassed() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnCorrectData_WhenNoParametersArePassed") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testUserOne); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); var result = await command.GetAllUsers(); Assert.IsInstanceOfType(result, typeof(IPagedList <UserDTO>)); Assert.IsTrue(result.Count() == 1); Assert.AreEqual(testUserOne.UserName, result.First().Username); Assert.IsFalse(result.First().Admin); Assert.IsFalse(result.First().Deleted); } }
public async Task ThrowException_WhenAParameter_IsNotPassed() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ThrowException_WhenAParameter_IsNotPassed") .Options; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var amountsDictionary = Enum.GetNames(typeof(TransactionType)).ToDictionary(name => name, value => 0m); userWallet = new Wallet { Currency = Currency.GBP, Balance = 0, User = user, }; foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = null // here there is no passed parameter }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(userWallet); await actContext.SaveChangesAsync(); } var getCurrencySymbol = CultureReferences.CurrencySymbols.TryGetValue(userWallet.Currency.ToString(), out string currencySymbol); var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var walletService = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProvider); await Assert.ThrowsExceptionAsync <EntityNotFoundException>(async() => await walletService.GetUserWallet(user)); } }
public async Task UpdateUser_WhenParamatersAreValidAndUserExists() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "UpdateUser_WhenParamatersAreValidAndUserExistsDeleteUser") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); await command.DeleteUser(testUser.Id); var deletedUser = await assertContext.Users.Where(user => user.Id == testUser.Id).FirstAsync(); Assert.IsTrue(deletedUser.IsDeleted); } }
public async Task ReturnCorrectUpdatedWallet() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnCorrectUpdatedWallet") .Options; decimal stake = 1000; dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; userWallet = new Wallet { Currency = Currency.GBP, Balance = 0, User = user, }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(userWallet); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var walletService = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProvider); var updateWallet = await walletService.UpdateUserWallet(user, stake); Assert.AreEqual(stake, updateWallet.Balance); } }
public async Task ReturnCorrectData_WhenParamatersAreValidAndUserExists() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnCorrectData_WhenParamatersAreValidAndUserExists") .UseInternalServiceProvider(serviceProvider) .Options; var foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 0m) }; foreignExchangeServiceMock.Setup(exchange => exchange.GetConvertionRates()) .Returns(Task.FromResult(foreignExchangeDTO)); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testWallet); await actContext.SaveChangesAsync(); testUser.Wallet = testWallet; await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); var result = await command.GetUserInfo(testUser.Id); Assert.IsInstanceOfType(result, typeof(UserInfoDTO)); Assert.AreEqual(testUser.UserName, result.Username); Assert.AreEqual(testWallet.Balance, result.Balance); Assert.AreEqual(walletCurrency.ToString(), result.Currency); Assert.AreEqual(testUser.Id, result.UserId); Assert.IsFalse(result.Admin); } }
public async Task ThrowException_When_NullOrInvalidParamsPassed() { // Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ThrowException_When_NullOrInvalidParamsPassed") .Options; decimal amount = 1000; dateTimeProviderMock = new Mock <IDateTimeProvider>(); user = new User(); userWallet = new Wallet { Currency = Currency.GBP, Balance = 2000, // we put 2000 in balance otherwise the method will return an null DTO (business logic) User = user, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, LastDigits = lastDigits, ExpiryDate = DateTime.Parse("03.03.2022"), User = user, CreatedOn = dateTimeProviderMock.Object.Now }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = null }; var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(userWallet); await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var walletService = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProviderMock.Object); await Assert.ThrowsExceptionAsync <EntityNotFoundException>(async() => await walletService.WithdrawFromUserBalance(user, amount, creditCard.Id)); } }
public async Task RemoveFromUserRolesTable_WhenParamatersAreValidAndUserExists() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "RemoveFromUserRolesTable_WhenParamatersAreValidAndUserExists") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); await actContext.AddAsync(testRole); await actContext.SaveChangesAsync(); var userRole = new IdentityUserRole <string>(); userRole.UserId = testUser.Id; userRole.RoleId = testRole.Id; await actContext.AddAsync(userRole); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); await command.ToggleAdmin(testUser.Id); var updatedUser = await assertContext.Users.Where(user => user.Id == testUser.Id).FirstOrDefaultAsync(); var assignedRole = await assertContext.Roles.Where(role => role.Id == testRole.Id).FirstOrDefaultAsync(); var userRole = await assertContext.UserRoles.Where(ur => ur.UserId == updatedUser.Id && ur.RoleId == assignedRole.Id).FirstOrDefaultAsync(); Assert.IsNull(userRole); } }
public async Task ReturnTrue_IfCardDoesntExist() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnTrue_IfCardDoesntExist") .Options; dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, ExpiryDate = DateTime.Parse("02.03.2020"), User = user, UserId = user.Id, }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } // Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var cardService = new CardService(assertContext, dateTimeProvider); //We pass in a different cardNumber which is not added thus it does not exist in the context! var doesCardExist = cardService.DoesCardExist("23232112412"); Assert.IsTrue(doesCardExist); } }
public async Task ThrowEntityNotFoundException_WhenUserCurrencyIsNotInCurrencyRates() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityNotFoundException_WhenUserCurrencyIsNotInCurrencyRates") .UseInternalServiceProvider(serviceProvider) .Options; var foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = new Dictionary <string, decimal>() }; foreignExchangeServiceMock.Setup(exchange => exchange.GetConvertionRates()) .Returns(Task.FromResult(foreignExchangeDTO)); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testWallet); await actContext.SaveChangesAsync(); testUser.Wallet = testWallet; await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); await Assert.ThrowsExceptionAsync <EntityNotFoundException>(async() => await command.GetUserInfo(testUser.Id)); } }
public async Task ReturnDeletedCard_AsNewCard_AfterReadding() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnDeletedCard_AsNewCard_AfterReadding") .Options; dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, ExpiryDate = DateTime.Parse("02.03.2020"), IsDeleted = true, User = user }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } // Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var cardService = new CardService(assertContext, dateTimeProvider); CreditCard creditCardResult = await cardService.AddCard(cardNumber, cvv, DateTime.Parse("02.03.2020"), user); Assert.IsInstanceOfType(creditCardResult, typeof(CreditCard)); } }
public async Task ThrowException_When_CardAlreadyExists() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ThrowException_When_CardAlreadyExists") .Options; dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, ExpiryDate = DateTime.Parse("02.03.2020"), User = user, UserId = user.Id }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var cardService = new CardService(actContext, dateTimeProvider); await Assert.ThrowsExceptionAsync <EntityAlreadyExistsException>(async() => await cardService.AddCard("23232141412", "3232", DateTime.Parse("02.03.2020"), user)); } }
public async Task ThrowException_When_NullValuesArePassed() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ThrowException_When_NullValuesArePassed") .Options; decimal stake = 1000; user = new User(); userWallet = new Wallet(); foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); dateTimeProvider = new DateTimeProvider(); using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(userWallet); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var walletService = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProvider); await Assert.ThrowsExceptionAsync <EntityNotFoundException>(async() => await walletService.UpdateUserWallet(user, stake)); } }
public async Task UpdateUser_WhenParamatersAreValidAndUserExists() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "UpdateUser_WhenParamatersAreValidAndUserExistsLockoutUser") .UseInternalServiceProvider(serviceProvider) .Options; dateTimeProviderMock .Setup(date => date.UtcNow) .Returns(DateTime.Parse(fakeDate)); dateTimeProviderMock .Setup(date => date.Now) .Returns(DateTime.Parse(fakeDate)); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.AddAsync(testUser); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var command = new UserService(assertContext, foreignExchangeServiceMock.Object, walletServiceMock.Object, dateTimeProviderMock.Object); await command.LockoutUser(testUser.Id, lockoutDays); var lockedUser = await assertContext.Users.Where(user => user.Id == testUser.Id).FirstAsync(); Assert.IsNotNull(lockedUser.LockoutEnd); Assert.AreEqual(DateTime.Parse(fakeDate).AddDays(1).Date, lockedUser.LockoutEnd.Value.Date); } }
public async Task ReturnCardToDelete_WhenValidParams_Passed() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnCardToDelete_WhenValidParams_Passed") .Options; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, ExpiryDate = DateTime.Parse("02.03.2018"), User = user, UserId = user.Id, }; dateTimeProvider = new DateTimeProvider(); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var cardService = new CardService(assertContext, dateTimeProvider); var cardToDelete = await cardService.DeleteCard(creditCard.Id); Assert.IsInstanceOfType(cardToDelete, typeof(CreditCard)); Assert.IsTrue(cardToDelete.IsDeleted); } }
public static void SeedAdmins(this IApplicationBuilder builder, UserManager <User> userManager, ItsAllAboutTheGameDbContext context) { Task.Run(async() => { //Here we create the Admin account if (await userManager.FindByEmailAsync(GlobalConstants.AdminEmail) == null) { var wallet = new Wallet() { Balance = 0, Currency = Currency.BGN }; context.Wallets.Add(wallet); await context.SaveChangesAsync(); User user = new User { UserName = GlobalConstants.AdminEmail, FirstName = "Admin", LastName = "Admin", DateOfBirth = DateTime.Parse("1/1/1991"), Email = GlobalConstants.AdminEmail, Wallet = wallet, WalletId = wallet.Id, Role = UserRole.Administrator }; var result = await userManager.CreateAsync(user, "Admin123_"); if (result.Succeeded) { await userManager.AddToRoleAsync(user, GlobalConstants.AdminRole); } } //Here we create the MasterAdmin account if (await userManager.FindByEmailAsync(GlobalConstants.MasterAdminEmail) == null) { var wallet = new Wallet() { Balance = 0, Currency = Currency.BGN }; context.Wallets.Add(wallet); await context.SaveChangesAsync(); User user = new User { UserName = GlobalConstants.MasterAdminEmail, FirstName = "MasterAdmin", LastName = "MasterAdmin", DateOfBirth = DateTime.Parse("1/1/1991"), Email = GlobalConstants.MasterAdminEmail, Wallet = wallet, WalletId = wallet.Id, Role = UserRole.MasterAdministrator }; var result = await userManager.CreateAsync(user, "Admin123_"); if (result.Succeeded) { await userManager.AddToRoleAsync(user, GlobalConstants.MasterAdminRole); } } }).Wait(); }
public async Task ReturnTransactionDTO_WhenPassedValidParams() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnTransactionDTO_WhenPassedValidParams") .Options; decimal amount = 1000; dateTimeProviderMock = new Mock <IDateTimeProvider>(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; userWallet = new Wallet { Currency = Currency.GBP, Balance = 2000, // we put 2000 in balance otherwise the method will return an null DTO (business logic) User = user, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, LastDigits = lastDigits, ExpiryDate = DateTime.Parse("03.03.2022"), User = user, CreatedOn = dateTimeProviderMock.Object.Now }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.CreditCards.AddAsync(creditCard); await actContext.Wallets.AddAsync(userWallet); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var walletService = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProviderMock.Object); var transactionDTO = await walletService.WithdrawFromUserBalance(user, amount, creditCard.Id); Assert.IsInstanceOfType(transactionDTO, typeof(TransactionDTO)); Assert.IsTrue(transactionDTO.Username == user.UserName); } }
public async Task ReturnPageList_OfTransactionDTO_WithDefaultParams() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnPageList_OfTransactionDTO_WithDefaultParams") .Options; dateTimeProviderMock = new Mock <IDateTimeProvider>(); foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; userTwo = new User { Id = userIdTwo, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userNameTwo, CreatedOn = dateTimeProviderMock.Object.Now, Email = emailTwo, FirstName = firstNameTwo, LastName = lastNameTwo, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var transaction = new Transaction { Type = TransactionType.Deposit, Description = GlobalConstants.DepositDescription + "3232".PadLeft(16, '*'), User = user, Amount = 1000, CreatedOn = dateTimeProviderMock.Object.Now, Currency = Currency.BGN }; var transactionTwo = new Transaction { Type = TransactionType.Deposit, Description = GlobalConstants.DepositDescription + "3102".PadLeft(16, '*'), User = userTwo, Amount = 1500, CreatedOn = dateTimeProviderMock.Object.Now.AddDays(1), // adding 1 day otherwise it will be created at the exact same time as the first transaction Currency = Currency.USD }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Users.AddAsync(userTwo); await actContext.Transactions.AddAsync(transaction); await actContext.Transactions.AddAsync(transactionTwo); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProviderMock.Object); var pageList = await sut.GetAllTransactions(); Assert.IsInstanceOfType(pageList, typeof(IPagedList <TransactionDTO>)); Assert.IsTrue(pageList.Count == 2); Assert.IsTrue(pageList.Select(c => c.Username).First() == userTwo.UserName); } }
public async Task ReturnTransactionListDTO_With_ConcreteUserParams() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnTransactionListDTO_With_ConcreteUserParam") .Options; dateTimeProviderMock = new Mock <IDateTimeProvider>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); user = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var userTwo = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = "******", CreatedOn = dateTimeProviderMock.Object.Now.AddDays(1), Email = "email", FirstName = "firstName", LastName = "lastName", DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var transaction = new Transaction { Type = TransactionType.Deposit, Description = GlobalConstants.DepositDescription + "3232".PadLeft(16, '*'), User = user, Amount = 1000, CreatedOn = dateTimeProviderMock.Object.Now, Currency = Currency.BGN }; var transactionTwo = new Transaction { Type = TransactionType.Deposit, Description = GlobalConstants.DepositDescription + "3102".PadLeft(16, '*'), User = userTwo, Amount = 1500, CreatedOn = dateTimeProviderMock.Object.Now.AddDays(1), // adding 1 day otherwise it will be created at the exact same time as the first transaction Currency = Currency.USD }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Users.AddAsync(userTwo); await actContext.Transactions.AddAsync(transaction); await actContext.Transactions.AddAsync(transactionTwo); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProviderMock.Object); var listDTO = await sut.GetUserTransactions(user.UserName); // we get only the DTO of one of the users Assert.IsInstanceOfType(listDTO, typeof(TransactionListDTO)); Assert.IsTrue(listDTO.TotalItemCount == 1); } }
public async Task ReturnEmptyTransactionListDTO_With_UserWalletCurrency_WhenUserHasNoTransactions() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnEmptyTransactionListDTO_With_UserWalletCurrency_WhenUserHasNoTransactions") .Options; dateTimeProviderMock = new Mock <IDateTimeProvider>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); user = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var userTwo = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = "******", CreatedOn = dateTimeProviderMock.Object.Now.AddDays(1), Email = "email", FirstName = "firstName", LastName = "lastName", DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var wallet = new Wallet { Balance = 0, Currency = Currency.GBP, User = user }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Users.AddAsync(userTwo); await actContext.Wallets.AddAsync(wallet); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProviderMock.Object); var listDTO = await sut.GetUserTransactions(user.UserName); // we get only the DTO of one of the users Assert.IsInstanceOfType(listDTO, typeof(TransactionListDTO)); Assert.IsTrue(listDTO.TotalItemCount == 0); } }
public async Task ReturnTransactionDTO_OfTypeStakeAndWin_WhenPassedValidParams(string userName, string amount, string game, string description, string type) { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnTransactionDTO_OfTypeStakeAndWin_WhenPassedValidParams") .Options; dateTimeProviderMock = new Mock <IDateTimeProvider>(); foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); var user = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = "*****@*****.**", FirstName = "Edward", LastName = "Evlogiev", DateOfBirth = DateTime.Parse("12.03.1993"), Role = UserRole.None, }; var wallet = new Wallet { Balance = 0, Currency = Currency.EUR, User = user }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(wallet); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProviderMock.Object); assertContext.Attach(wallet); var gameResult = await sut.GameTransaction(user, int.Parse(amount), game, description, (TransactionType)Enum.Parse(typeof(TransactionType), type)); Assert.IsInstanceOfType(gameResult, typeof(TransactionDTO)); Assert.IsTrue(gameResult.Description == description + game); Assert.IsTrue(gameResult.Type == (TransactionType)Enum.Parse(typeof(TransactionType), type)); Assert.IsTrue(gameResult.Amount == int.Parse(amount) / 2); Assert.IsTrue(gameResult.Username == userName); } }
public async Task MakeTransactions_ThatAreAdded_ToTheBase(string userName, string amount, string game, string description, string type) { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "MakeTransactions_ThatAreAdded_ToTheBase") .Options; dateTimeProviderMock = new Mock <IDateTimeProvider>(); foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); var user = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = "*****@*****.**", FirstName = "Edward", LastName = "Evlogiev", DateOfBirth = DateTime.Parse("12.03.1993"), Role = UserRole.None, }; var wallet = new Wallet { Balance = 0, Currency = Currency.EUR, User = user }; var transaction = new Transaction() { Type = (TransactionType)Enum.Parse(typeof(TransactionType), type), Description = description + game, User = user, Amount = int.Parse(amount) / foreignExchangeDTO.Rates[Currency.EUR.ToString()], CreatedOn = dateTimeProviderMock.Object.Now, Currency = wallet.Currency }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(wallet); await actContext.Transactions.AddAsync(transaction); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProviderMock.Object); assertContext.Attach(wallet); var gameResult = await sut.GameTransaction(user, int.Parse(amount), game, description, (TransactionType)Enum.Parse(typeof(TransactionType), type)); Assert.AreEqual(transaction, await assertContext.Transactions.Where(t => t.User == user).FirstOrDefaultAsync()); } }
public async Task ReturnListOfCards_AfterSelectingUserExistingCards() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnListOfCards_AfterSelectingUserExistingCards") .Options; dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; creditCard = new CreditCard { CardNumber = cardNumberOne, CVV = cvvOne, ExpiryDate = DateTime.Parse("02.03.2020"), User = user, UserId = user.Id, }; creditCardTwo = new CreditCard { CardNumber = cardNumberTwo, CVV = cvvTwo, ExpiryDate = DateTime.Parse("02.03.2016"), User = user, UserId = user.Id, }; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.CreditCards.AddAsync(creditCard); await actContext.CreditCards.AddAsync(creditCardTwo); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var cardService = new CardService(assertContext, dateTimeProvider); var userCards = await cardService.GetSelectListCards(user); Assert.IsInstanceOfType(userCards, typeof(IEnumerable <SelectListItem>)); } }
public async Task ReturnTransactionDTO_When_PassedValidParams() { //Arrange var contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnTransactionDTO_When_PassedValidParams") .UseInternalServiceProvider(serviceProvider) .Options; dateTimeProvider = new Mock <IDateTimeProvider>(); foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); decimal amount = 1000; user = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None }; userWallet = new Wallet { Currency = Currency.GBP, Balance = 2000, // we put 2000 in balance otherwise the method will return an null DTO (business logic) User = user, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, LastDigits = lastDigits, ExpiryDate = DateTime.Parse("03.03.2022"), User = user, CreatedOn = dateTimeProvider.Object.Now }; foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeServiceMock .Setup(foreign => foreign.GetConvertionRates()) .ReturnsAsync(foreignExchangeDTO); userWalletDTO = new WalletDTO(userWallet, foreignExchangeDTO); walletServiceMock = new Mock <IWalletService>(); walletServiceMock .Setup(wsm => wsm.GetUserWallet(It.IsAny <User>())) .ReturnsAsync(userWalletDTO); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.SaveChangesAsync(); await actContext.Wallets.AddAsync(userWallet); await actContext.SaveChangesAsync(); await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProvider.Object); assertContext.Attach(user);//We tell the context to monitor the selected object var transactionDTO = await sut.MakeDeposit(user, creditCard.Id, amount); Assert.IsInstanceOfType(transactionDTO, typeof(TransactionDTO)); } }
public async Task ReturnCorrectConvertedBalance_When_PassedValidValue() { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnCorrectConvertedBalance_When_PassedValidValue") .Options; dateTimeProvider = new DateTimeProvider(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProvider.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; userWallet = new Wallet { Currency = Currency.GBP, Balance = 2000, // we put 2000 in balance otherwise the method will return an null DTO (business logic) User = user, }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Wallets.AddAsync(userWallet); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProvider); var convertedBalance = await sut.ConvertBalance(user); var currentWalletBalance = await assertContext.Wallets.Where(w => w.User == user).FirstOrDefaultAsync(); var expectedAmount = currentWalletBalance.Balance * foreignExchangeDTO.Rates[userWallet.Currency.ToString()]; Assert.AreEqual(expectedAmount, convertedBalance); } }
public async Task ThrowException_When_CardIsDeleted() { // Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ThrowException_When_CardIsDeleted") .Options; decimal amount = 1000; dateTimeProviderMock = new Mock <IDateTimeProvider>(); user = new User { Id = userId, Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; creditCard = new CreditCard { CardNumber = cardNumber, CVV = cvv, LastDigits = lastDigits, ExpiryDate = DateTime.Parse("03.03.2022"), User = user, CreatedOn = dateTimeProviderMock.Object.Now, IsDeleted = true }; foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) // All of the rates are with value 2 for testing purposes (value => 2m) }; var currencies = foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.CreditCards.AddAsync(creditCard); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var walletService = new WalletService(assertContext, foreignExchangeServiceMock.Object, dateTimeProviderMock.Object); await Assert.ThrowsExceptionAsync <EntityNotFoundException>(async() => await walletService.WithdrawFromUserBalance(user, amount, creditCard.Id)); } }
public async Task ReturnDictionary_WithConcreteUserParams(string transactionType, string userName, string firstName, string lastName) { //Arrange contextOptions = new DbContextOptionsBuilder <ItsAllAboutTheGameDbContext>() .UseInMemoryDatabase(databaseName: "ReturnDictionary_WithConcreteUserParams") .Options; dateTimeProviderMock = new Mock <IDateTimeProvider>(); foreignExchangeServiceMock = new Mock <IForeignExchangeService>(); walletServiceMock = new Mock <IWalletService>(); userServiceMock = new Mock <IUserService>(); cardServiceMock = new Mock <ICardService>(); foreignExchangeDTO = new ForeignExchangeDTO { Base = GlobalConstants.BaseCurrency, Rates = Enum.GetNames(typeof(Currency)).ToDictionary(name => name, value => 2m) }; foreignExchangeServiceMock.Setup(fesm => fesm.GetConvertionRates()).ReturnsAsync(foreignExchangeDTO); user = new User { Cards = new List <CreditCard>(), Transactions = new List <Transaction>(), UserName = userName, CreatedOn = dateTimeProviderMock.Object.Now, Email = email, FirstName = firstName, LastName = lastName, DateOfBirth = DateTime.Parse("02.01.1996"), Role = UserRole.None, }; var transaction = new Transaction { Type = (TransactionType)Enum.Parse(typeof(TransactionType), transactionType), Description = GlobalConstants.DepositDescription + "3232".PadLeft(16, '*'), User = user, Amount = 1000, CreatedOn = dateTimeProviderMock.Object.Now, Currency = Currency.BGN }; var transactionTwo = new Transaction { Type = (TransactionType)Enum.Parse(typeof(TransactionType), transactionType), Description = GlobalConstants.DepositDescription + "3102".PadLeft(16, '*'), User = user, Amount = 1495.5332m, CreatedOn = dateTimeProviderMock.Object.Now.AddDays(1), // adding 1 day otherwise it will be created at the exact same time as the first transaction Currency = Currency.BGN }; int digitsAfterFloatingPoint; //Act using (var actContext = new ItsAllAboutTheGameDbContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.Transactions.AddAsync(transaction); await actContext.Transactions.AddAsync(transactionTwo); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new ItsAllAboutTheGameDbContext(contextOptions)) { var sut = new TransactionService(assertContext, walletServiceMock.Object, userServiceMock.Object, foreignExchangeServiceMock.Object, cardServiceMock.Object, dateTimeProviderMock.Object); var dictionaryResult = await sut.GetAllAmounts(); digitsAfterFloatingPoint = dictionaryResult[transactionType] .ToString() .Substring(dictionaryResult[transactionType] .ToString() .IndexOf(".") + 1) .Length; Assert.IsInstanceOfType(dictionaryResult, typeof(Dictionary <string, decimal>)); Assert.IsTrue(digitsAfterFloatingPoint == 2); } }