public ActionResult ViewPayroll(PayrollViewModel viewModel)
        {
            var pc    = new PayrollCalculator(db);
            var stubs = pc.GetPayroll(viewModel.StartDate, viewModel.NumberOfWeeks);

            return(View(stubs));
        }
        public IEnumerable <PayStub> Index(string dateString, string weekString)
        {
            //var rangeQuery = HttpUtility.ParseQueryString(Request.RequestUri.Query);
            var startDate = DateTime.ParseExact(dateString, "yyyyMMdd", CultureInfo.CurrentCulture);

            var numberOfWeeks = Convert.ToInt32(weekString);
            var pc            = new PayrollCalculator(db);

            var payroll = pc.GetPayroll(startDate, numberOfWeeks);

            return(payroll);
        }
        public void Given_th_employee_is_paid_10_per_hour_when_the_employee_works_40_hours_the_Gross_amount_400()
        {
            var employee = new Employee()
            {
                HourRate = 40, TotalWorkedHours = 10
            };

            IPayroll payrollCaculator = new PayrollCalculator();
            var      expected         = 400;
            var      actual           = payrollCaculator.CalculateGrossIncome(employee);

            Assert.Equal(expected, actual);
        }
        public void Should_NotPayOvertime_WithLessThan40Hours()
        {
            //arrange
            PayrollCalculator calculator     = new PayrollCalculator();
            double            hours          = 5.0;
            decimal           rate           = 8.25m;
            decimal           expectedResult = 41.25m;

            //act
            decimal actualResult = calculator.CalulateGrossPay(hours, rate);

            //assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void Should_PayOvertime_WithOver40Hours()
        {
            //arrange
            PayrollCalculator calculator     = new PayrollCalculator();
            double            hours          = 42.5;
            decimal           rate           = 10m;
            decimal           expectedResult = 437.50m;

            //act
            decimal actualResult = calculator.CalulateGrossPay(hours, rate);

            //assert
            Assert.AreEqual(expectedResult, actualResult);
        }
Beispiel #6
0
        public void CalculatePayroll_ValidInputData_ShouldProduceCorrectPayroll(double taxRate,
                                                                                double hourlyRate, int timeCardHours, bool seniority, double payroll)
        {
            // arrange
            TaxBracket taxBracket = new TaxBracket
            {
                TaxRate = taxRate
            };

            Employee employee = new Employee
            {
                Seniority  = seniority,
                HourlyRate = hourlyRate
            };

            TimeCard timeCard = new TimeCard
            {
                TotalHours = timeCardHours
            };

            Mock <ITaxService>      taxServiceMock      = new Mock <ITaxService>();
            Mock <IEmployeeService> employeeServiceMock = new Mock <IEmployeeService>();
            Mock <ITimeCardService> timeCardServiceMock = new Mock <ITimeCardService>();

            taxServiceMock.Setup(x => x.GetTaxBracket(It.IsAny <double>())).Returns(taxBracket);
            employeeServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(employee);
            timeCardServiceMock
            .Setup(x => x.GetEmployeeTimeCard(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <DateTime>()))
            .Returns(timeCard);

            var sut = new PayrollCalculator(timeCardServiceMock.Object, employeeServiceMock.Object,
                                            taxServiceMock.Object);

            // act
            double amount = sut.CalculatePayroll(DateTime.Now, DateTime.Now.AddDays(7), "1");

            // assert
            Assert.Equal(payroll, amount);
        }
Beispiel #7
0
        public void CalculatePayroll_LessThanOrEqualZeroTimeCardHours_ShouldReturnZero(int hours)
        {
            // arrange
            TaxBracket taxBracket = new TaxBracket
            {
                TaxRate = 0.2
            };

            Employee employee = new Employee
            {
                Seniority  = false,
                HourlyRate = 25
            };

            TimeCard timeCard = new TimeCard
            {
                TotalHours = hours
            };

            Mock <ITaxService>      taxServiceMock      = new Mock <ITaxService>();
            Mock <IEmployeeService> employeeServiceMock = new Mock <IEmployeeService>();
            Mock <ITimeCardService> timeCardServiceMock = new Mock <ITimeCardService>();

            taxServiceMock.Setup(x => x.GetTaxBracket(It.IsAny <double>())).Returns(taxBracket);
            employeeServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(employee);
            timeCardServiceMock
            .Setup(x => x.GetEmployeeTimeCard(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <DateTime>()))
            .Returns(timeCard);

            var sut = new PayrollCalculator(timeCardServiceMock.Object, employeeServiceMock.Object,
                                            taxServiceMock.Object);

            // act
            double payroll = sut.CalculatePayroll(DateTime.Now, DateTime.Now.AddDays(7), "1");

            // assert
            Assert.Equal(0, payroll);
        }