public async Task HandleAsync_WithValidOfflineId_ShouldPutItemInBasket()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommandWithOfflineId();
IStoreItem storeItem = local.StoreItemFixture.CreateValid();
var temporaryItemId = new TemporaryItemId(command.OfflineTolerantItemId.OfflineId.Value);
ShoppingListMock listMock = local.ShoppingListMockFixture.Create();
local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object);
local.ItemRepositoryMock.SetupFindByAsync(temporaryItemId, storeItem);
// Act
bool result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
local.ItemRepositoryMock.VerifyFindByAsync(temporaryItemId);
listMock.VerifyPutItemInBasketOnce(storeItem.Id);
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object);
}
}
public async Task ExchangeItemAsync_WithNewItemAvailableForShoppingListAndNotInBasket_ShouldRemoveOldItemAndAddNewItem()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
ShoppingListMock shoppingListMock = local.CreateShoppingListMockNotInBasket();
var shopppingListStoreId = shoppingListMock.Object.StoreId;
IShoppingListItem oldShoppingListItem = shoppingListMock.GetRandomItem(local.CommonFixture, i => !i.IsInBasket);
ItemId oldItemId = oldShoppingListItem.Id;
IStoreItem newItem = local.CreateNewItemForStore(shopppingListStoreId);
local.ShoppingListRepositoryMock.SetupFindActiveByAsync(oldItemId, shoppingListMock.Object.ToMonoList());
// Act
await service.ExchangeItemAsync(oldItemId, newItem, default);
// Assert
var sectionId = newItem.Availabilities.First(av => av.StoreId == shopppingListStoreId).DefaultSectionId;
using (new AssertionScope())
{
shoppingListMock.VerifyRemoveItemOnce(oldItemId);
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object);
local.AddItemToShoppingListServiceMock.VerifyAddItemToShoppingListOnce(shoppingListMock.Object,
newItem.Id, sectionId, oldShoppingListItem.Quantity);
shoppingListMock.VerifyPutItemInBasketNever();
}
}
public async Task HandleAsync_WithActualId_ShouldAddItemToList()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommandWithActualId();
ShoppingListMock listMock = local.ShoppingListMockFixture.Create();
local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object);
// Act
bool result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object);
local.AddItemToShoppingListServiceMock.VerifyAddItemToShoppingListOnce(
listMock.Object,
new ItemId(command.ItemId.ActualId.Value),
command.SectionId,
command.Quantity);
}
}
public async Task HandleAsync_WithValidActualId_ShouldRemoveItemFromBasket(bool isActualItemId, bool isTemporaryItem)
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = isActualItemId ? local.CreateCommandWithActualId() : local.CreateCommandWithOfflineId();
ShoppingListMock listMock = local.ShoppingListMockFixture.Create();
var storeItem = local.StoreItemFixture.Create(StoreItemDefinition.FromTemporary(isTemporaryItem));
StoreItemMock itemMock = new StoreItemMock(storeItem);
local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object);
if (isActualItemId)
{
local.ItemRepositoryMock.SetupFindByAsync(new ItemId(command.OfflineTolerantItemId.ActualId.Value), itemMock.Object);
}
else
{
local.ItemRepositoryMock.SetupFindByAsync(new TemporaryItemId(command.OfflineTolerantItemId.OfflineId.Value), itemMock.Object);
}
TransactionMock transactionMock = new TransactionMock();
local.TransactionGeneratorMock.SetupGenerateAsync(transactionMock.Object);
// Act
bool result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
listMock.VerifyRemoveItemOnce(itemMock.Object.Id);
local.TransactionGeneratorMock.VerifyGenerateAsyncOnce();
if (isTemporaryItem)
{
itemMock.VerifyDeleteOnce();
local.ItemRepositoryMock.VerifyStoreAsyncOnce(itemMock.Object);
}
else
{
itemMock.VerifyDeleteNever();
local.ItemRepositoryMock.VerifyStoreAsyncNever();
}
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object);
transactionMock.VerifyCommitAsyncOnce();
}
}
public async Task HandleAsync_WithActualId_ShouldRemoveItemFromBasket()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommandWithActualId();
ShoppingListMock shoppingListMock = local.ShoppingListMockFixture.Create();
local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, shoppingListMock.Object);
// Act
bool result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
shoppingListMock.VerifyRemoveItemFromBasketOnce(new ItemId(command.OfflineTolerantItemId.ActualId.Value));
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object);
}
}
public async Task HandleAsync_WithInvalidActualItemId_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommandWithActualId();
ShoppingListMock listMock = local.ShoppingListMockFixture.Create();
local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object);
local.ItemRepositoryMock.SetupFindByAsync(new ItemId(command.OfflineTolerantItemId.ActualId.Value), null);
// Act
Func <Task> function = async() => await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
(await function.Should().ThrowAsync <DomainException>())
.Where(e => e.Reason.ErrorCode == ErrorReasonCode.ItemNotFound);
}
}
public async Task ExchangeItemAsync_WithNewItemNotAvailableForShoppingList_ShouldRemoveOldItemAndNotAddNewItem()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
ShoppingListMock shoppingListMock = local.CreateShoppingListMockInBasket();
ItemId oldItemId = local.CommonFixture.ChooseRandom(shoppingListMock.Object.Items).Id;
IStoreItem newItem = local.CreateNewItemNotInStore(shoppingListMock.Object.StoreId);
local.ShoppingListRepositoryMock.SetupFindActiveByAsync(oldItemId, shoppingListMock.Object.ToMonoList());
// Act
await service.ExchangeItemAsync(oldItemId, newItem, default);
// Assert
using (new AssertionScope())
{
shoppingListMock.VerifyRemoveItemOnce(oldItemId);
shoppingListMock.VerifyAddItemNever();
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object);
}
}
public async Task HandleAsync_WithValidData_ShouldFinishShoppingList()
{
// Arrange
var fixture = commonFixture.GetNewFixture();
TransactionGeneratorMock transactionGeneratorMock = new TransactionGeneratorMock(fixture);
ShoppingListRepositoryMock shoppingListRepositoryMock = new ShoppingListRepositoryMock(fixture);
Mock <ITransaction> transactionMock = new Mock <ITransaction>();
ShoppingListMock listMock = shoppingListMockFixture.Create();
ShoppingListMock remainingListMock = shoppingListMockFixture.Create();
var command = fixture.Create <FinishShoppingListCommand>();
var handler = fixture.Create <FinishShoppingListCommandHandler>();
listMock.SetupFinish(command.CompletionDate, remainingListMock.Object);
shoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object);
transactionGeneratorMock.SetupGenerateAsync(transactionMock.Object);
// Act
bool result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
listMock.VerifyFinishOnce(command.CompletionDate);
transactionGeneratorMock.VerifyGenerateAsyncOnce();
shoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object);
shoppingListRepositoryMock.VerifyStoreAsyncOnce(remainingListMock.Object);
transactionMock.Verify(
i => i.CommitAsync(
It.IsAny <CancellationToken>()),
Times.Once);
}
}
