public void TotalHoursWorkedTest()
        {
            var repo             = new TimeTrackerRepository();
            int totalHoursWorked = repo.TotalHoursWorked(6);

            Assert.AreEqual(22, totalHoursWorked);
        }
        public void GetSingleEmployeeTest()
        {
            var      repo           = new TimeTrackerRepository();
            Employee singleEmployee = repo.GetSingleEmployee(6);

            Assert.AreEqual("Lisa", singleEmployee.FirstName);
        }
        public void GetAllEmployeesTest()
        {
            var             repo         = new TimeTrackerRepository();
            List <Employee> allEmployees = repo.GetAllEmployees();

            Assert.AreEqual(14, allEmployees.Count);
        }
Esempio n. 4
0
        public List <Managers> GetManagers()
        {
            var repo     = new TimeTrackerRepository();
            var managers = repo.GetAllManagers();

            return(managers);
        }
Esempio n. 5
0
        public Response <List <Employee> > GetAllEmployees()
        {
            TimeTrackerRepository repo      = new TimeTrackerRepository();
            var             response        = new Response <List <Employee> >();
            List <Employee> listOfEmployees = repo.GetAllEmployees();

            try
            {
                if (listOfEmployees.Count > 0)
                {
                    response.Success = true;
                    response.Data    = listOfEmployees;
                }
                else
                {
                    response.Success = false;
                    response.Message = "There were no employees found";
                }
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }
            return(response);
        }
        public void DeleteTimesheetTest()
        {
            var repo = new  TimeTrackerRepository();

            repo.DeleteTimesheet(1);
            List <Timesheet> listOfSheets = repo.GetAllTimeSheets(1);

            Assert.IsFalse(listOfSheets.Exists(p => p.TimesheetId == 1));
        }
        public void DeleteEmpTimesheetTest()
        {
            TimeTrackerOperations ops = new TimeTrackerOperations();

            ops.DeleteSingleTimesheet(14);
            var repo = new TimeTrackerRepository();
            List <Timesheet> listOfSheets = repo.GetAllTimeSheets(5);

            Assert.IsFalse(listOfSheets.Exists(p => p.TimesheetId == 15));
        }
        public void GetAllSheetsTest()
        {
            var repo = new TimeTrackerRepository();
            List <Timesheet> timesheets = new List <Timesheet>();

            timesheets = repo.GetAllTimeSheets(6);
            var timesheet = timesheets.FirstOrDefault(x => x.TimesheetId == 22);

            Assert.AreEqual(timesheet.EntryTypeName, "Timesheet");
            Assert.AreEqual(4, timesheets.Count);
        }
        public void SubmitNewTimeSheet()
        {
            var repo      = new TimeTrackerRepository();
            var timesheet = new Timesheet()
            {
                DateOfTimesheet = new DateTime(1989, 02, 01),
                EmpId           = 1,
                TotalHoursByDay = 2
            };

            repo.SubmitNewTimeSheet(timesheet);
            List <Timesheet> listOfSheets = repo.GetAllTimeSheets(1);

            Assert.AreEqual(8, listOfSheets.Count);
        }
        public void Repository_Create_ThrowsException_WhenAlreadyExists(Mock <DbSet <TimeEntry> > dbSet,
                                                                        Mock <TimeTrackerDbContext> dbContext,
                                                                        List <TimeEntry> fakeTimeEntries,
                                                                        int userId,
                                                                        DateTime entryDate)
        {
            // Arrange
            fakeTimeEntries.Add(new TimeEntry(userId, entryDate.Date));
            dbSet.SetupData(fakeTimeEntries);
            dbContext.Setup(moq => moq.TimeEntries).Returns(dbSet.Object);
            var sut = new TimeTrackerRepository(dbContext.Object);
            // Act
            Action act = () => sut.Create(userId, entryDate);

            // Assert
            act.Should().Throw <Exception>("because time entry already exists").And.Message.Contains("TimeEntry already exists");
        }
Esempio n. 11
0
        public void SubmitTimeSheetTest()
        {
            TimeTrackerOperations ops = new TimeTrackerOperations();
            var timesheet             = new Timesheet()
            {
                DateOfTimesheet = new DateTime(1989, 07, 01),
                EmpId           = 1,
                TotalHoursByDay = 12
            };

            ops.SubmitTimeSheet(timesheet);

            var repo = new TimeTrackerRepository();
            List <Timesheet> listOfSheets = repo.GetAllTimeSheets(1);

            Assert.AreEqual(6, listOfSheets.Count);
        }
        public void Repository_Create_Success(Mock <DbSet <TimeEntry> > dbSet,
                                              Mock <TimeTrackerDbContext> dbContext,
                                              List <TimeEntry> fakeTimeEntries,
                                              int userId,
                                              DateTime entryDate)
        {
            // Arrange
            int initialDbSetCount = fakeTimeEntries.Count();

            dbSet.SetupData(fakeTimeEntries);
            dbContext.Setup(moq => moq.TimeEntries).Returns(dbSet.Object);
            var sut = new TimeTrackerRepository(dbContext.Object);
            // Act
            var response = sut.Create(userId, entryDate);

            // Assert
            response.Id.Should().NotBeEmpty("because Id is autoset");
            response.UserId.Should().Be(userId, "because it is passed as an input");
            response.EntryDate.Should().Be(entryDate.Date, "because it is passed as an input");
            dbContext.Object.TimeEntries.Count().Should().Be(initialDbSetCount + 1, "because a new item is added to the collection");
        }
Esempio n. 13
0
        public Response <TimeTrackerSummary> GetTimeTrackerSummary(int empId)
        {
            TimeTrackerRepository repo = new TimeTrackerRepository();
            var response = new Response <TimeTrackerSummary>();
            List <Timesheet> listOfTimesheets = repo.GetAllTimeSheets(empId);

            try
            {
                if (listOfTimesheets.Count > 0)
                {
                    response.Success = true;
                    response.Data    = new TimeTrackerSummary()
                    {
                        SelectedEmployee = repo.GetSingleEmployee(empId),
                        TotalHoursWorked = repo.TotalHoursWorked(empId),
                        AllTimesheets    = listOfTimesheets
                    };
                }

                else
                {
                    response.Data = new TimeTrackerSummary()
                    {
                        SelectedEmployee = repo.GetSingleEmployee(empId),
                    };

                    response.Success = false;
                    response.Message = "There were no timesheets found for that employee";
                }
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }

            return(response);
        }
Esempio n. 14
0
        public void SubmitTimeSheet(Timesheet timesheet)
        {
            TimeTrackerRepository repo = new TimeTrackerRepository();

            repo.SubmitNewTimeSheet(timesheet);
        }
Esempio n. 15
0
        public void DeleteSingleTimesheet(int timesheetId)
        {
            TimeTrackerRepository repo = new TimeTrackerRepository();

            repo.DeleteTimesheet(timesheetId);
        }