public async Task UpdateWorkLog_WhenModelValid_UpdatesWorkLogInDatabase()
        {
            var request = new WorkLogUpdateRequest()
            {
                Description  = "description",
                ActivityType = ActivityType.Coding,
                StartDate    = DateTimeOffset.MaxValue.AddDays(-3333),
                TimeSpent    = TimeSpan.FromDays(2).Seconds,
                WorkLogId    = WorklogsDbSet.Get().First().Id
            };

            var httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLog, request);

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.VerifySuccessResponse();
            var worklog = await GetWorkLogFromDatabase(request.WorkLogId);

            worklog.Description.Should().Be(request.Description);
            worklog.ActivityType.Should().Be(request.ActivityType);
            worklog.StartDate.Should().Be(request.StartDate);
            worklog.TimeSpent.Should().Be(request.TimeSpent);
            await ReSeedDatabase();
        }
        public async Task GetActivitiesForUser_WhenModelValid_ReturnsUserActivities()
        {
            var user    = UsersDbSet.Get().First();
            var request = new ActivitiesRequest()
            {
                ProjectId = ProjectsDbSet.Get().First().Id,
                UserId    = user.Id
            };
            var workLogItems = WorklogsDbSet.Get().Where(e => e.UserId.Equals(request.UserId))
                               .Include(e => e.Issue)
                               .ThenInclude(e => e.Project)
                               .Where(e => e.Issue.ProjectId.Equals(request.ProjectId));
            var httpResponse = await GetAsync(WorkLogControllerRoutes.GetUserWorkLogs + "?" + request.ToQueryString());

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiResponse <UserActivityDto> >();

            response.VerifySuccessResponse();
            response.Data.UserId.Should().Be(request.UserId);
            response.Data.UserName.Should().Be(user.FirstName);
            response.Data.UserSurname.Should().Be(user.LastName);
            response.Data.UserEmail.Should().Be(user.Email);
            response.Data.ProjectName.Should().Be(workLogItems?.Select(e => e.Issue.Project.Name).FirstOrDefault());
            response.Data.TotalWorkLogInSeconds.Should().Be((long?)workLogItems?.Sum(e => e.TimeSpent));
            response.Data.WorkLogItems.Should()
            .BeEquivalentTo(workLogItems?.Select(e => GetWorkLogDetails(e)).ToList());
            await ReSeedDatabase();
        }
Esempio n. 3
0
 public static void SeedData(TimeTrackingDbContext context)
 {
     context.Issues.AddRange(IssuesDbSet.Get().ToList());
     context.Projects.AddRange(ProjectsDbSet.Get().ToList());
     context.Milestones.AddRange(MilestonesDbSet.Get().ToList());
     context.Teams.AddRange(TeamsDbSet.Get().ToList());
     context.WorkLogs.AddRange(WorklogsDbSet.Get().ToList());
     context.Users.AddRange(UsersDbSet.Get().ToList());
     context.SaveChanges();
 }
        public async Task WorklogRepository_GetAllAsync_ReturnsAllValues()
        {
            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);
            var expected          = WorklogsDbSet.Get();

            var actual = await workLogRepository.GetAllAsync();

            Assert.That(actual.OrderBy(x => x.Id), Is.EqualTo(expected.OrderBy(x => x.Id))
                        .Using(EqualityComparers.WorkLogComparer));
        }
        public async Task WorklogRepository_GetById_ShouldReturnCorrectItem(string id)
        {
            var guidId = Guid.Parse(id);

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var expected          = WorklogsDbSet.Get().First(x => x.Id == guidId);
            var workLogRepository = new WorklogRepository(context);

            var actual = await workLogRepository.GetByIdAsync(guidId);

            Assert.That(actual, Is.EqualTo(expected).Using(EqualityComparers.WorkLogComparer));
        }
        public async Task WorklogRepository_UpdateAsync_UpdateEntity()
        {
            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);
            var entityToUpdate    = WorklogsDbSet.Get().First();

            entityToUpdate.Description = "New description";

            var actual = await workLogRepository.UpdateAsync(entityToUpdate);

            actual.Should().BeEquivalentTo(entityToUpdate);
        }
        public async Task WorklogRepository_DeleteAsync_DeletesEntity()
        {
            var guidId         = Guid.Parse("29C2F600-4F76-4753-A54D-A422DEF8EB9E");
            var entityToDelete = WorklogsDbSet.Get().First(x => x.Id == guidId);
            var expectedCount  = WorklogsDbSet.Get().ToList().Count - 1;

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);

            await workLogRepository.DeleteAsync(entityToDelete);

            context.WorkLogs.Should().HaveCount(expectedCount);
        }
        public async Task DeleteWorklog_WhenFound_DeletesWorkLogFromDatabase()
        {
            var expected  = WorklogsDbSet.Get().First();
            var workLogId = expected.Id;

            var httpResponse = await DeleteAsync(WorkLogControllerRoutes.BaseRoute + "/" + workLogId);

            var response = await httpResponse.BodyAs <ApiResponse>();

            response.StatusCode.Should().Be(200);
            var workLog = await GetWorkLogFromDatabase(workLogId);

            workLog.Should().BeNull();
            await ReSeedDatabase();
        }
        public async Task WorklogRepository_AddAsync_AddsValueToDatabase()
        {
            var expectedCount = WorklogsDbSet.Get().ToList().Count + 1;
            var entityToAdd   = WorklogsDbSet.WorkLogBuilder().Create();

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);

            await workLogRepository.AddAsync(entityToAdd);

            context.WorkLogs.Should().HaveCount(expectedCount);
            var entityFound = await context.WorkLogs.FindAsync(entityToAdd.Id);

            entityFound.Should().BeEquivalentTo(entityFound);
        }
        public async Task WorklogRepository_GetByIdWithUserAsync_ReturnsWorkLogForWithUser()
        {
            var workLogId = new Guid("29C2F600-4F76-4753-A54D-A422DEF8EB9E");

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);
            var expected          = WorklogsDbSet.Get().Where(e => e.Id == workLogId)
                                    .Include(e => e.TimeTrackingUser)
                                    .FirstOrDefault();

            var actual = await workLogRepository.GetByIdWithUserAsync(workLogId);

            Assert.That(actual, Is.EqualTo(expected).Using(EqualityComparers.WorkLogComparer));
            Assert.That(actual.TimeTrackingUser,
                        Is.EqualTo(expected.TimeTrackingUser).Using(EqualityComparers.TimeTrackingUserComparer));
        }
        public async Task GetAllWorkLogsPaged_WhenRequestValid_ReturnsAllWorkLogs(int page, int size, int expectedPage,
                                                                                  int expectedSize)
        {
            var expected     = WorklogsDbSet.Get().ToList();
            var pagedRequest = new PagedRequest()
            {
                Page     = page,
                PageSize = size
            };
            var httpResponse = await GetAsync(WorkLogControllerRoutes.BaseRoute + "?" + pagedRequest.ToQueryString());

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiPagedResponse <WorkLogDetailsDto> >();

            response.EnsurePagedResult(expected.Count, expectedSize, expectedPage);
        }
        public async Task GetWorkLog_WhenFound_ReturnsWorkLog()
        {
            var expected  = WorklogsDbSet.Get().First();
            var workLogId = expected.Id;

            var httpResponse = await GetAsync(WorkLogControllerRoutes.BaseRoute + "/" + workLogId);

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiResponse <WorkLogDetailsDto> >();

            response.VerifySuccessResponse();
            response.Data.Should().BeEquivalentTo(GetWorkLogDetails(expected),
                                                  opt => opt.ExcludingMissingMembers()
                                                  .Excluding(e => e.WorkLogId)
                                                  .Excluding(e => e.UserId));
        }
        public async Task GetAllProjects_WhenRequestValid_ReturnsValidProjects()
        {
            var pagedRequest = new PagedRequest()
            {
                Page     = 1,
                PageSize = 6
            };
            var expected             = WorklogsDbSet.Get().Take(pagedRequest.PageSize).ToList();
            var mappedExpectedResult = expected.Select(GetWorkLogDto).ToList();

            var httpResponse = await GetAsync(WorkLogControllerRoutes.BaseRoute + "?" + pagedRequest.ToQueryString());

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiPagedResponse <WorkLogDto> >();

            response.Data.Should().BeEquivalentTo(mappedExpectedResult);
        }
        public async Task WorklogRepository_GetActivitiesWithDetailsByUserId_ReturnstActivitiesWithDetails()
        {
            var userId    = new Guid("57C10EE7-4108-4FD9-BCE9-5477FE8BFF9B");
            var projectId = new Guid("40B40CF5-46E1-4F03-8968-FA1F5DA459B3");

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);
            var expected          = WorklogsDbSet.Get().Where(e => e.UserId == userId)
                                    .Include(x => x.Issue)
                                    .ThenInclude(e => e.Project)
                                    .Where(e => e.Issue.ProjectId.Equals(projectId))
                                    .ToList();

            var actual = await workLogRepository.GetActivitiesWithDetailsByUserId(userId, projectId);

            Assert.That(actual.OrderBy(e => e.Id), Is.EqualTo(expected.OrderBy(e => e.Id))
                        .Using(EqualityComparers.WorkLogComparer));
        }
        public async Task WorklogRepository_GetAllPagedAsync_ReturnsAllResultsPaged()
        {
            var page = 1;
            var size = 6;

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var workLogRepository = new WorklogRepository(context);
            var expected          = WorklogsDbSet.Get().Take(size).ToList();

            var actual = await workLogRepository.GetAllPagedAsync(page, size);

            actual.EnsurePagedResult(WorklogsDbSet.Get().ToList().Count, size, page);
            var actualItems = actual.Items.ToList();

            actualItems.Should().BeEquivalentTo(expected, options => options
                                                .Excluding(e => e.TimeTrackingUser)
                                                .Excluding(e => e.Issue));
        }
        public async Task UpdateWorkLog_WhenModelNotValid_UpdatesWorkLogInDatabase()
        {
            var request = new WorkLogUpdateRequest()
            {
                ActivityType = ActivityType.Coding,
                StartDate    = DateTimeOffset.MaxValue.AddDays(-3333),
                TimeSpent    = TimeSpan.FromDays(2).Seconds,
                WorkLogId    = WorklogsDbSet.Get().First().Id
            };

            var httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLog, request);

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.CheckValidationException(2);

            request = new WorkLogUpdateRequest()
            {
                ActivityType = ActivityType.Coding,
                TimeSpent    = TimeSpan.FromDays(2).Seconds,
                WorkLogId    = WorklogsDbSet.Get().First().Id
            };

            httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLog, request);

            httpResponse.EnsureSuccessStatusCode();
            response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.CheckValidationException(3);

            request = new WorkLogUpdateRequest()
            {
                ActivityType = ActivityType.Coding,
                WorkLogId    = WorklogsDbSet.Get().First().Id
            };

            httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLog, request);

            httpResponse.EnsureSuccessStatusCode();
            response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.CheckValidationException(4);
        }
        public async Task IssueRepository_GetIssueWithDetails_ShouldReturnCorrectItem(string id)
        {
            var guidId = Guid.Parse(id);

            await using var context = new TimeTrackingDbContext(_dbOptions);
            var issueRepository   = new IssueRepository(context);
            var expected          = IssuesDbSet.Get().First(x => x.Id == guidId);
            var expectedMilestone = MilestonesDbSet.Get().First(e => e.Id == expected.MilestoneId);
            var expectedWorkLogs  = WorklogsDbSet.Get().Where(e => e.IssueId == expected.Id).OrderBy(e => e.Id).ToList();
            var expectedTimeTrackingUserReporter = UsersDbSet.Get().First(e => e.Id == expected.ReportedByUserId);
            var expectedTimeTrackingUserAssigned = UsersDbSet.Get().First(e => e.Id == expected.AssignedToUserId);

            var issue = await issueRepository.GetIssueWithDetails(guidId);

            Assert.That(issue, Is.EqualTo(expected).Using(EqualityComparers.IssueComparer));
            Assert.That(issue.Milestone, Is.EqualTo(expectedMilestone).Using(EqualityComparers.MilestoneComparer));
            Assert.That(issue.WorkLogs.ToList(), Is.EqualTo(expectedWorkLogs).Using(EqualityComparers.WorkLogComparer));
            Assert.That(issue.TimeTrackingUserReporter, Is.EqualTo(expectedTimeTrackingUserReporter).Using(EqualityComparers.TimeTrackingUserComparer));
            Assert.That(issue.TimeTrackingUserAssigned, Is.EqualTo(expectedTimeTrackingUserAssigned).Using(EqualityComparers.TimeTrackingUserComparer));
        }
        public async Task CreateWorkLog_WhenModelValid_CreatesWorkLogInDbAndReturnSuccessResponse()
        {
            var workLogCount = WorklogsDbSet.Get().Count();
            var request      = new WorkLogDto()
            {
                Description  = "description",
                StartDate    = DateTimeOffset.Now,
                IssueId      = IssuesDbSet.Get().First().Id,
                ActivityType = ActivityType.Research,
                TimeSpent    = TimeSpan.FromDays(2).Seconds,
            };

            var httpResponse = await PostAsync(WorkLogControllerRoutes.CreateWorkLog, request);

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.VerifySuccessResponse();
            await CheckWorkLogAddedToDatabase(response.Data, workLogCount + 1);

            response.VerifySuccessResponse();
            await ReSeedDatabase();
        }
        public async Task UpdateWorkLogStatus_WhenModelNotValid_ReturnsValidationErrors()
        {
            var claims = new Claim("roles", "TeamLead");
            var token  = GetJwtToken(new[] { claims });

            AddAuth(token);
            //description not set
            var request = new UpdateWorkLogStatusRequest
            {
                IsApproved = false,
                WorkLogId  = WorklogsDbSet.Get().First().Id
            };
            var httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLogStatus, request);

            var response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.CheckValidationException(2);

            //description and work log id not set
            request = new UpdateWorkLogStatusRequest
            {
                IsApproved = false
            };
            httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLogStatus, request);

            response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.CheckValidationException(3);

            //empty request
            request      = new UpdateWorkLogStatusRequest();
            httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLogStatus, request);

            response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.CheckValidationException(3);
        }
        public async Task UpdateWorkLogStatus_WhenModelValidFound_UpdatesWorkLog()
        {
            var claims = new Claim("roles", "TeamLead");
            var token  = GetJwtToken(new[] { claims });

            AddAuth(token);
            var request = new UpdateWorkLogStatusRequest
            {
                Description = "desc",
                IsApproved  = false,
                WorkLogId   = WorklogsDbSet.Get().First().Id
            };

            var httpResponse = await PostAsync(WorkLogControllerRoutes.UpdateWorkLogStatus, request);

            httpResponse.EnsureSuccessStatusCode();
            var response = await httpResponse.BodyAs <ApiResponse <WorkLogDto> >();

            response.VerifySuccessResponse();
            var workLog = await GetWorkLogFromDatabase(request.WorkLogId);

            workLog.IsApproved.Should().Be(request.IsApproved);
            await ReSeedDatabase();
        }