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");
}
