Beispiel #1
0
        public void GivenFinishedGoodWithSerializedInventory_WhenDeriving_ThenQuantityOnHandUpdated()
        {
            // Arrange
            var available = new SerialisedInventoryItemStates(this.Session).Available;
            var warehouse = new Facilities(this.Session).FindBy(M.Facility.FacilityType, new FacilityTypes(this.Session).Warehouse);

            var kinds          = new InventoryItemKinds(this.Session);
            var unitsOfMeasure = new UnitsOfMeasure(this.Session);
            var unknown        = new InventoryTransactionReasons(this.Session).Unknown;

            var vatRate21   = new VatRateBuilder(this.Session).WithRate(21).Build();
            var category    = new ProductCategoryBuilder(this.Session).WithName("category").Build();
            var serialPart  = CreatePart("FG1", kinds.Serialised);
            var serialItem1 = new SerialisedItemBuilder(this.Session).WithSerialNumber("1").Build();
            var serialItem2 = new SerialisedItemBuilder(this.Session).WithSerialNumber("2").Build();
            var serialItem3 = new SerialisedItemBuilder(this.Session).WithSerialNumber("3").Build();

            serialPart.AddSerialisedItem(serialItem1);
            serialPart.AddSerialisedItem(serialItem2);
            serialPart.AddSerialisedItem(serialItem3);

            var good = CreateGood("10101", vatRate21, "good1", unitsOfMeasure.Piece, category, serialPart);

            // Act
            this.Session.Derive(true);

            CreateInventoryTransaction(1, unknown, serialPart, serialItem1);
            CreateInventoryTransaction(1, unknown, serialPart, serialItem2);
            CreateInventoryTransaction(1, unknown, serialPart, serialItem3);

            this.Session.Derive(true);

            // Assert
            Assert.Equal(3, serialPart.QuantityOnHand);
        }
        public void GivenSerializedInventoryItems_WhenVarianceContainsInvalidQuantity_ThenDerivationExceptionRaised()
        {
            // Arrange
            var kinds          = new InventoryItemKinds(this.Session);
            var unitsOfMeasure = new UnitsOfMeasure(this.Session);
            var unknown        = new InventoryTransactionReasons(this.Session).Unknown;

            var vatRegime    = new VatRegimes(this.Session).BelgiumStandard;
            var category     = new ProductCategoryBuilder(this.Session).WithName("category").Build();
            var finishedGood = this.CreatePart("FG1", kinds.Serialised);
            var good         = this.CreateGood("10101", vatRegime, "good1", unitsOfMeasure.Piece, category, finishedGood);
            var serialItem   = new SerialisedItemBuilder(this.Session).WithSerialNumber("1").Build();
            var variance     = this.CreateInventoryTransaction(10, unknown, finishedGood, serialItem);

            // Act
            var derivation = this.Session.Derive(false);

            // Assert
            Assert.True(derivation.HasErrors);
            Assert.Contains(M.InventoryItemTransaction.Quantity, derivation.Errors.SelectMany(e => e.RoleTypes));

            // Re-Arrange
            variance.Quantity = -10;

            // Act
            derivation = this.Session.Derive(false);

            // Assert
            Assert.True(derivation.HasErrors);
            Assert.Contains(M.InventoryItemTransaction.Quantity, derivation.Errors.SelectMany(e => e.RoleTypes));
        }
        public void GivenInventoryItem_WhenPositiveVariance_ThenQuantityOnHandIsRaised()
        {
            var nonSerialized = new InventoryItemKinds(this.Session).NonSerialised;
            var unknown       = new InventoryTransactionReasons(this.Session).Unknown;
            var vatRate21     = new VatRateBuilder(this.Session).WithRate(21).Build();
            var piece         = new UnitsOfMeasure(this.Session).Piece;
            var category      = this.Session.Extent <ProductCategory>().First;

            var finishedGood = this.CreatePart("FG1", nonSerialized);

            this.Session.Derive(true);
            this.Session.Commit();

            var inventoryItem = (NonSerialisedInventoryItem)finishedGood.InventoryItemsWherePart.First();

            Assert.Equal(0, finishedGood.QuantityOnHand);
            Assert.Equal(0, inventoryItem.QuantityOnHand);

            var transaction = this.CreateInventoryTransaction(10, unknown, finishedGood);

            this.Session.Derive(true);

            Assert.Equal(10, finishedGood.QuantityOnHand);
            Assert.Equal(10, inventoryItem.QuantityOnHand);
        }
        public void GivenInventoryItem_WhenQuantityOnHandIsDecreased_ThenSalesOrderItemsWithQuantityRequestsShippingAreUpdated()
        {
            // Arrange
            var inventoryItemKinds = new InventoryItemKinds(this.Session);
            var unitsOfMeasure     = new UnitsOfMeasure(this.Session);
            var varianceReasons    = new InventoryTransactionReasons(this.Session);
            var contactMechanisms  = new ContactMechanismPurposes(this.Session);

            var vatRate21    = new VatRateBuilder(this.Session).WithRate(21).Build();
            var category     = new ProductCategoryBuilder(this.Session).WithName("category").Build();
            var finishedGood = CreatePart("1", inventoryItemKinds.NonSerialised);
            var good         = CreateGood("10101", vatRate21, "good1", unitsOfMeasure.Piece, category, finishedGood);

            CreateInventoryTransaction(5, varianceReasons.Unknown, finishedGood);

            this.Session.Derive(true);

            var mechelen             = new CityBuilder(this.Session).WithName("Mechelen").Build();
            var mechelenAddress      = new PostalAddressBuilder(this.Session).WithGeographicBoundary(mechelen).WithAddress1("Haverwerf 15").Build();
            var shipToMechelen       = CreateShipTo(mechelenAddress, contactMechanisms.ShippingAddress, true);
            var customer             = new PersonBuilder(this.Session).WithLastName("customer").WithPartyContactMechanism(shipToMechelen).Build();
            var internalOrganisation = this.InternalOrganisation;

            new CustomerRelationshipBuilder(this.Session).WithFromDate(DateTime.UtcNow).WithCustomer(customer).Build();

            this.Session.Derive(true);

            var order     = CreateSalesOrder(customer, customer, DateTime.UtcNow, false);
            var salesItem = CreateSalesOrderItem("item1", good, 10, 15);

            // Act
            order.AddSalesOrderItem(salesItem);
            this.Session.Derive(true);

            order.Confirm();
            this.Session.Derive(true);

            // Assert
            Assert.Equal(5, salesItem.QuantityRequestsShipping);
            Assert.Equal(0, salesItem.QuantityPendingShipment);
            Assert.Equal(10, salesItem.QuantityReserved);
            Assert.Equal(5, salesItem.QuantityShortFalled);

            // Rearrange
            CreateInventoryTransaction(-2, varianceReasons.Unknown, finishedGood);

            // Act
            this.Session.Derive();

            // Assert
            Assert.Equal(3, salesItem.QuantityRequestsShipping);
            Assert.Equal(0, salesItem.QuantityPendingShipment);
            Assert.Equal(10, salesItem.QuantityReserved);
            Assert.Equal(7, salesItem.QuantityShortFalled);
        }
