public Task AssignTableShouldReturnProperHypermediaLinks(HireWaiter hireWaiterCommand, AddTable addTableCommand, Fixture fixture) =>
_apiHelper.InTheContextOfAManager(
manager => async httpClient =>
{
// Arrange
await _fixture.SendAsync(hireWaiterCommand);
await _fixture.SendAsync(addTableCommand);
var assignTableCommand = new AssignTable
{
WaiterId = hireWaiterCommand.Id,
TableNumber = addTableCommand.Number
};
// Act
var response = await httpClient
.PostAsJsonAsync(WaiterRoute("table/assign"), assignTableCommand);
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self,
LinkNames.Waiter.GetEmployedWaiters,
LinkNames.Waiter.Hire
};
await response.ShouldBeAResource <AssignTableResource>(expectedLinks);
},
fixture);
public async Task CanConnectAsBarista(Register registerCommand, HireBarista hireBaristaCommand, Guid orderId, MenuItem[] menuItems)
{
// Arrange
await _authTestsHelper.Register(registerCommand);
await _fixture.SendAsync(hireBaristaCommand);
var assignBaristaToAccountCommand = new AssignBaristaToAccount
{
AccountId = registerCommand.Id,
BaristaId = hireBaristaCommand.Id
};
await _fixture.SendAsync(assignBaristaToAccountCommand);
var accessToken = (await _authTestsHelper.Login(registerCommand.Email, registerCommand.Password)).TokenString;
var testConnection = BuildTestConnection(accessToken);
await testConnection.OpenAsync();
// Act
await _toGoOrdersHelper.CreateConfirmedOrder(orderId, menuItems);
// Assert
await testConnection
.VerifyMessageReceived <OrderConfirmed>(
e => e.Order.Id == orderId &&
e.Order.OrderedItems.Count == menuItems.Length,
Times.Once());
}
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 Task GetAllOpenTabsShouldReturnProperHypermediaLinks(Fixture fixture) =>
_apiHelper.InTheContextOfAWaiter(
waiter => async httpClient =>
{
// Arrange
var openTabCommand = new OpenTab
{
Id = Guid.NewGuid(),
CustomerName = "Some customer",
TableNumber = waiter.ServedTables[0].Number
};
await _fixture.SendAsync(openTabCommand);
// Act
var response = await httpClient.GetAsync(TabRoute());
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self
};
var resource = await response.ShouldBeAResource <TabsContainerResource>(expectedLinks);
resource.Items.ShouldAllBe(r => r.Links.Count > 0);
},
fixture);
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 CanOrderMenuItems(
Guid tabId,
int tableNumber,
MenuItem[] itemsToOrder)
{
// Arrange
await _helper.OpenTabOnTable(tabId, tableNumber);
await _helper.AddMenuItems(itemsToOrder);
var orderItemsCommand = new OrderMenuItems
{
TabId = tabId,
ItemNumbers = itemsToOrder.Select(i => i.Number).ToList()
};
// Act
var result = await _fixture.SendAsync(orderItemsCommand);
// Assert
await _helper.AssertTabExists(
orderItemsCommand.TabId,
t => t.IsOpen == true &&
t.OutstandingMenuItems.Any() &&
orderItemsCommand.ItemNumbers.All(n => t.OutstandingMenuItems.Any(i => i.Number == n)));
}
public async Task CreateConfirmedOrder(Guid orderId, MenuItem[] items)
{
await OrderToGo(orderId, items);
await _fixture.SendAsync(new ConfirmToGoOrder
{
OrderId = orderId,
PricePaid = items.Sum(i => i.Price)
});
}
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 CanGetTabHistory(Guid[] tabIds)
{
// Arrange
await CreateClosedTabsFromIds(tabIds);
// Act
var tabs = await _fixture.SendAsync(new GetTabHistory());
// Assert
(tabs.Count == tabIds.Length &&
tabs.All(t => tabIds.Contains(t.Id)))
.ShouldBeTrue();
}
public async Task CanGetAllMenuItems(GetAllMenuItems query, MenuItem[] menuItems)
{
// Arrange
await _helper.AddMenuItems(menuItems);
// Act
var items = await _fixture.SendAsync(query);
// Assert
(items.Count == menuItems.Length &&
items.All(i => menuItems.Any(mi => i.Number == mi.Number &&
i.Description == mi.Description &&
i.Price == mi.Price)))
.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 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 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 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 ShouldNotCreateDefaultAdminAccountWhenExisting()
{
// Arrange
var configuration = await _fixture.ExecuteScopeAsync(async sp => sp.GetService <IConfiguration>());
var expectedAdminCredentials = configuration.GetAdminCredentials();
await _fixture.SendAsync(new Register
{
Id = Guid.NewGuid(),
Email = expectedAdminCredentials.Email,
Password = expectedAdminCredentials.Password,
FirstName = "Some",
LastName = "Account"
});
// Act
await _fixture.ExecuteScopeAsync(async sp =>
{
var userManager = sp.GetService <UserManager <User> >();
var result = await DatabaseConfiguration
.AddDefaultAdminAccountIfNoneExisting(userManager, configuration);
// Assert
result.HasValue.ShouldBeFalse();
});
}
public async Task CanGetAllOpenTabs(Guid[] tabIds)
{
// Arrange
for (int i = 0; i < tabIds.Length; i++)
{
await _helper.OpenTabOnTable(tabIds[i], tableNumber : i + 1);
}
// Act
var tabs = await _fixture.SendAsync(new GetAllOpenTabs());
// Assert
(tabs.Count == tabIds.Length &&
tabs.All(t => tabIds.Contains(t.Id)))
.ShouldBeTrue();
}
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 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 LoginAndCheckClaim(string email, string password, Func <Claim, bool> claimPredicate)
{
var loginResult = await _fixture.SendAsync(new Login
{
Email = email,
Password = password
});
loginResult.Exists(jwt =>
{
var decoded = new JwtSecurityToken(jwt.TokenString);
return(decoded
.Claims
.Any(claimPredicate));
})
.ShouldBeTrue();
}
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 AuthenticatedSubscribersAreNotifiedAboutHiredWaiters(HireWaiter hireWaiterCommand)
{
// Arrange
var adminAccessToken = await _authTestsHelper.GetAdminToken();
var testConnection = BuildTestConnection(adminAccessToken);
await testConnection.OpenAsync();
// Act
await _fixture.SendAsync(hireWaiterCommand);
// Assert
await testConnection
.VerifyMessageReceived <WaiterHired>(
e => e.Waiter.Id == hireWaiterCommand.Id &&
e.Waiter.ShortName == hireWaiterCommand.ShortName,
Times.Once());
}
public async Task CanConfirmToGoOrder(Guid orderId, MenuItem[] items)
{
// Arrange
await _helper.OrderToGo(orderId, items);
var commandToTest = new ConfirmToGoOrder
{
OrderId = orderId,
PricePaid = items.Sum(i => i.Price)
};
// Act
var result = await _fixture.SendAsync(commandToTest);
// Assert
await _helper.AssertOrderExists(
orderId,
order => order.Status == ToGoOrderStatus.Issued);
}
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 InTheContextOfAManager(Func <Manager, Func <HttpClient, Task> > serverCall, Fixture fixture)
{
var hireManager = fixture.Create <HireManager>();
await _appFixture.SendAsync(hireManager);
var manager = await _appFixture.ExecuteDbContextAsync(dbContext =>
dbContext
.Managers
.FirstAsync(m => m.Id == hireManager.Id));
var token = await SetupUserWithClaims(
fixture,
new List <Claim> {
new Claim(AuthConstants.ClaimTypes.ManagerId, manager.Id.ToString())
});
await _appFixture.ExecuteHttpClientAsync(serverCall(manager), token);
}
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 CanCloseTabWithoutTip(Guid tabId, int tableNumber)
{
// Arrange
await _helper.OpenTabOnTable(tabId, tableNumber);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = 0 // This should be OK as we haven't ordered anything
};
// Act
var result = await _fixture.SendAsync(closeTabCommand);
// Assert
await _helper.AssertTabExists(
closeTabCommand.TabId,
t => t.IsOpen == false &&
t.TipValue == 0);
}
