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 HandleAsync_WithValidData_ShouldStoreItem()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
IStoreItem storeItem = local.StoreItemFixture.CreateValid();
IStoreItemAvailability availability = local.CommonFixture.ChooseRandom(storeItem.Availabilities);
var command = local.CreateCommand(availability);
local.StoreItemFactoryMock.SetupCreate(command.TemporaryItemCreation, storeItem);
// Act
var result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
local.AvailabilityValidationServiceMock.VerifyValidateOnce(
command.TemporaryItemCreation.Availability.ToMonoList());
local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItem);
}
}
public async Task HandleAsync_WithValidDataAndManufacturerIdNull_ShouldCreateItem()
{
// Arrange
var local = new LocalFixture();
IStoreItem storeItem = local.StoreItemFixture.CreateValid();
List <IStoreItemAvailability> availabilities = storeItem.Availabilities.ToList();
var handler = local.CreateCommandHandler();
var command = local.CreateCommandWithoutManufacturerId(availabilities);
local.StoreItemFactoryMock.SetupCreate(command.ItemCreation, storeItem);
// Act
var result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItem);
local.ItemCategoryValidationServiceMock.VerifyValidateAsyncOnce(command.ItemCreation.ItemCategoryId);
local.ManufacturerValidationServiceMock.VerifyValidateAsyncNever();
local.AvailabilityValidationServiceMock.VerifyValidateOnce(availabilities);
}
}
public async Task HandleAsync_WithValidDataAndManufacturerId_ShouldMakeTemporaryItemPermanent()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
StoreItemMock storeItemMock = local.StoreItemMockFixture.Create(StoreItemDefinition.FromTemporary(true));
List <IStoreItemAvailability> availabilities = storeItemMock.Object.Availabilities.ToList();
var command = local.CreateCommand(availabilities);
local.ItemRepositoryMock.SetupFindByAsync(command.PermanentItem.Id, storeItemMock.Object);
// Act
var result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
local.ItemCategoryValidationServiceMock.VerifyValidateAsyncOnce(command.PermanentItem.ItemCategoryId);
local.ManufacturerValidationServiceMock.VerifyValidateAsyncOnce(command.PermanentItem.ManufacturerId);
local.AvailabilityValidationServiceMock.VerifyValidateOnce(availabilities);
storeItemMock.VerifyMakePermanentOnce(command.PermanentItem, availabilities);
local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItemMock.Object);
}
}
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_WithCommandIsNull_ShouldThrowArgumentNullException()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
// Act
Func <Task> function = async() => await handler.HandleAsync(null, default);
// Assert
using (new AssertionScope())
{
await function.Should().ThrowAsync <ArgumentNullException>();
}
}
public async Task HandleAsync_WithInvalidShoppingListId_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommandWithOfflineId();
local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, 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.ShoppingListNotFound);
}
}
public async Task HandleAsync_WithInvalidItemId_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommand();
local.ItemRepositoryMock.SetupFindByAsync(command.PermanentItem.Id, null);
// Act
Func <Task <bool> > action = async() => await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
(await action.Should().ThrowAsync <DomainException>())
.Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ItemNotFound);
}
}
public async Task HandleAsync_WithItemOnShoppingLists_ShouldDeleteItemAndRemoveItFromActiveShoppingLists(
List <ShoppingListMock> shoppingListMocks)
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommand();
TransactionMock transactionMock = new TransactionMock();
StoreItemMock storeItemMock = local.StoreItemMockFixture.Create();
local.ItemRepositoryMock.SetupFindByAsync(command.ItemId, storeItemMock.Object);
local.ShoppingListRepositoryMock.SetupFindActiveByAsync(storeItemMock.Object.Id,
shoppingListMocks.Select(m => m.Object));
local.TransactionGeneratorMock.SetupGenerateAsync(transactionMock.Object);
// Act
var result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
storeItemMock.VerifyDeleteOnce();
local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItemMock.Object);
if (!shoppingListMocks.Any())
{
local.ShoppingListRepositoryMock.VerifyStoreAsyncNever();
}
else
{
foreach (var shoppingListMock in shoppingListMocks)
{
shoppingListMock.VerifyRemoveItemOnce(storeItemMock.Object.Id);
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.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_WithNonTemporaryItem_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
var command = local.CreateCommand();
var baseDefinition = StoreItemDefinition.FromTemporary(false);
IStoreItem storeItem = local.StoreItemFixture.CreateValid(baseDefinition);
local.ItemRepositoryMock.SetupFindByAsync(command.PermanentItem.Id, storeItem);
// Act
Func <Task <bool> > action = async() => await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
(await action.Should().ThrowAsync <DomainException>())
.Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ItemNotTemporary);
}
}
