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 ConvertAsync_WithItemCategoryAndManufacturer_ShouldConvertToReadModel()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var item = local.CreateItem();
var availability = item.Availabilities.First();
var itemCategory = local.CreateItemCategory(item.ItemCategoryId);
var manufacturer = local.CreateManufacturer(item.ManufacturerId);
var store = local.CreateStore(availability.StoreId, availability.DefaultSectionId);
local.ItemCategoryRepositoryMock.SetupFindByAsync(item.ItemCategoryId, itemCategory);
local.ManufacturerRepositoryMock.SetupFindByAsync(item.ManufacturerId, manufacturer);
local.StoreRepositoryMock.SetupFindByAsync(availability.StoreId.ToMonoList(), store.ToMonoList());
// Act
var result = await service.ConvertAsync(item, default);
// Assert
var expected = local.ToSimpleReadModel(item, itemCategory, manufacturer, store);
using (new AssertionScope())
{
result.Should().BeEquivalentTo(expected);
}
}
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 ConvertAsync_WithItemCategoryAndNoManufacturer_ShouldConvertToReadModel()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var store = local.CreateStore();
var items = local.CreateItemsWithoutManufacturer(store).ToList();
var itemCategoryIds = items
.Where(i => i.ItemCategoryId != null)
.Select(i => i.ItemCategoryId);
var manufacturerIds = items
.Where(i => i.ManufacturerId != null)
.Select(i => i.ManufacturerId);
var itemCategoryDict = local.CreateItemCategories(itemCategoryIds);
var manufacturerDict = local.CreateManufacturers(manufacturerIds);
local.ItemCategoryRepositoryMock.SetupFindByAsync(itemCategoryIds, itemCategoryDict.Values);
local.ManufacturerRepositoryMock.SetupFindByAsync(manufacturerIds, manufacturerDict.Values);
// Act
var result = await service.ConvertAsync(items, store, default);
// Assert
var expected = local.ToSimpleReadModels(items, store, itemCategoryDict, manufacturerDict);
using (new AssertionScope())
{
result.Should().BeEquivalentTo(expected);
}
}
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 ConvertAsync_WithInvalidManufacturer_ShouldConvertToReadModel()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var item = local.CreateItem();
var availability = item.Availabilities.First();
var itemCategory = local.CreateItemCategory(item.ItemCategoryId);
var store = local.CreateStore(availability.StoreId, availability.DefaultSectionId);
local.ItemCategoryRepositoryMock.SetupFindByAsync(item.ItemCategoryId, itemCategory);
local.ManufacturerRepositoryMock.SetupFindByAsync(item.ManufacturerId, null);
local.StoreRepositoryMock.SetupFindByAsync(availability.StoreId.ToMonoList(), store.ToMonoList());
// Act
Func <Task <StoreItemReadModel> > function = async() => await service.ConvertAsync(item, default);
// Assert
using (new AssertionScope())
{
(await function.Should().ThrowAsync <DomainException>())
.Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ManufacturerNotFound);
}
}
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_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);
}
}
private static void AddFixture(string fixtureFullName, string fixtureName)
{
LocalFixture lf = new LocalFixture(LocalCollection.CurrentLocalAssembly, fixtureName, fixtureFullName);
if (!LocalCollection.CurrentLocalAssembly.LocalFixtures.Contains(lf))
{
LocalCollection.CurrentLocalAssembly.LocalFixtures.Add(lf);
}
LocalCollection.CurrentLocalAssembly.CurrentLocalFixture = (from x in LocalCollection.CurrentLocalAssembly.LocalFixtures
where x.Equals(lf)
select x).First();
}
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 AddItemToShoppingList_WithItemIdIsNull_ShouldThrowArgumentNullException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var shoppingList = local.ShoppingListFixture.AsModelFixture().CreateValid();
var sectionId = new SectionId(local.CommonFixture.NextInt());
var quantity = local.CommonFixture.NextFloat();
// Act
Func <Task> function = async() => await service.AddItemToShoppingList(shoppingList, (ItemId)null,
sectionId, quantity, default);
public async Task ValidateAsync_WithAvailabilitiesIsNull_ShouldThrowArgumentNullException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
// Act
Func <Task> function = async() => await service.ValidateAsync(null, default);
// Assert
using (new AssertionScope())
{
await function.Should().ThrowAsync <ArgumentNullException>();
}
}
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 ConvertAsync_WithItemIsNull_ShouldThrowArgumentNullException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
// Act
Func <Task <StoreItemReadModel> > function = async() => await service.ConvertAsync(null, default);
// Assert
using (new AssertionScope())
{
await function.Should().ThrowAsync <ArgumentNullException>();
}
}
public async Task ExchangeItemAsync_WithOldItemIdIsNull_ShouldThrowArgumentNullException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var oldItemId = local.CreateOldItemId();
// Act
Func <Task> function = async() => await service.ExchangeItemAsync(oldItemId, null, default);
// Assert
using (new AssertionScope())
{
await function.Should().ThrowAsync <ArgumentNullException>();
}
}
public async Task ValidateAsync_WithDuplicatedStoreIds_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var availabilities = local.CreateAvailabilitiesWithDuplicatedStoreIds();
// Act
Func <Task> function = async() => await service.ValidateAsync(availabilities, default);
// Assert
using (new AssertionScope())
{
(await function.Should().ThrowAsync <DomainException>())
.Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.MultipleAvailabilitiesForStore);
}
}
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 Change_Customer_Maximum_Length_Name_Should_Be_Ok()
{
// Setup
LocalFixture.Seed(this.GetContext);
// Arrange
using var context = this.GetContext();
var handler = new ChangeCustomerNameCommandHandler(context);
var command = new ChangeCustomerNameCommand(
new Guid("8e61088d-776d-4c0f-a458-50dccf4e6580"),
"Mauricio A"
);
// Act
var actual = await handler.Handle(command, CancellationToken.None);
// Assert
Assert.True(actual.IsSuccess);
}
public async Task ValidateAsync_WithValidItemCategoryId_ShouldNotThrow()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var itemCategory = local.CreateItemCategory();
local.ItemCategoryRepositoryMock.SetupFindByAsync(itemCategory.Id, itemCategory);
// Act
Func <Task> function = async() => await service.ValidateAsync(itemCategory.Id, default);
// Assert
using (new AssertionScope())
{
await function.Should().NotThrowAsync();
}
}
public async Task ValidateAsync_WithValidManufacturerId_ShouldNotThrow()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var manufacturer = local.CreateManufacturer();
local.ManufacturerRepositoryMock.SetupFindByAsync(manufacturer.Id, manufacturer);
// Act
Func <Task> function = async() => await service.ValidateAsync(manufacturer.Id, default);
// Assert
using (new AssertionScope())
{
await function.Should().NotThrowAsync();
}
}
public async Task AddItemToShoppingList_WithItemIdAndShoppingListIsNull_ShouldThrowArgumentNullException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var itemId = new ItemId(local.CommonFixture.NextInt());
var sectionId = new SectionId(local.CommonFixture.NextInt());
var quantity = local.CommonFixture.NextFloat();
// Act
Func <Task> function = async() => await service.AddItemToShoppingList(null, itemId, sectionId, quantity, 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_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 ValidateAsync_WithInvalidItemCategoryId_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var itemCategoryId = new ItemCategoryId(local.CommonFixture.NextInt());
local.ItemCategoryRepositoryMock.SetupFindByAsync(itemCategoryId, null);
// Act
Func <Task> function = async() => await service.ValidateAsync(itemCategoryId, default);
// Assert
using (new AssertionScope())
{
(await function.Should().ThrowAsync <DomainException>())
.Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ItemCategoryNotFound);
}
}
public async Task ExchangeItemAsync_WithOldItemOnNoShoppingLists_ShouldDoNothing()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
ItemId oldItemId = local.CreateOldItemId();
IStoreItem newItem = local.CreateNewItem();
local.ShoppingListRepositoryMock.SetupFindActiveByAsync(oldItemId, Enumerable.Empty <IShoppingList>());
// Act
await service.ExchangeItemAsync(oldItemId, newItem, default);
// Assert
using (new AssertionScope())
{
local.ShoppingListRepositoryMock.VerifyStoreAsyncNever();
}
}
public async Task ValidateAsync_WithInvalidStoreId_ShouldThrowDomainException()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var availabilities = local.CreateValidAvailabilities();
var storeIds = availabilities.Select(av => av.StoreId);
local.StoreRepositoryMock.SetupFindByAsync(storeIds, Enumerable.Empty <IStore>());
// Act
Func <Task> function = async() => await service.ValidateAsync(availabilities, default);
// Assert
using (new AssertionScope())
{
(await function.Should().ThrowAsync <DomainException>())
.Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.StoreNotFound);
}
}
public async Task ValidateAsync_WithValidData_ShouldNotThrow()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
var availabilities = local.CreateValidAvailabilities().ToList();
var storeIds = availabilities.Select(av => av.StoreId);
var stores = local.CreateValidStores(availabilities);
local.StoreRepositoryMock.SetupFindByAsync(storeIds, stores);
// Act
Func <Task> function = async() => await service.ValidateAsync(availabilities, default);
// Assert
using (new AssertionScope())
{
await function.Should().NotThrowAsync();
}
}
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);
}
}
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);
}
}
