예제 #1
0
            public async Task UpdateIssueAsync_Where_SaveChangesAsync_Fails_Should__return_a_IssueNotCreatedException_Test()
            {
                // Arrange

                const int id               = 1;
                var       expectedLog      = $"Updating Issue: {id} Failed!";
                var       issueToUpdateDto = new IssueForUpdateDto
                {
                    Id = 1, IssueDescription = "Test 1 updated", DateAdded = DateTimeOffset.Now
                };

                RepositoryWrapperMock
                .Setup(x => x.Issue.GetIssueByIdAsync(id))
                .ReturnsAsync(Issues[0]).Verifiable();

                RepositoryWrapperMock
                .Setup(x => x.SaveAsync())
                .Throws(new Exception("Save Changes Failed")).Verifiable();

                // Act

                await Assert.ThrowsAsync <IssueNotUpdatedException>(() => ServiceUnderTest.UpdateIssueAsync(issueToUpdateDto));

                // Assert

                LoggerMock.VerifyLog(LogLevel.Error, expectedLog);
                RepositoryWrapperMock.Verify(x => x.SaveAsync(), Times.Once);
                RepositoryWrapperMock
                .Verify(x => x.Issue.GetIssueByIdAsync(id), Times.Once);
            }
예제 #2
0
            public async Task UpdateIssueAsync_Should_Update_and_return_the_specified_Issue_Test()
            {
                // Arrange

                const int id = 1;
                var       issueToUpdateDto = new IssueForUpdateDto()
                {
                    Id = 1, IssueDescription = "Test 1 updated", DateAdded = DateTimeOffset.Now
                };

                RepositoryWrapperMock
                .Setup(x => x.Issue.GetIssueByIdAsync(id))
                .ReturnsAsync(Issues[0]).Verifiable();

                RepositoryWrapperMock
                .Setup(x => x.SaveAsync())
                .Returns(() => Task.Run(() => { return(1); })).Verifiable();

                // Act

                var result = await ServiceUnderTest.UpdateIssueAsync(issueToUpdateDto);

                // Assert

                result.Should().BeTrue();
                RepositoryWrapperMock.Verify(x => x.SaveAsync(), Times.Once);
                RepositoryWrapperMock
                .Verify(x => x.Issue.GetIssueByIdAsync(id), Times.Once);
            }
예제 #3
0
        public async Task <IActionResult> UpdateIssueAsync([FromBody] IssueForUpdateDto issue)
        {
            try
            {
                if (issue == null)
                {
                    _logger.LogError("Issue object sent from client is null");
                    return(BadRequest("Issue object sent from client is null."));
                }

                if (!ModelState.IsValid)
                {
                    _logger.LogError("Invalid issue object sent from client");
                    return(BadRequest(ModelState));
                }

                await _issueService.UpdateIssueAsync(issue);

                return(NoContent());
            }
            catch (IssueNotFoundException)
            {
                return(NotFound());
            }
            catch (Exception ex)
            {
                _logger.LogError("Something went wrong inside UpdateIssueAsync action: {Message}", ex.Message);
                return(StatusCode(500, "Internal server error"));
            }
        }
            public async Task UpdateIssueAsync_With_An_Exception_Should_Return_StatusCode_500_Test()
            {
                // Arrange

                var expectedIssue = new IssueForUpdateDto()
                {
                    Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
                };
                const string expectedLog   = "Something went wrong inside UpdateIssueAsync action: Some Error";
                const string expectedValue = "Internal server error";

                IssueServiceMock
                .Setup(x => x.UpdateIssueAsync(It.IsAny <IssueForUpdateDto>()))
                .ThrowsAsync(new Exception("Some Error"));

                // Act

                var result = await ControllerUnderTest.UpdateIssueAsync(expectedIssue);

                // Assert

                result.Should().BeOfType <ObjectResult>();
                LoggerMock.Invocations.Count.Should().Be(1);
                LoggerMock.Invocations[0].Arguments[2].ToString().Should().Contain(expectedLog);

                var content = (ObjectResult)result;

                content.StatusCode.Should().Be(500);
                content.Value.Should().Be(expectedValue);
            }
예제 #5
0
        public async Task UpdateIssueAsync(IssueForUpdateDto issue)
        {
            using var response = await _apiHelper.ApiClient.GetAsync("/api/GetAllIssuesAsync");

            if (response.IsSuccessStatusCode)
            {
                var result = await response.Content.ReadAsAsync <List <IssueDto> >();
            }
            else
            {
                throw new Exception(response.ReasonPhrase);
            }
        }
