public void Should_increase_original_premium_by_20_percent_when_driver_is_24()
        {
            const double expected            = 600.00;
            const double increaseAmount      = 0.2;
            const int    startingYoungAge    = 21;
            const int    endingYoungAge      = 25;
            const string driverName          = "name";
            const string occupation          = "occupation";
            const string secondDriverName    = "name2";
            const double premium             = 500.00;
            var          todayProvider       = new GenericStubProvider <DateTime>(new[] { DateTime.Today, DateTime.Today });
            var          driverDateOfBirth   = DateTime.Now.AddYears(-25);
            var          driversDateOfBirth  = DateTime.Now.AddYears(-40);
            var          driverClaims        = new IClaim[0];
            var          secondDriversClaims = new IClaim[0];
            var          driversAndPremiumToUpdatedPremiumForYoungDrivers = new DriversAndPremiumToUpdatedPremiumForYoungDrivers(startingYoungAge, endingYoungAge, todayProvider, increaseAmount);
            var          firstDriver       = new DriverStub(driverName, occupation, driverDateOfBirth, driverClaims);
            var          secondDriver      = new DriverStub(secondDriverName, occupation, driversDateOfBirth, secondDriversClaims);
            var          drivers           = new [] { firstDriver, secondDriver };
            var          driversAndPremium = new DriverAndPremium(firstDriver, premium);

            var actual = driversAndPremiumToUpdatedPremiumForYoungDrivers.Transform(driversAndPremium);

            Assert.AreEqual(expected, actual);
        }
        public void Should_return_original_premium_when_neither_driver_is_a_chauffeur()
        {
            const double increaseAmount              = 0.1;
            const double expected                    = 500.00;
            const string driversName                 = "name";
            const string driversOccupation           = "Mechanic";
            var          driversDateOfBirth          = DateTime.Now;
            var          driversClaims               = new IClaim[0];
            var          jobsWherePremiumIsIncreased = new [] { "Chauffeur" };
            var          driversAndPremiumToIncreasedPremiumBasedOnOccupationTransform = new DriversAndPremiumToIncreasedPremiumBasedOnOccupationTransform(jobsWherePremiumIsIncreased, increaseAmount);
            var          driver           = new DriverStub(driversName, driversOccupation, driversDateOfBirth, driversClaims);
            var          driverAndPremium = new DriverAndPremium(driver, expected);

            var actual = driversAndPremiumToIncreasedPremiumBasedOnOccupationTransform.Transform(driverAndPremium);

            Assert.AreEqual(expected, actual);
        }
예제 #3
0
        public void Should_return_original_premium_when_driver_is_not_an_Accountant()
        {
            const double expected                    = 500.00;
            const double decreaseAmount              = 0.1;
            const string driversName                 = "name";
            const string driversOccupation           = "Electrician";
            var          driversDateOfBirth          = DateTime.Now;
            var          driversClaims               = new IClaim[0];
            var          jobsWherePremiumIsDecreased = new [] { "Accountant" };
            var          driversAndPremiumToDecreasedPremiumBasedOnOccupationTransform = new DriversAndPremiumToDecreasedPremiumBasedOnOccupationTransform(jobsWherePremiumIsDecreased, decreaseAmount);
            var          firstDriver      = new DriverStub(driversName, driversOccupation, driversDateOfBirth, driversClaims);
            var          driverAndPremium = new DriverAndPremium(firstDriver, expected);

            var actual = driversAndPremiumToDecreasedPremiumBasedOnOccupationTransform.Transform(driverAndPremium);

            Assert.AreEqual(expected, actual);
        }
        public void Should_return_the_result_of_driversAndPremiumToDecreasedPremiumBasedOnOccupationTransform()
        {
            const double premium            = 500.00;
            const string driverName         = "name";
            const string driverOccupation   = "occupation";
            var          driversDateOfBirth = DateTime.Now;
            var          claims             = new IClaim[0];
            var          drivers            = new DriverStub(driverName, driverOccupation, driversDateOfBirth, claims);
            const double expected           = 660.00;
            var          driversAndPremium  = new DriverAndPremium(drivers, premium);
            var          driversAndPremiumToIncreasedPremiumBasedOnOccupationTransform = new GenericStubTransform <DriverAndPremium, double>(premium);
            var          driversAndPremiumToDecreasedPremiumBasedOnOccupationTransform = new GenericStubTransform <DriverAndPremium, double>(expected);
            var          driversAndPremiumToUpdatedPremiumBasedOnOccupationTransform   = new DriversAndPremiumToUpdatedPremiumBasedOnOccupationTransform(driversAndPremiumToIncreasedPremiumBasedOnOccupationTransform, driversAndPremiumToDecreasedPremiumBasedOnOccupationTransform);

            var actual = driversAndPremiumToUpdatedPremiumBasedOnOccupationTransform.Transform(driversAndPremium);

            Assert.AreEqual(expected, actual);
        }
        public void Should_return_original_premium_when_driver_is_younger_than_26()
        {
            const double increaseAmount    = 0.1;
            const int    startingAdultAge  = 26;
            const int    endingAdultAge    = 75;
            const string driverName        = "name";
            const string occupation        = "occupation";
            const double expected          = 500.00;
            var          todayProvider     = new GenericStubProvider <DateTime>(new[] { DateTime.Today, DateTime.Today });
            var          driverDateOfBirth = DateTime.Now.AddYears(-25);
            var          driverClaims      = new IClaim[0];
            var          driversAndPremiumToUpdatedPremiumForYoungDrivers = new DriversAndPremiumToUpdatedPremiumForAdultDrivers(startingAdultAge, endingAdultAge, todayProvider, increaseAmount);
            var          driver            = new DriverStub(driverName, occupation, driverDateOfBirth, driverClaims);
            var          driversAndPremium = new DriverAndPremium(driver, expected);

            var actual = driversAndPremiumToUpdatedPremiumForYoungDrivers.Transform(driversAndPremium);

            Assert.AreEqual(expected, actual);
        }
예제 #6
0
        public void Should_increase_premium_by_smaller_percentage_when_a_claim_has_been_made_more_than_one_year_ago()
        {
            const double expected                = 550.00;
            const string name                    = "name";
            const string occupation              = "occupation";
            const double premium                 = 500.00;
            var          dateOfBirth             = DateTime.Now;
            var          dateOfClaim             = DateTime.Today.AddYears(-2);
            var          todayProvider           = new GenericStubProvider <DateTime>(DateTime.Today);
            const double smallerPercentIncrease  = 0.1;
            const double largePercentageIncrease = 0.2;
            const int    smallerTimeSpanInYears  = 1;
            const int    largerTimeSpanInYears   = 5;
            var          driversAndPremiumToUpdatedPremiumBasedOnDriverClaimsTransform = new DriversAndPremiumToUpdatedPremiumBasedOnDriverClaimsTransform(smallerPercentIncrease, largePercentageIncrease, smallerTimeSpanInYears, largerTimeSpanInYears, todayProvider);
            var          claim             = new ClaimStub(dateOfClaim);
            var          driver            = new DriverStub(name, occupation, dateOfBirth, new [] { claim });
            var          driversAndPremium = new DriverAndPremium(driver, premium);

            var actual = driversAndPremiumToUpdatedPremiumBasedOnDriverClaimsTransform.Transform(driversAndPremium);

            Assert.AreEqual(expected, actual);
        }