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); } }