public void CheckPersonOrderIsSummedTest()
        {
            //Arrange
            Order order1 = new Order()
            {
                Person = "Person A",
                Plates = new BasePlate[] { greyPlate, greyPlate }
            };
            Order order2 = new Order()
            {
                Person = "Person A",
                Plates = new BasePlate[] { soupPlate, greenPlate, greenPlate }
            };
            Order order3 = new Order()
            {
                Person = "Person B",
                Plates = new BasePlate[] { greyPlate }
            };
            IEnumerable <Order> mockOrders = new List <Order> {
                order1, order2, order3
            };

            this.orderRepositoryMock.Setup(repo => repo.GetAllOrders()).Returns(mockOrders);
            this.priceRepositoryMock.Setup(price => price.GetPlatePrice(greyPlate)).Returns(4.95m);

            //Act
            OptimizedBill optimizedBill = this.orderService.PayAllOrders();

            //Assert
            Assert.Equal(2, optimizedBill.PersonalPrice.Count);
            Assert.Equal(5, optimizedBill.PersonalPrice["Person A"].Plates.ToList().Count);
        }
        public void optmizedBillIntegration_Example1_Test()
        {
            //Arrange
            Order order1 = new Order()
            {
                Person = "Person A",
                Plates = new BasePlate[] { greyPlate, greyPlate }
            };
            Order order2 = new Order()
            {
                Person = "Person A",
                Plates = new BasePlate[] { soupPlate, greenPlate, greenPlate, redPlate, redPlate, bluePlate }
            };
            Order order3 = new Order()
            {
                Person = "Person B",
                Plates = new BasePlate[] { greyPlate, greyPlate, greenPlate, greenPlate, yellowPlate, yellowPlate, redPlate, redPlate }
            };
            Order order4 = new Order()
            {
                Person = "Person C",
                Plates = new BasePlate[] { soupPlate, soupPlate, greyPlate, greyPlate, greenPlate, greenPlate, yellowPlate, yellowPlate, yellowPlate, redPlate, redPlate }
            };
            List <Order> mockOrders = new List <Order> {
                order1, order2, order3, order4
            };

            this.clockMock.Setup(clk => clk.Now).Returns(new DateTime(2021, 5, 5, 13, 45, 0));
            int     expectedPersonCount  = 3;
            decimal personAExpectedValue = 13.35m;
            //decimal personBExpectedValue = 15.35m;
            decimal personBExpectedValue = 16.35m;
            decimal personCExpectedValue = 18.95m;
            //decimal expectedOptimizedPrice = 36.85m;
            decimal expectedOptimizedPrice = 45.4m;
            //decimal expectedSavings = 10.8m;
            decimal expectedSavings = 3.25m;

            //Act
            mockOrders.ForEach(o => this.orderService.AddOrder(o));
            OptimizedBill optimizedBill  = this.orderService.PayAllOrders();
            int           personCount    = optimizedBill.PersonalPrice.Count;
            PersonalPrice personABill    = optimizedBill.PersonalPrice["Person A"];
            PersonalPrice personBBill    = optimizedBill.PersonalPrice["Person B"];
            PersonalPrice personCBill    = optimizedBill.PersonalPrice["Person C"];
            decimal       optimizedPrice = optimizedBill.OptimizedPrice;
            decimal       actualSavings  = optimizedBill.Saved;

            //Assert
            Assert.Equal(expectedPersonCount, personCount);
            Assert.Equal(8, personABill.Plates.ToList().Count);
            Assert.Equal(personAExpectedValue, personABill.Total);
            Assert.Equal(personBExpectedValue, personBBill.Total);
            Assert.Equal(personCExpectedValue, personCBill.Total);
            Assert.Equal(expectedOptimizedPrice, optimizedPrice);
            Assert.Equal(expectedSavings, actualSavings);
        }