Beispiel #5
0
        public void GivenInventoryItem_WhenBuild_ThenPostBuildRelationsMustExist()
        {
            // Arrange
            var available = new SerialisedInventoryItemStates(this.Session).Available;
            var warehouse = new Facilities(this.Session).FindBy(M.Facility.FacilityType, new FacilityTypes(this.Session).Warehouse);
            var kinds     = new InventoryItemKinds(this.Session);

            var serialItem   = new SerialisedItemBuilder(this.Session).WithSerialNumber("1").Build();
            var finishedGood = CreatePart("1", kinds.Serialised);

            finishedGood.AddSerialisedItem(serialItem);
            var serialInventoryItem = new SerialisedInventoryItemBuilder(this.Session).WithSerialisedItem(serialItem).WithPart(finishedGood).Build();

            // Act
            this.Session.Derive(true);

            // Assert
            Assert.Equal(available, serialInventoryItem.SerialisedInventoryItemState);
            Assert.Equal(warehouse, serialInventoryItem.Facility);
        }
Beispiel #6
0
        public void GivenSerializedItemInMultipleFacilities_WhenDeriving_ThenMultipleQuantityOnHandTracked()
        {
            // Arrange
            var warehouseType = new FacilityTypes(this.Session).Warehouse;
            var warehouse1    = CreateFacility("WH1", warehouseType, this.InternalOrganisation);
            var warehouse2    = CreateFacility("WH2", warehouseType, this.InternalOrganisation);

            var serialized = new InventoryItemKinds(this.Session).Serialised;
            var piece      = new UnitsOfMeasure(this.Session).Piece;
            var unknown    = new InventoryTransactionReasons(this.Session).Unknown;

            var vatRate21    = new VatRateBuilder(this.Session).WithRate(21).Build();
            var category     = new ProductCategoryBuilder(this.Session).WithName("category").Build();
            var finishedGood = CreatePart("FG1", serialized);
            var serialItem1  = new SerialisedItemBuilder(this.Session).WithSerialNumber("1").Build();
            var serialItem2  = new SerialisedItemBuilder(this.Session).WithSerialNumber("2").Build();

            finishedGood.AddSerialisedItem(serialItem1);
            finishedGood.AddSerialisedItem(serialItem2);

            var good = CreateGood("10101", vatRate21, "good1", piece, category, finishedGood);

            // Act
            this.Session.Derive(true);

            CreateInventoryTransaction(1, unknown, finishedGood, serialItem1, warehouse1);
            CreateInventoryTransaction(1, unknown, finishedGood, serialItem2, warehouse2);

            this.Session.Derive(true);

            // Assert
            var item1 = (SerialisedInventoryItem) new InventoryItems(this.Session).Extent().First(i => i.Facility.Equals(warehouse1));

            Assert.Equal(1, item1.QuantityOnHand);

            var item2 = (SerialisedInventoryItem) new InventoryItems(this.Session).Extent().First(i => i.Facility.Equals(warehouse2));

            Assert.Equal(1, item2.QuantityOnHand);

            Assert.Equal(2, finishedGood.QuantityOnHand);
        }
