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);
            }
        }
示例#2
0
        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);
            }
        }
示例#3
0
        public async Task HandleAsync_WithValidDataAndManufacturerId_ShouldCreateItem()
        {
            // Arrange
            var local = new LocalFixture();

            IStoreItem storeItem = local.StoreItemFixture.CreateValid();
            List <IStoreItemAvailability> availabilities = storeItem.Availabilities.ToList();

            var handler = local.CreateCommandHandler();
            var command = local.CreateCommand(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.VerifyValidateAsyncOnce(command.ItemCreation.ManufacturerId);
                local.AvailabilityValidationServiceMock.VerifyValidateOnce(availabilities);
            }
        }
示例#4
0
        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();
            }
        }
示例#6
0
        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);
            }
        }