public void TestThanFirstBunchDataCalculateCorrectly()
        {
            var calculator = new FirstBunchDataCalculator();
            var results    = calculator.Recalculate(ExceptionRulePerPayRuleStub.GetData());

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.AreEqual("PersonNumber1", results[0].PayRule.PersonNumber);
            Assert.AreEqual(new TimeSpan(13, 7, 0), results[0].ExceptionRule.InLate);
            Assert.AreEqual(new TimeSpan(21, 8, 0), results[0].ExceptionRule.OutLate);
            Assert.AreEqual(new TimeSpan(8, 0, 0), results[0].ExceptionRule.InEarly);
            Assert.AreEqual(new TimeSpan(11, 48, 0), results[0].ExceptionRule.OutEarly);

            Assert.AreEqual("PersonNumber2", results[1].PayRule.PersonNumber);
            Assert.AreEqual(new TimeSpan(8, 0, 0), results[1].ExceptionRule.InLate);
            Assert.AreEqual(new TimeSpan(22, 0, 0), results[1].ExceptionRule.OutLate);
            Assert.AreEqual(new TimeSpan(8, 0, 0), results[1].ExceptionRule.InEarly);
            Assert.AreEqual(new TimeSpan(17, 0, 0), results[1].ExceptionRule.OutEarly);

            Assert.AreEqual("PersonNumber3", results[2].PayRule.PersonNumber);
            Assert.AreEqual(new TimeSpan(8, 0, 0), results[2].ExceptionRule.InLate);
            Assert.AreEqual(new TimeSpan(22, 0, 0), results[2].ExceptionRule.OutLate);
            Assert.AreEqual(new TimeSpan(4, 41, 0), results[2].ExceptionRule.InEarly);
            Assert.AreEqual(new TimeSpan(17, 0, 0), results[2].ExceptionRule.OutEarly);
        }
        public void TestExceptionMapToUnscheduleExceptionCorrectly()
        {
            var exceptionPerPayRules = ExceptionRulePerPayRuleStub.GetData();
            var timesheets           = TimesheetStub.GetData();

            var mapper        = new UnscheduleExceptionMapper();
            var date          = new DateTime(2017, 1, 1);
            var scheduleInOut = "scheduleInOut";

            var result = mapper.Map(exceptionPerPayRules, timesheets, date, scheduleInOut);

            Assert.NotNull(result);
            Assert.AreEqual(3, result.Count);
            for (int i = 0; i <= 1; i++)
            {
                Assert.AreEqual(date, result[i].Date);
                Assert.AreEqual(new TimeSpan(12, 31, 0), result[i].InPuchTime);
                Assert.AreEqual(new TimeSpan(13, 31, 0), result[i].OutPuchTime);
                Assert.AreEqual("scheduleInOut", result[i].ScheduledInOut);
                Assert.AreEqual(true, result[i].ExceptionRulePerPayRule.ExceptionRule.Unscheduled);
                Assert.AreEqual("PayRuleName1", result[i].ExceptionRulePerPayRule.PayRule.PayRuleName);
                Assert.AreEqual("FullName1", result[i].ExceptionRulePerPayRule.PayRule.FullName);
                Assert.AreEqual("PersonNumber1", result[i].ExceptionRulePerPayRule.PayRule.PersonNumber);
            }

            Assert.AreEqual("ExceptionTypeName1_1", result[0].TimekeepingExceptionTypeName);
            Assert.AreEqual("ExceptionTypeName1_2", result[1].TimekeepingExceptionTypeName);

            Assert.AreEqual(date, result[2].Date);
            Assert.AreEqual(new TimeSpan(12, 31, 0), result[2].InPuchTime);
            Assert.Null(result[2].OutPuchTime);
            Assert.AreEqual("scheduleInOut", result[2].ScheduledInOut);
            Assert.Null(result[2].ExceptionRulePerPayRule.ExceptionRule.Unscheduled);
            Assert.AreEqual("PayRuleName2", result[2].ExceptionRulePerPayRule.PayRule.PayRuleName);
            Assert.AreEqual("FullName2", result[2].ExceptionRulePerPayRule.PayRule.FullName);
            Assert.AreEqual("PersonNumber2", result[2].ExceptionRulePerPayRule.PayRule.PersonNumber);
            Assert.Null(result[2].TimekeepingExceptionTypeName);


            date = new DateTime(2017, 1, 2);

            result = mapper.Map(exceptionPerPayRules, timesheets, date, scheduleInOut);
            Assert.NotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(date, result[0].Date);
            Assert.AreEqual(new TimeSpan(12, 32, 0), result[0].InPuchTime);
            Assert.Null(result[0].OutPuchTime);
            Assert.AreEqual("scheduleInOut", result[0].ScheduledInOut);
            Assert.AreEqual(true, result[0].ExceptionRulePerPayRule.ExceptionRule.Unscheduled);
            Assert.AreEqual("PayRuleName1", result[0].ExceptionRulePerPayRule.PayRule.PayRuleName);
            Assert.AreEqual("FullName1", result[0].ExceptionRulePerPayRule.PayRule.FullName);
            Assert.AreEqual("PersonNumber1", result[0].ExceptionRulePerPayRule.PayRule.PersonNumber);
            Assert.Null(result[0].TimekeepingExceptionTypeName);
        }
        public void TestsMapping()
        {
            var mapper         = new OutLateDataMapper();
            var date           = new DateTime(2017, 2, 25);
            var exceptionRules = ExceptionRulePerPayRuleStub.GetData();
            var result         = mapper.Map(exceptionRules, date);

            Assert.NotNull(result);
            Assert.NotNull(result.Item1);
            Assert.NotNull(result.Item2);
            Assert.NotNull(result.Item3);

            Assert.AreEqual(date, result.Item1.Schedules[0].StartDate);
            Assert.AreEqual(date, result.Item1.Schedules[0].EndDate);
            Assert.AreEqual(new TimeSpan(8, 0, 0), result.Item1.Schedules[0].ShiftStartTime);
            Assert.AreEqual(new TimeSpan(17, 0, 0), result.Item1.Schedules[0].ShiftEndTime);
            Assert.AreEqual(1, result.Item1.Schedules[0].ShiftStartDayNumber);
            Assert.AreEqual(1, result.Item1.Schedules[0].ShiftEndDayNumber);

            Assert.AreEqual(3, result.Item2.Count);
            Assert.AreEqual(exceptionRules[0].PayRule.PersonNumber, result.Item2[0].PersonNumber);
            Assert.AreEqual(exceptionRules[1].PayRule.PersonNumber, result.Item2[1].PersonNumber);
            Assert.AreEqual(exceptionRules[2].PayRule.PersonNumber, result.Item2[2].PersonNumber);
            Assert.AreEqual(date, result.Item2[0].Date);
            Assert.AreEqual(date, result.Item2[1].Date);
            Assert.AreEqual(date, result.Item2[2].Date);
            Assert.AreEqual(PunchType.InPunch, result.Item2[0].Type);
            Assert.AreEqual(PunchType.InPunch, result.Item2[1].Type);
            Assert.AreEqual(PunchType.InPunch, result.Item2[2].Type);
            Assert.AreEqual(new TimeSpan(8, 0, 0), result.Item2[0].Time);
            Assert.AreEqual(new TimeSpan(8, 0, 0), result.Item2[1].Time);
            Assert.AreEqual(new TimeSpan(8, 0, 0), result.Item2[2].Time);

            Assert.AreEqual(3, result.Item3.Count);
            Assert.AreEqual(exceptionRules[0].PayRule.PersonNumber, result.Item3[0].PersonNumber);
            Assert.AreEqual(exceptionRules[1].PayRule.PersonNumber, result.Item3[1].PersonNumber);
            Assert.AreEqual(exceptionRules[2].PayRule.PersonNumber, result.Item3[2].PersonNumber);
            Assert.AreEqual(date, result.Item3[0].Date);
            Assert.AreEqual(PunchType.OutPunch, result.Item3[0].Type);
            Assert.AreEqual(PunchType.OutPunch, result.Item3[1].Type);
            Assert.AreEqual(PunchType.OutPunch, result.Item3[2].Type);
            Assert.AreEqual(date, result.Item3[1].Date);
            Assert.AreEqual(date, result.Item3[2].Date);
            Assert.AreEqual(exceptionRules[0].ExceptionRule.OutLate, result.Item3[0].Time);
            Assert.AreEqual(exceptionRules[1].ExceptionRule.OutLate, result.Item3[1].Time);
            Assert.AreEqual(exceptionRules[2].ExceptionRule.OutLate, result.Item3[2].Time);
        }
        public void TestExceptionMapToScheduleExceptionWithOverridePunchOutCorrectly(
            string overridePunchIn,
            string overridePunchOut,
            bool isEarly)
        {
            var exceptionPerPayRules = ExceptionRulePerPayRuleStub.GetData();
            var timesheets           = TimesheetStub.GetData();

            var mapper = new ScheduleExceptionMapper();
            var dates  = new List <DateTime> {
                new DateTime(2017, 1, 1), new DateTime(2017, 1, 2)
            };
            var punchIn = overridePunchIn != null?TimeSpan.Parse(overridePunchIn) : (TimeSpan?)null;

            var punchOut = overridePunchOut != null?TimeSpan.Parse(overridePunchOut) : (TimeSpan?)null;

            var result = mapper.Map(exceptionPerPayRules, timesheets, dates, punchIn, punchOut, isEarly);

            Assert.NotNull(result);
            Assert.AreEqual(4, result.Count);
            for (int i = 0; i <= 1; i++)
            {
                Assert.AreEqual(new DateTime(2017, 1, 1), result[i].Date);
                Assert.AreEqual(new TimeSpan(8, 0, 0), result[i].ScheduledIn);
                Assert.AreEqual(new TimeSpan(17, 0, 0), result[i].ScheduledOut);
                if (overridePunchIn != null)
                {
                    Assert.AreEqual(punchIn, result[i].InPuchTime);
                    Assert.AreEqual(new TimeSpan(13, 31, 0), result[i].OutPuchTime);
                    if (isEarly)
                    {
                        Assert.AreEqual(new TimeSpan(5, 13, 0), result[i].ExceptionConfigTime);
                    }
                    else
                    {
                        Assert.AreEqual(new TimeSpan(4, 9, 0), result[i].ExceptionConfigTime);
                    }
                }
                else
                {
                    Assert.AreEqual(new TimeSpan(8, 1, 0), result[i].InPuchTime);
                    Assert.AreEqual(punchOut, result[i].OutPuchTime);
                    if (isEarly)
                    {
                        Assert.AreEqual(new TimeSpan(22, 0, 0), result[i].ExceptionConfigTime);
                    }
                    else
                    {
                        Assert.AreEqual(new TimeSpan(5, 8, 0), result[i].ExceptionConfigTime);
                    }
                }

                Assert.AreEqual(true, result[i].ExceptionRulePerPayRule.ExceptionRule.Unscheduled);
                Assert.AreEqual("PayRuleName1", result[i].ExceptionRulePerPayRule.PayRule.PayRuleName);
                Assert.AreEqual("FullName1", result[i].ExceptionRulePerPayRule.PayRule.FullName);
                Assert.AreEqual("PersonNumber1", result[i].ExceptionRulePerPayRule.PayRule.PersonNumber);
            }

            Assert.AreEqual("ExceptionTypeName1_1", result[0].TimekeepingExceptionTypeName);
            Assert.AreEqual("ExceptionTypeName1_2", result[1].TimekeepingExceptionTypeName);

            Assert.AreEqual(new DateTime(2017, 1, 2), result[2].Date);
            Assert.AreEqual(new TimeSpan(8, 0, 0), result[2].ScheduledIn);
            Assert.AreEqual(new TimeSpan(17, 0, 0), result[2].ScheduledOut);
            if (overridePunchIn != null)
            {
                Assert.AreEqual(punchIn, result[2].InPuchTime);
                Assert.Null(result[2].OutPuchTime);
                if (isEarly)
                {
                    Assert.AreEqual(new TimeSpan(5, 13, 0), result[2].ExceptionConfigTime);
                }
                else
                {
                    Assert.AreEqual(new TimeSpan(4, 9, 0), result[2].ExceptionConfigTime);
                }
            }
            else
            {
                Assert.AreEqual(punchOut, result[2].OutPuchTime);
                Assert.AreEqual(new TimeSpan(12, 32, 0), result[2].InPuchTime);
                if (isEarly)
                {
                    Assert.AreEqual(new TimeSpan(22, 0, 0), result[2].ExceptionConfigTime);
                }
                else
                {
                    Assert.AreEqual(new TimeSpan(5, 8, 0), result[2].ExceptionConfigTime);
                }
            }

            Assert.AreEqual(true, result[2].ExceptionRulePerPayRule.ExceptionRule.Unscheduled);
            Assert.AreEqual("PayRuleName1", result[2].ExceptionRulePerPayRule.PayRule.PayRuleName);
            Assert.AreEqual("FullName1", result[2].ExceptionRulePerPayRule.PayRule.FullName);
            Assert.AreEqual("PersonNumber1", result[2].ExceptionRulePerPayRule.PayRule.PersonNumber);
            Assert.Null(result[2].TimekeepingExceptionTypeName);

            Assert.AreEqual(new DateTime(2017, 1, 1), result[3].Date);
            Assert.AreEqual(new TimeSpan(8, 0, 0), result[3].ScheduledIn);
            Assert.AreEqual(new TimeSpan(17, 0, 0), result[3].ScheduledOut);
            if (overridePunchIn != null)
            {
                Assert.AreEqual(punchIn, result[3].InPuchTime);
                Assert.Null(result[3].OutPuchTime);
                if (isEarly)
                {
                    Assert.AreEqual(new TimeSpan(21, 0, 29), result[3].ExceptionConfigTime);
                }
                else
                {
                    Assert.AreEqual(new TimeSpan(5, 1, 0), result[3].ExceptionConfigTime);
                }
            }
            else
            {
                Assert.AreEqual(punchOut, result[3].OutPuchTime);
                Assert.AreEqual(new TimeSpan(12, 31, 0), result[3].InPuchTime);
                if (isEarly)
                {
                    Assert.AreEqual(new TimeSpan(13, 1, 45), result[3].ExceptionConfigTime);
                }
                else
                {
                    Assert.AreEqual(new TimeSpan(8, 0, 0), result[3].ExceptionConfigTime);
                }
            }
            Assert.Null(result[3].ExceptionRulePerPayRule.ExceptionRule.Unscheduled);
            Assert.AreEqual("PayRuleName2", result[3].ExceptionRulePerPayRule.PayRule.PayRuleName);
            Assert.AreEqual("FullName2", result[3].ExceptionRulePerPayRule.PayRule.FullName);
            Assert.AreEqual("PersonNumber2", result[3].ExceptionRulePerPayRule.PayRule.PersonNumber);
            Assert.Null(result[3].TimekeepingExceptionTypeName);
        }