Beispiel #7
0
        public void GivenInventoryItem_WhenQuantityOnHandIsRaised_ThenSalesOrderItemsWithQuantityShortFalledAreUpdated()
        {
            // Arrange
            var inventoryItemKinds = new InventoryItemKinds(this.Session);
            var unitsOfMeasure     = new UnitsOfMeasure(this.Session);
            var varianceReasons    = new InventoryTransactionReasons(this.Session);
            var contactMechanisms  = new ContactMechanismPurposes(this.Session);

            var store = this.Session.Extent <Store>().First;

            store.IsImmediatelyPicked = false;

            var vatRate21    = new VatRateBuilder(this.Session).WithRate(21).Build();
            var category     = new ProductCategoryBuilder(this.Session).WithName("category").Build();
            var finishedGood = this.CreatePart("1", inventoryItemKinds.NonSerialised);
            var good         = this.CreateGood("10101", vatRate21, "good1", unitsOfMeasure.Piece, category, finishedGood);

            this.Session.Derive();

            this.CreateInventoryTransaction(5, varianceReasons.Unknown, finishedGood);

            this.Session.Derive();

            var mechelen        = new CityBuilder(this.Session).WithName("Mechelen").Build();
            var mechelenAddress = new PostalAddressBuilder(this.Session).WithPostalAddressBoundary(mechelen).WithAddress1("Haverwerf 15").Build();
            var shipToMechelen  = this.CreateShipTo(mechelenAddress, contactMechanisms.ShippingAddress, true);
            var customer        = new PersonBuilder(this.Session).WithLastName("customer").WithPartyContactMechanism(shipToMechelen).Build();

            new CustomerRelationshipBuilder(this.Session).WithFromDate(this.Session.Now()).WithCustomer(customer).Build();

            this.Session.Derive();
            this.Session.Commit();

            var order1     = this.CreateSalesOrder(customer, customer, this.Session.Now());
            var salesItem1 = this.CreateSalesOrderItem("item1", good, 10, 15);
            var salesItem2 = this.CreateSalesOrderItem("item2", good, 20, 15);

            order1.AddSalesOrderItem(salesItem1);
            order1.AddSalesOrderItem(salesItem2);

            var order2     = this.CreateSalesOrder(customer, customer, this.Session.Now().AddDays(1));
            var salesItem3 = this.CreateSalesOrderItem("item3", good, 10, 15);
            var salesItem4 = this.CreateSalesOrderItem("item4", good, 20, 15);

            order2.AddSalesOrderItem(salesItem3);
            order2.AddSalesOrderItem(salesItem4);

            this.Session.Derive();
            this.Session.Commit();

            // Act
            order1.SetReadyForPosting();
            this.Session.Derive(true);

            order1.Post();
            this.Session.Derive();

            order1.Accept();
            this.Session.Derive();

            Assert.Equal(0, salesItem1.ReservedFromNonSerialisedInventoryItem.AvailableToPromise);
            Assert.Equal(5, salesItem1.ReservedFromNonSerialisedInventoryItem.QuantityOnHand);

            order2.SetReadyForPosting();

            this.Session.Derive(true);

            order2.Post();
            this.Session.Derive();

            order2.Accept();
            this.Session.Derive();

            // Assert
            Assert.Equal(0, salesItem1.QuantityRequestsShipping);
            Assert.Equal(5, salesItem1.QuantityPendingShipment);
            Assert.Equal(10, salesItem1.QuantityReserved);
            Assert.Equal(5, salesItem1.QuantityShortFalled);

            Assert.Equal(0, salesItem2.QuantityRequestsShipping);
            Assert.Equal(0, salesItem2.QuantityPendingShipment);
            Assert.Equal(20, salesItem2.QuantityReserved);
            Assert.Equal(20, salesItem2.QuantityShortFalled);

            Assert.Equal(0, salesItem3.QuantityRequestsShipping);
            Assert.Equal(0, salesItem3.QuantityPendingShipment);
            Assert.Equal(10, salesItem3.QuantityReserved);
            Assert.Equal(10, salesItem3.QuantityShortFalled);

            Assert.Equal(0, salesItem4.QuantityRequestsShipping);
            Assert.Equal(0, salesItem4.QuantityPendingShipment);
            Assert.Equal(20, salesItem4.QuantityReserved);
            Assert.Equal(20, salesItem4.QuantityShortFalled);

            Assert.Equal(0, salesItem1.ReservedFromNonSerialisedInventoryItem.AvailableToPromise);
            Assert.Equal(5, salesItem1.ReservedFromNonSerialisedInventoryItem.QuantityOnHand);

            // Re-arrange
            this.CreateInventoryTransaction(15, varianceReasons.Unknown, finishedGood);

            // Act
            this.Session.Derive(true);
            this.Session.Commit();

            // Assert
            // Orderitems are sorted as follows: item1, item2, item3, item4
            Assert.Equal(0, salesItem1.QuantityRequestsShipping);
            Assert.Equal(10, salesItem1.QuantityPendingShipment);
            Assert.Equal(10, salesItem1.QuantityReserved);
            Assert.Equal(0, salesItem1.QuantityShortFalled);

            Assert.Equal(0, salesItem2.QuantityRequestsShipping);
            Assert.Equal(10, salesItem2.QuantityPendingShipment);
            Assert.Equal(20, salesItem2.QuantityReserved);
            Assert.Equal(10, salesItem2.QuantityShortFalled);

            Assert.Equal(0, salesItem3.QuantityRequestsShipping);
            Assert.Equal(0, salesItem3.QuantityPendingShipment);
            Assert.Equal(10, salesItem3.QuantityReserved);
            Assert.Equal(10, salesItem3.QuantityShortFalled);

            Assert.Equal(0, salesItem4.QuantityRequestsShipping);
            Assert.Equal(0, salesItem4.QuantityPendingShipment);
            Assert.Equal(20, salesItem4.QuantityReserved);
            Assert.Equal(20, salesItem4.QuantityShortFalled);

            Assert.Equal(0, salesItem1.ReservedFromNonSerialisedInventoryItem.AvailableToPromise);
            Assert.Equal(20, salesItem1.ReservedFromNonSerialisedInventoryItem.QuantityOnHand);

            // Re-arrange
            this.CreateInventoryTransaction(85, varianceReasons.Unknown, finishedGood);

            // Act
            this.Session.Derive();
            this.Session.Commit();

            // Assert
            // Orderitems are sorted as follows: item2, item1, item4, item 3
            Assert.Equal(0, salesItem1.QuantityRequestsShipping);
            Assert.Equal(10, salesItem1.QuantityPendingShipment);
            Assert.Equal(10, salesItem1.QuantityReserved);
            Assert.Equal(0, salesItem1.QuantityShortFalled);

            Assert.Equal(0, salesItem2.QuantityRequestsShipping);
            Assert.Equal(20, salesItem2.QuantityPendingShipment);
            Assert.Equal(20, salesItem2.QuantityReserved);
            Assert.Equal(0, salesItem2.QuantityShortFalled);

            Assert.Equal(0, salesItem3.QuantityRequestsShipping);
            Assert.Equal(10, salesItem3.QuantityPendingShipment);
            Assert.Equal(10, salesItem3.QuantityReserved);
            Assert.Equal(0, salesItem3.QuantityShortFalled);

            Assert.Equal(0, salesItem4.QuantityRequestsShipping);
            Assert.Equal(20, salesItem4.QuantityPendingShipment);
            Assert.Equal(20, salesItem4.QuantityReserved);
            Assert.Equal(0, salesItem4.QuantityShortFalled);

            Assert.Equal(45, salesItem1.ReservedFromNonSerialisedInventoryItem.AvailableToPromise);
            Assert.Equal(105, salesItem1.ReservedFromNonSerialisedInventoryItem.QuantityOnHand);
        }