예제 #1
0
        public void ReturnPositiveNumber_WhenParameterIsNotNull()
        {
            // Arrange
            var expectedResult = 11;

            var firstProduct  = new Mock <IProduct>();
            var secondProduct = new Mock <IProduct>();

            firstProduct
            .SetupGet(m => m.Sugar)
            .Returns(5);

            secondProduct
            .SetupGet(m => m.Sugar)
            .Returns(6);

            ICollection <IProduct> productConsumed = new List <IProduct> {
                firstProduct.Object, secondProduct.Object
            };
            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult = dailyNutriCalcMock.CalculateCurrentSugars(productConsumed);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
예제 #2
0
        public void ReturnRemainingCarbsIntake_WhenInvokedWithValidParameters()
        {
            // Arrange
            var suggestedDailyCarbsIntake = 220;

            var firstProduct  = new Mock <IProduct>();
            var secondProduct = new Mock <IProduct>();

            firstProduct
            .SetupGet(m => m.Carbs)
            .Returns(60);

            secondProduct
            .SetupGet(m => m.Carbs)
            .Returns(55);

            var expectedResult = 105; // 220 - 115
            ICollection <IProduct> productConsumed = new List <IProduct> {
                firstProduct.Object, secondProduct.Object
            };
            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult = dailyNutriCalcMock.RemainingCarbsIntake(suggestedDailyCarbsIntake, productConsumed);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void ReturnRemainingCaloriesIntake_WhenActivityIsNull()
        {
            // Arrange
            var suggestedDailyCaloriesIntake = 2500;

            var firstProduct  = new Mock <IProduct>();
            var secondProduct = new Mock <IProduct>();

            firstProduct
            .SetupGet(m => m.Calories)
            .Returns(320);

            secondProduct
            .SetupGet(m => m.Calories)
            .Returns(450);

            var expectedResult = 1730; // 2500 - 770

            ICollection <IProduct> productConsumed = new List <IProduct> {
                firstProduct.Object, secondProduct.Object
            };

            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult =
                dailyNutriCalcMock.RemainingCaloriesIntake(suggestedDailyCaloriesIntake, productConsumed);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void ReturnRemainingCaloriesIntake_WhenProductsConsumedAreNull()
        {
            // Arrange
            var suggestedDailyCaloriesIntake = 2500;

            var activityMock = new Mock <IActivity>();

            activityMock
            .Setup(m => m.CalculateBurnedCalories())
            .Returns(270);

            var expectedResult = 2770; // 2500 + 270

            ICollection <IActivity> activities = new List <IActivity> {
                activityMock.Object
            };
            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult =
                dailyNutriCalcMock.RemainingCaloriesIntake(suggestedDailyCaloriesIntake, null, activities);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
예제 #5
0
        public void ReturnRemainingFatsIntake_WhenInvokedWithValidParameters()
        {
            // Arrange
            var suggestedDailyFatsIntake = 70;

            var firstProduct  = new Mock <IProduct>();
            var secondProduct = new Mock <IProduct>();

            firstProduct
            .SetupGet(m => m.Fat)
            .Returns(12);

            secondProduct
            .SetupGet(m => m.Fat)
            .Returns(22);

            var expectedResult = 36; // 70 - 34
            ICollection <IProduct> productConsumed = new List <IProduct> {
                firstProduct.Object, secondProduct.Object
            };
            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult = dailyNutriCalcMock.RemainingFatsIntake(suggestedDailyFatsIntake, productConsumed);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void ThrowArgumentException_WhenInvokedWithNegativeWaterConsumedParameter()
        {
            // Assert
            var suggestedWaterIntake = 3700;
            var waterConsumed        = -1000;

            var dailyNutriCal = new DailyNutriCalc();

            // Act
            Assert.ThrowsException <ArgumentException>(() =>
                                                       dailyNutriCal.RemainingWaterIntake(suggestedWaterIntake, waterConsumed));
        }
예제 #7
0
        public void Return0_WhenInvokedWithNullParameter()
        {
            // Arrange
            var expectedResult = 0;

            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult = dailyNutriCalcMock.CalculateCurrentSugars(null);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
예제 #8
0
        public void ReturnSuggestedCarbsIntake_WhenProductsConsumedAreNull()
        {
            // Arrange
            var suggestedDailyCarbsIntake = 220;
            var expectedResult            = suggestedDailyCarbsIntake;

            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult = dailyNutriCalcMock.RemainingCarbsIntake(suggestedDailyCarbsIntake, null);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void ReturnRemainingWaterIntake_WhenInvokedWithValidParameters()
        {
            // Assert
            var suggestedWaterIntake = 3700;
            var waterConsumed        = 2000;
            var expectedResult       = 1700;

            var dailyNutriCal = new DailyNutriCalc();

            // Act
            var actualResult = dailyNutriCal.RemainingWaterIntake(suggestedWaterIntake, waterConsumed);

            // Arrange
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void ReturnRemainingCaloriesIntake_WhenInvokedWithAllValidParameters()
        {
            // Arrange
            var suggestedDailyCaloriesIntake = 2500;

            var firstProduct  = new Mock <IProduct>();
            var secondProduct = new Mock <IProduct>();
            var activityMock  = new Mock <IActivity>();

            firstProduct
            .SetupGet(m => m.Calories)
            .Returns(320);

            secondProduct
            .SetupGet(m => m.Calories)
            .Returns(450);

            activityMock
            .Setup(m => m.CalculateBurnedCalories())
            .Returns(270);

            var expectedResult = 2000; // 2500 - 770  + 270

            ICollection <IProduct> productConsumed = new List <IProduct> {
                firstProduct.Object, secondProduct.Object
            };
            ICollection <IActivity> activities = new List <IActivity> {
                activityMock.Object
            };

            var dailyNutriCalcMock = new DailyNutriCalc();

            // Act
            var actualResult =
                dailyNutriCalcMock.RemainingCaloriesIntake(suggestedDailyCaloriesIntake, productConsumed, activities);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void ReturnCurrentDayMacrosRation_WhenInvokedWithValidParameters()
        {
            // Arrange
            var firstProduct  = new Mock <IProduct>();
            var secondProduct = new Mock <IProduct>();
            var thirdProduct  = new Mock <IProduct>();

            firstProduct
            .SetupGet(m => m.Calories)
            .Returns(189);

            firstProduct
            .SetupGet(m => m.Protein)
            .Returns(20);

            firstProduct
            .SetupGet(m => m.Carbs)
            .Returns(25);

            firstProduct
            .SetupGet(m => m.Fat)
            .Returns(1);

            secondProduct
            .SetupGet(m => m.Calories)
            .Returns(305);

            secondProduct
            .SetupGet(m => m.Protein)
            .Returns(25);

            secondProduct
            .SetupGet(m => m.Carbs)
            .Returns(40);

            secondProduct
            .SetupGet(m => m.Fat)
            .Returns(5);

            thirdProduct
            .SetupGet(m => m.Calories)
            .Returns(410);

            thirdProduct
            .SetupGet(m => m.Protein)
            .Returns(8);

            thirdProduct
            .SetupGet(m => m.Carbs)
            .Returns(70);

            thirdProduct
            .SetupGet(m => m.Fat)
            .Returns(10);

            var dailyNutriCalc = new DailyNutriCalc();
            ICollection <IProduct> productsConsumed =
                new List <IProduct> {
                firstProduct.Object, secondProduct.Object, thirdProduct.Object
            };

            var carbsCalories   = 540;
            var proteinCalories = 212;
            var fatCalories     = 144;

            var expectedResult = $"Carbs:Protein:Fat = {60}:{24}:{16}";

            // Act
            var actualResult = dailyNutriCalc.CurrentDayMacrosRatio(productsConsumed);

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }