public void Modify_WithValidData_ShouldModifyItem()
{
// Arrange
Fixture fixture = commonFixture.GetNewFixture();
var isTemporary = commonFixture.NextBool();
var definition = StoreItemDefinition.FromTemporary(isTemporary);
IStoreItem storeItem = storeItemFixture.CreateValid(definition);
ItemModify itemModify = fixture.Create <ItemModify>();
IEnumerable <IStoreItemAvailability> availabilities = storeItemAvailabilityFixture.CreateManyValid().ToList();
// Act
storeItem.Modify(itemModify, availabilities);
// Assert
using (new AssertionScope())
{
storeItem.Name.Should().Be(itemModify.Name);
storeItem.Comment.Should().Be(itemModify.Comment);
storeItem.QuantityType.Should().Be(itemModify.QuantityType);
storeItem.QuantityInPacket.Should().Be(itemModify.QuantityInPacket);
storeItem.QuantityTypeInPacket.Should().Be(itemModify.QuantityTypeInPacket);
storeItem.Availabilities.Should().BeEquivalentTo(availabilities);
storeItem.ItemCategoryId.Should().Be(itemModify.ItemCategoryId);
storeItem.ManufacturerId.Should().Be(itemModify.ManufacturerId);
storeItem.IsTemporary.Should().Be(isTemporary);
}
}
public void MakePermanent_WithValidData_ShouldMakeItemPermanent()
{
// Arrange
Fixture fixture = commonFixture.GetNewFixture();
var definition = StoreItemDefinition.FromTemporary(true);
IStoreItem storeItem = storeItemFixture.CreateValid(definition);
PermanentItem permanentItem = fixture.Create <PermanentItem>();
List <IStoreItemAvailability> availabilities = storeItemAvailabilityFixture.CreateManyValid().ToList();
// Act
storeItem.MakePermanent(permanentItem, availabilities);
// Assert
using (new AssertionScope())
{
storeItem.Name.Should().Be(permanentItem.Name);
storeItem.Comment.Should().Be(permanentItem.Comment);
storeItem.QuantityType.Should().Be(permanentItem.QuantityType);
storeItem.QuantityInPacket.Should().Be(permanentItem.QuantityInPacket);
storeItem.QuantityTypeInPacket.Should().Be(permanentItem.QuantityTypeInPacket);
storeItem.Availabilities.Should().BeEquivalentTo(availabilities);
storeItem.ItemCategoryId.Should().Be(permanentItem.ItemCategoryId);
storeItem.ManufacturerId.Should().Be(permanentItem.ManufacturerId);
storeItem.IsTemporary.Should().BeFalse();
}
}
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);
}
}
private object[] NoItemCategory()
{
IStore store = storeFixture.CreateValid();
var list = GetShoppingListContainingOneItem(store.Id, store.Sections.First().Id);
IManufacturer manufacturer = manufaturerFixture.Create();
var avavilabilityDef = new StoreItemAvailabilityDefinition
{
StoreId = store.Id,
DefaultSectionId = store.Sections.First().Id
};
var availability = storeItemAvailabilityFixture.Create(avavilabilityDef);
var itemDef = new StoreItemDefinition
{
Id = list.Sections.First().Items.First().Id,
ItemCategoryId = null,
ManufacturerId = manufacturer.Id,
Availabilities = availability.ToMonoList()
};
IStoreItem item = storeItemFixture.Create(itemDef);
var listReadModel = ToSimpleReadModel(list, store, item, null, manufacturer);
return(new object[]
{
list,
store,
item.ToMonoList(),
Enumerable.Empty <IItemCategory>(),
manufacturer.ToMonoList(),
listReadModel
});
}
private IStoreItem CreateItem(ItemCategoryId itemCategoryId, ManufacturerId manufacturerId)
{
var def = new StoreItemDefinition
{
ItemCategoryId = itemCategoryId,
ManufacturerId = manufacturerId,
Availabilities = StoreItemAvailabilityFixture.CreateManyValid(1)
};
return(StoreItemFixture.CreateValid(def));
}
public IStoreItem CreateNewItemForStore(StoreId storeId)
{
var availabilityDef = StoreItemAvailabilityDefinition.FromStoreId(storeId);
var availability = StoreItemAvailabilityFixture.Create(availabilityDef);
var storeItemDef = new StoreItemDefinition
{
Availabilities = availability.ToMonoList()
};
return(StoreItemFixture.Create(storeItemDef));
}
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 IEnumerable <IStoreItem> CreateItems(IStore store)
{
List <StoreItemDefinition> definitions = new List <StoreItemDefinition>();
for (int i = 0; i < 2; i++)
{
var availabilityDef = new StoreItemAvailabilityDefinition
{
StoreId = store.Id,
DefaultSectionId = CommonFixture.ChooseRandom(store.Sections).Id
};
var availability = StoreItemAvailabilityFixture.Create(availabilityDef);
var def = new StoreItemDefinition
{
Availabilities = availability.ToMonoList()
};
definitions.Add(def);
}
return(StoreItemFixture.CreateMany(definitions));
}
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);
}
}