예제 #6
0
        public async Task <bool> UpdateIssueAsync(IssueForUpdateDto issue)
        {
            var issueEntity = await EnforceIssueExistenceAsync(issue.Id);

            _mapper.Map(issue, issueEntity);

            _repositoryWrapper.Issue.UpdateIssue(issueEntity);

            try
            {
                await _repositoryWrapper.SaveAsync();

                return(true);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Updating Issue: {Id} Failed!", issue.Id);
                throw new IssueNotUpdatedException(issueEntity);
            }
        }
            public async Task UpdateIssueAsync_Should_return_BadRequestResult()
            {
                // Arrange

                var issue = new IssueForUpdateDto()
                {
                    Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
                };

                ControllerUnderTest.ModelState.AddModelError("Id", "Some error");

                // Act

                var result = await ControllerUnderTest.UpdateIssueAsync(issue);

                // Assert

                var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);

                Assert.IsType <SerializableError>(badRequestResult.Value);
            }
            public async Task UpdateIssueAsync_Should_return_NoContentResult_Test()
            {
                // Arrange

                var expectedIssue = new IssueForUpdateDto()
                {
                    Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
                };

                IssueServiceMock
                .Setup(x => x.UpdateIssueAsync(expectedIssue))
                .ReturnsAsync(true);

                // Act

                var result = await ControllerUnderTest.UpdateIssueAsync(expectedIssue);

                // Assert

                result.Should().BeOfType <NoContentResult>();
            }
예제 #9
0
            public async Task UpdateIssueAsync_With_A_NonExisting_Issue_Should_Return_IssueNotUpdatedException_Test()
            {
                // Arrange

                var issueToUpdateDto = new IssueForUpdateDto()
                {
                    Id = 1, IssueDescription = "Test 1 updated"
                };

                RepositoryWrapperMock
                .Setup(x => x.Issue.GetIssueByIdAsync(issueToUpdateDto.Id))
                .ReturnsAsync(default(Issue)).Verifiable();

                // Act

                await Assert.ThrowsAsync <IssueNotFoundException>(() => ServiceUnderTest.UpdateIssueAsync(issueToUpdateDto));

                // Assert

                RepositoryWrapperMock
                .Verify(x => x.Issue.GetIssueByIdAsync(issueToUpdateDto.Id), Times.Once);
            }
            public async Task UpdateIssueAsync_Should_return_NotFoundResult_when_IssueNotFoundException_is_thrown()
            {
                // Arrange

                var unExpectedIssue = new IssueForUpdateDto()
                {
                    Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
                };
                var expectedResult = new Issue {
                    Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
                };

                IssueServiceMock
                .Setup(x => x.UpdateIssueAsync(unExpectedIssue))
                .ThrowsAsync(new IssueNotFoundException(expectedResult));

                // Act

                var result = await ControllerUnderTest.UpdateIssueAsync(unExpectedIssue);

                // Assert

                Assert.IsType <NotFoundResult>(result);
            }
예제 #11
0
        public async Task <IActionResult> UpdateIssueForProject(Guid projectId, Guid issueId, IssueForUpdateDto issueForUpdate)
        {
            if (issueForUpdate.DueDate != null && issueForUpdate.DueDate < DateTime.Today)
            {
                return(BadRequest("Due Date cannot be before today"));
            }

            var projectFromRepo = await _repository.Project.GetProjectWithUsers(projectId);

            if (projectFromRepo == null)
            {
                return(BadRequest("Project doesn't exist"));
            }

            var issueFromRepo = await _repository.Issue.GetIssue(issueId);

            if (issueFromRepo == null)
            {
                return(BadRequest("Issue doesn't exist"));
            }

            if (issueForUpdate.AssigneeEmail != null)
            {
                var user = await _repository.User.GetUser(issueForUpdate.AssigneeEmail);

                if (user == null)
                {
                    return(BadRequest("User doesn't exist"));
                }

                var userOnProject = projectFromRepo.Users.FirstOrDefault(up => up.UserId.Equals(user.Id));
                if (userOnProject == null)
                {
                    return(BadRequest("User not on project"));
                }

                issueFromRepo.AssigneeId = user.Id;
            }

            Severity       severity;
            Classification classify;
            Stage          status;

            Enum.TryParse(issueForUpdate.Severity, out severity);
            Enum.TryParse(issueForUpdate.Classification, out classify);
            Enum.TryParse(issueForUpdate.Status, out status);

            _mapper.Map(issueForUpdate, issueFromRepo);

            issueFromRepo.Severity       = severity;
            issueFromRepo.Classification = classify;
            issueFromRepo.Status         = status;

            _repository.Issue.UpdateIssue(issueFromRepo);
            var updateIssue = await _repository.SaveAsync();

            if (!updateIssue)
            {
                throw new Exception("Failed to update issue for project");
            }

            return(NoContent());
        }