public async Task CanQueryOrdersByStatus(Fixture fixture) { // Arrange var statusToTest = ToGoOrderStatus.Pending; var ordersToInsert = fixture .Build <ToGoOrder>() .With(o => o.Status, statusToTest) .CreateMany() .ToList(); await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.ToGoOrders.AddRange(ordersToInsert); await dbContext.SaveChangesAsync(); }); var queryToTest = new GetOrdersByStatus { Status = statusToTest }; // Act var orders = await _fixture.SendAsync(queryToTest); // Assert (orders.Count == ordersToInsert.Count && orders.All(order => ordersToInsert.Any(insertedOrder => order.Id == insertedOrder.Id && order.OrderedItems.Count == insertedOrder.OrderedItems.Count && order.Status == insertedOrder.Status && !string.IsNullOrEmpty(order.StatusText)))) .ShouldBeTrue(); }
public async Task CanAssignBaristaToAccount(Register accountToRegisterCommand, Barista baristaToAssign) { // Arrange await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.Baristas.Add(baristaToAssign); await dbContext.SaveChangesAsync(); }); await _fixture.SendAsync(accountToRegisterCommand); var commandToTest = new AssignBaristaToAccount { BaristaId = baristaToAssign.Id, AccountId = accountToRegisterCommand.Id }; // Act var result = await _fixture.SendAsync(commandToTest); // Assert await _helper.LoginAndCheckClaim( accountToRegisterCommand.Email, accountToRegisterCommand.Password, c => c.Type == AuthConstants.ClaimTypes.BaristaId && c.Value == baristaToAssign.Id.ToString()); }
public async Task CanAssignWaiterToAccount(Register registerAccountCommand, Waiter waiterToAssign) { // Arrange await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.Waiters.Add(waiterToAssign); await dbContext.SaveChangesAsync(); }); await _fixture.SendAsync(registerAccountCommand); var commandToTest = new AssignWaiterToAccount { WaiterId = waiterToAssign.Id, AccountId = registerAccountCommand.Id }; // Act var result = await _fixture.SendAsync(commandToTest); // Assert await _helper.LoginAndCheckClaim( registerAccountCommand.Email, registerAccountCommand.Password, c => c.Type == AuthConstants.ClaimTypes.WaiterId && c.Value == waiterToAssign.Id.ToString()); }
public async Task AddBarista(Barista barista) { await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.Baristas.Add(barista); await dbContext.SaveChangesAsync(); }); }
public async Task UserCanBetForAwayTeam( Fixture fixture, Team homeTeam, Team awayTeam, Register registerCommand) { // Arrange await _authTestsHelper .RegisterAndLogin(registerCommand); var match = await _matchTestHelper .RegistrateMatchAsync(fixture, homeTeam, awayTeam); var betCommand = new UserBetForAwayTeam { UserId = registerCommand.Id, MatchId = match.Id, AwayBet = fixture.Create <decimal>(), }; // Act var result = await _fixture.SendAsync(betCommand); // Assert var isBetExists = await _fixture.ExecuteDbContextAsync( async context => context.UserMatchBets .Any(bet => bet.UserId == registerCommand.Id && bet.MatchId == match.Id && bet.AwayBet == betCommand.AwayBet && bet.HomeBet == 0)); isBetExists.ShouldBeTrue(); }
public async Task UserTeamVotesAreSentToAllSubscribers( Register registerCommand, Team teamToVote) { // Arrange await _authTestsHelper.Register(registerCommand); await _fixture.ExecuteDbContextAsync(async dbContext => { await dbContext.Teams.AddAsync(teamToVote); await dbContext.SaveChangesAsync(); }); var testConnection = BuildTestConnection(); var voteForTeamCommand = new VoteForTeam(teamToVote.Id, registerCommand.Id); // Act await _fixture.SendAsync(voteForTeamCommand); // Assert testConnection .VerifyMessageReceived( team => team.UserId == voteForTeamCommand.UserId && team.TeamId == voteForTeamCommand.TeamId, Times.Never()); }
public async Task <Match> RegistrateMatchAsync( ISpecimenBuilder fixture, Team homeTeam, Team awayTeam) { var team1 = await _teamTestsHelper.AddAsync(homeTeam); var team2 = await _teamTestsHelper.AddAsync(awayTeam); var currentMatch = new Match { Id = Guid.NewGuid(), AwayTeamId = team2.Id, HomeTeamId = team1.Id, Start = fixture.Create <DateTime>(), }; await _fixture.ExecuteDbContextAsync(async dbContext => { await dbContext.Matches.AddAsync(currentMatch); await dbContext.SaveChangesAsync(); }); return(currentMatch); }
public async Task ItAddsAnIngredient() { var ingredientName = Guid.NewGuid().ToString(); var recipe = new Recipe(name: nameof(ItAddsAnIngredient)); await AppFixture.InsertAsync(recipe); var result = await AppFixture.SendAsync(new AddIngredientRequest { RecipeKey = new ModelUpdateIdentifier(recipe), Name = ingredientName, Quantity = 42M, UnitOfMeasure = UnitOfMeasure.Pint }); var saved = await AppFixture.ExecuteDbContextAsync(db => db.RecipeIngredients .Include(ri => ri.Ingredient) .Include(ri => ri.Recipe) .Where(ri => ri.Key == result.Key) .FirstOrDefaultAsync()); saved.Ingredient.Name.Should().Be(ingredientName); saved.Recipe.Key.Should().Be(recipe.Key); saved.UnitOfMeasure.Should().Be(UnitOfMeasure.Pint); saved.Quantity.Should().Be(42M); }
public async Task CanAssignTable(HireWaiter hireWaiterCommand, AddTable addTableCommand) { // Arrange await _fixture.SendAsync(addTableCommand); await _fixture.SendAsync(hireWaiterCommand); var assignTableCommand = new AssignTable { WaiterId = hireWaiterCommand.Id, TableNumber = addTableCommand.Number }; // Act var result = await _fixture.SendAsync(assignTableCommand); // Assert var tableInDb = await _fixture.ExecuteDbContextAsync(dbContext => dbContext .Tables .Include(t => t.Waiter) .ThenInclude(w => w.ServedTables) .FirstOrDefaultAsync(t => t.Id == addTableCommand.Id)); tableInDb.ShouldNotBeNull(); tableInDb.WaiterId.ShouldBe(hireWaiterCommand.Id); tableInDb.Waiter.ShouldNotBeNull(); tableInDb.Waiter.ShortName.ShouldBe(hireWaiterCommand.ShortName); tableInDb.Waiter.ServedTables.ShouldContain(t => t.Id == addTableCommand.Id && t.Number == assignTableCommand.TableNumber); }
public async Task CanGetAllEmployedBaristas(GetEmployedBaristas query, Barista[] baristasToHire) { // Arrange await _fixture.ExecuteDbContextAsync(async dbContext => { // Completed orders will be automatically generated by AutoFixture dbContext.Baristas.AddRange(baristasToHire); await dbContext.SaveChangesAsync(); }); // Act var baristas = await _fixture.SendAsync(query); // Assert (baristas.Count == baristasToHire.Length && baristas.All(b => baristasToHire.Any(hiredBarista => b.Id == hiredBarista.Id && b.ShortName == hiredBarista.ShortName && b.CompletedOrders.Count == hiredBarista.CompletedOrders.Count && b.CompletedOrders.All(ov => hiredBarista.CompletedOrders.Any(o => o.Id == ov.Id && o.Status == ov.Status && o.OrderedItems.Count == ov.OrderedItems.Count))))) .ShouldBeTrue(); }
public async Task ItRemovesTheIngredient() { var original = new Recipe(name: nameof(ItRemovesTheIngredient)); var toDelete = original.AddIngredient(new Ingredient(Guid.NewGuid().ToString()), UnitOfMeasure.Cup, 2M); original.AddIngredient(new Ingredient(Guid.NewGuid().ToString()), UnitOfMeasure.Pint, 5M); await AppFixture.InsertAsync(original); var request = new RemoveIngredientRequest { RecipeModelKey = new ModelUpdateIdentifier(original), RecipeIngredientModelKey = new ModelUpdateIdentifier(toDelete) }; await AppFixture.SendAsync(request); var saved = await AppFixture.ExecuteDbContextAsync(async db => { return(await db.Recipes.Where(x => x.Id == original.Id).Include(x => x.RecipeIngredients) .FirstOrDefaultAsync()); }); saved.RecipeIngredients.Should().HaveCount(1); saved.RecipeIngredients[0].UnitOfMeasure.Should().Be(UnitOfMeasure.Pint); }
public async Task CompletedOrderIsAssignedToTheCompletingBarista(Guid orderId, Barista barista, MenuItem[] items) { // Arrange await _helper.AddBarista(barista); await _helper.CreateConfirmedOrder(orderId, items); var commandToTest = new CompleteToGoOrder { OrderId = orderId, BaristaId = barista.Id.Some <Guid>() }; // Act var result = await _fixture.SendAsync(commandToTest); // Assert var updatedBarista = await _fixture.ExecuteDbContextAsync(dbContext => dbContext .Baristas .Include(b => b.CompletedOrders) .FirstOrDefaultAsync(b => b.Id == barista.Id)); updatedBarista.CompletedOrders.ShouldContain(o => o.Id == orderId); }
public async Task GetRecipe_FetchesAndMaps() { var recipe = await AppFixture.ExecuteDbContextAsync(async db => { var recipe = new Recipe(name: nameof(GetRecipe_FetchesAndMaps) + Guid.NewGuid()) { Description = "Testing a load", CookTime = Duration.FromMinutes(60), PrepTime = Duration.FromMinutes(15) }; var ingredient = new Ingredient("Sugar"); recipe.AddIngredient(ingredient, UnitOfMeasure.Cup, 1M); db.Recipes.Add(recipe); await Task.CompletedTask; return(recipe); }); var response = await AppFixture.SendAsync(new GetRecipeRequest { Key = recipe.Key }); response.Name.Should().StartWith(nameof(GetRecipe_FetchesAndMaps)); response.CookTime.Should().Be(Duration.FromHours(1)); response.RecipeIngredients.Should().HaveCount(1); recipe.RecipeIngredients[0].Ingredient.Name.Should().Be("Sugar"); }
public Task <Team> AddAsync(Team team) => _fixture.ExecuteDbContextAsync( async context => { await context.Teams.AddAsync(team); await context.SaveChangesAsync(); return(team); });
public async Task AddMenuItems(params MenuItem[] items) { await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.MenuItems.AddRange(items); await dbContext.SaveChangesAsync(); }); }
public async Task InTheContextOfAWaiter(Func <Waiter, Func <HttpClient, Task> > serverCall, Fixture fixture) { var hireWaiter = fixture.Create <HireWaiter>(); await _tabHelper.SetupWaiterWithTable(hireWaiter, fixture.Create <AddTable>()); var waiter = await _appFixture.ExecuteDbContextAsync(dbContext => dbContext .Waiters .Include(w => w.ServedTables) .FirstAsync(w => w.Id == hireWaiter.Id)); var token = await SetupUserWithClaims( fixture, new List <Claim> { new Claim(AuthConstants.ClaimTypes.WaiterId, waiter.Id.ToString()) }); await _appFixture.ExecuteHttpClientAsync(serverCall(waiter), token); }
public async Task CanAddTable(AddTable command) { // Arrange // Act var result = await _fixture.SendAsync(command); // Assert var tableInDb = await _fixture.ExecuteDbContextAsync(dbContext => dbContext.Tables.FirstOrDefaultAsync(t => t.Id == command.Id)); tableInDb.ShouldNotBeNull(); tableInDb.Number.ShouldBe(command.Number); }
public async Task CanRegister(Register command) { // Act var result = await _fixture.SendAsync(command); // Assert result.HasValue.ShouldBeTrue(); var userInDb = await _fixture .ExecuteDbContextAsync(context => context.Users.FirstOrDefaultAsync(u => u.Id == command.Id)); userInDb.Id.ShouldBe(command.Id); userInDb.Email.ShouldBe(command.Email); userInDb.FirstName.ShouldBe(command.FirstName); userInDb.LastName.ShouldBe(command.LastName); }
public async Task CanHireWaiter(HireWaiter command) { // Arrange // Act var result = await _fixture.SendAsync(command); // Assert result.HasValue.ShouldBeTrue(); var waiterInDb = await _fixture.ExecuteDbContextAsync(dbContext => dbContext .Waiters .FirstOrDefaultAsync(w => w.Id == command.Id)); waiterInDb.Id.ShouldBe(command.Id); waiterInDb.ShortName.ShouldBe(command.ShortName); }
public async Task CanSaveASimpleRecipe() { var recipe = new Recipe(name: "Chocolate Milk") { PrepTime = Duration.FromMinutes(3), CookTime = Duration.Zero }; var milk = new Ingredient("Milk"); var chocolateSauce = new Ingredient("Chocolate Sauce"); recipe.AddIngredient(milk, UnitOfMeasure.Cup, 1M); recipe.AddIngredient(chocolateSauce, UnitOfMeasure.Tablespoon, 2M); await AppFixture.InsertAsync(recipe); var saved = await AppFixture.ExecuteDbContextAsync(db => db.Recipes .Include(r => r.RecipeIngredients) .ThenInclude(ri => ri.Ingredient) .Where(r => r.Key == recipe.Key) .FirstOrDefaultAsync()); saved.Name.Should().Be("Chocolate Milk"); saved.PrepTime.Should().Be(Duration.FromMinutes(3)); saved.CookTime.Should().Be(Duration.Zero); saved.RecipeIngredients.Should().HaveCount(2) .And.SatisfyRespectively( first => { first.Id.Should().BeGreaterThan(0); first.Key.Should().NotBe(Guid.Empty); first.Quantity.Should().Be(1M); first.UnitOfMeasure.Should().Be(UnitOfMeasure.Cup); first.Ingredient.Should().Be(milk); }, second => { second.Id.Should().BeGreaterThan(0); second.Key.Should().NotBe(Guid.Empty); second.Quantity.Should().Be(2M); second.UnitOfMeasure.Should().Be(UnitOfMeasure.Tablespoon); second.Ingredient.Should().Be(chocolateSauce); }); }
public async Task CanGetAllEmployedCashiers(GetEmployedCashiers query, Cashier[] cashiersToHire) { // Arrange await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.Cashiers.AddRange(cashiersToHire); await dbContext.SaveChangesAsync(); }); // Act var cashiers = await _fixture.SendAsync(query); // Assert (cashiers.Count == cashiersToHire.Length && cashiers.All(c => cashiersToHire.Any(hiredCashier => c.Id == hiredCashier.Id && c.ShortName == hiredCashier.ShortName))) .ShouldBeTrue(); }
public async Task CanHireManager(HireManager command) { // Act var result = await _fixture.SendAsync(command); // Assert var managerInDb = await _fixture.ExecuteDbContextAsync(dbContext => { var manager = dbContext .Managers .SingleAsync(m => m.Id == command.Id); return(manager); }); managerInDb.Id.ShouldBe(command.Id); managerInDb.ShortName.ShouldBe(command.ShortName); }
public async Task ItSoftDeletesRecords() { var original = new Recipe(name: nameof(ItSoftDeletesRecords)); await AppFixture.InsertAsync(original); await AppFixture.ExecuteDbContextAsync(async db => { var saved = await db.Recipes.FindAsync(original.Id); saved.Should().NotBeNull("we just saved it"); saved.SoftDelete(); // db.Remove(saved); }); var deleted = await AppFixture.FindAsync <Recipe>(original.Key); deleted.Should().BeNull("Recipe {0} was soft-deleted", original.Key); }
public async Task CanGetAllEmployedWaiters(GetEmployedWaiters query, Waiter[] waitersToHire) { // Arrange await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.Waiters.AddRange(waitersToHire); await dbContext.SaveChangesAsync(); }); // Act var waiters = await _fixture.SendAsync(query); // Assert (waiters.Count == waitersToHire.Length && waiters.All(w => waitersToHire.Any(hiredWaiter => w.Id == hiredWaiter.Id && w.ShortName == hiredWaiter.ShortName && w.TablesServed.Count == hiredWaiter.ServedTables.Count))) .ShouldBeTrue(); }
public async Task ItTreatsVersionAsConcurrencyToken() { var original = new Recipe(name: nameof(ItTreatsVersionAsConcurrencyToken)); await AppFixture.InsertAsync(original); FluentActions.Invoking(async() => { await AppFixture.ExecuteDbContextAsync(async db => { var saved = await db.Recipes.FirstOrDefaultAsync(x => x.Key == original.Key); saved.Name = "Sally"; // record is updated by another user while this context is working with the entity // so when it goes to save, the version numbers will no longer match await db.Database.ExecuteSqlInterpolatedAsync( $"update recipes set version = version + 1 where key = {original.Key}"); }); }).Should().Throw <DbUpdateConcurrencyException>(); }
public async Task CanHireBarista(HireBarista command) { // Arrange // Act var result = await _fixture.SendAsync(command); // Assert result.HasValue.ShouldBeTrue(); var baristaInDb = await _fixture.ExecuteDbContextAsync(dbContext => dbContext .Baristas .Include(b => b.CompletedOrders) .FirstOrDefaultAsync(b => b.Id == command.Id && b.ShortName == command.ShortName && b.CompletedOrders.Count == 0)); baristaInDb.Id.ShouldBe(command.Id); baristaInDb.ShortName.ShouldBe(command.ShortName); }
public async Task CanQueryEmployedManagers(Manager[] managersToAdd) { // Arrange await _fixture.ExecuteDbContextAsync(async dbContext => { dbContext.Managers.AddRange(managersToAdd); await dbContext.SaveChangesAsync(); }); var queryToTest = new GetEmployedManagers(); // Act var managers = await _fixture.SendAsync(queryToTest); // Assert managers.All(m => managersToAdd .Any(addedManager => m.Id == addedManager.Id && m.ShortName == addedManager.ShortName)) .ShouldBeTrue(); }
public async Task CanAddMenuItems(MenuItemView[] itemsToAdd) { // Arrange var command = new AddMenuItems { MenuItems = itemsToAdd }; // Act var result = await _fixture.SendAsync(command); // Assert var itemsInDb = await _fixture.ExecuteDbContextAsync(dbContext => dbContext .MenuItems .ToListAsync()); itemsInDb.ShouldAllBe(i => itemsToAdd.Any(addedItem => i.Number == addedItem.Number && i.Description == addedItem.Description && i.Price == addedItem.Price)); }
public async Task ItDeletesRecipeAndIngredients() { var recipe = new Recipe(name: nameof(ItDeletesRecipeAndIngredients)); var ingredient = new Ingredient(Guid.NewGuid().ToString()); recipe.AddIngredient(ingredient, UnitOfMeasure.Cup, 10M); await AppFixture.InsertAsync(recipe); await AppFixture.SendAsync(new RemoveRecipeRequest() { RecipeKey = new ModelUpdateIdentifier(recipe) }); var deleted = await AppFixture.ExecuteDbContextAsync(db => db.GetRecipe(recipe.Key)); deleted.Should().BeNull(because: "it was soft-deleted"); var deletedIngredient = await AppFixture.FindAsync <RecipeIngredient>(ingredient.Key); deletedIngredient.Should().BeNull(because: "it was soft-deleted"); }
public async Task ItBumpsTheVersionAndEditTime() { var original = new Recipe(name: nameof(ItBumpsTheVersionAndEditTime)); await AppFixture.InsertAsync(original); await AppFixture.ExecuteDbContextAsync(async db => { var saved = await db.Recipes.FirstOrDefaultAsync(x => x.Key == original.Key); saved.Name = "Milk"; }); var updated = await AppFixture.FindAsync <Recipe>(original.Key); updated.Name.Should().Be("Milk"); updated.Version.Should().Be(2); updated.UpdatedAt.ToUnixTimeMilliseconds().Should() .BeGreaterThan(original.UpdatedAt.ToUnixTimeMilliseconds(), because: "updated timestamps should be bumped on change"); updated.CreatedAt.Should().Be(original.CreatedAt, because: "created timestamps are never changed"); }