Esempio n. 1
0
        public async Task AddIterationToWorkspaceReleaseValidModelTest()
        {
            var workspaceId = Guid.NewGuid();
            var workspaceReleaseIterationDto = new CreateWorkspaceReleaseIterationDto();
            var releaseId = Guid.NewGuid();
            var release   = new Release();

            _workspaceService.Setup(service => service.AddIterationToWorkspaceRelease(workspaceId, releaseId, workspaceReleaseIterationDto)).ReturnsAsync(release);

            var response = await _controller.AddIterationToWorkspaceRelease(workspaceId, releaseId, workspaceReleaseIterationDto);

            Assert.NotNull(response);
            Assert.IsType <ApiResponse>(response);
            Assert.Equal("Iteration added to release successfully", response.Message);
            Assert.Equal((int)HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(release, response.Result);
        }
Esempio n. 2
0
        public async Task AddIterationToWorkspaceReleaseWhenReleaseNullTest()
        {
            var workspaceId        = Guid.NewGuid();
            var releaseId          = Guid.NewGuid();
            var createIterationDto = new CreateWorkspaceReleaseIterationDto();
            var workspace          = new Workspace {
                Releases = new List <Release> {
                    new Release {
                        Guid = Guid.NewGuid()
                    }
                }
            };

            _workspaceRepo.Setup(repo => repo.GetWorkspaceById(workspaceId)).ReturnsAsync(workspace);

            var release = await _service.AddIterationToWorkspaceRelease(workspaceId, releaseId, createIterationDto);

            Assert.Null(release);
        }
        public async Task <Release> AddIterationToWorkspaceRelease(Guid workspaceId, Guid releaseId, CreateWorkspaceReleaseIterationDto iterationDto)
        {
            var workspaceFromRepo = await _workspaceRepo.GetWorkspaceById(workspaceId);

            if (workspaceFromRepo == null)
            {
                return(null);
            }

            var newWorkspaceReleaseIteration = _mapper.Map <Iteration>(iterationDto);

            newWorkspaceReleaseIteration.Guid = Guid.NewGuid();

            var releaseToAddIteration = workspaceFromRepo.Releases.FirstOrDefault(x => x.Guid == releaseId);

            if (releaseToAddIteration == null)
            {
                return(null);
            }

            if (releaseToAddIteration.Iterations.IsNullOrEmpty())
            {
                releaseToAddIteration.Iterations = new List <Iteration>();
            }

            releaseToAddIteration.Iterations.Add(newWorkspaceReleaseIteration);

            await _workspaceRepo.CreateOrUpdateWorkspace(workspaceFromRepo);

            return(releaseToAddIteration);
        }
Esempio n. 4
0
        public async Task <ApiResponse> AddIterationToWorkspaceRelease(Guid workspaceId, Guid releaseId, [FromBody] CreateWorkspaceReleaseIterationDto workspaceReleaseIterationDto)
        {
            if (ModelState.IsValid)
            {
                var release = await _workspaceService.AddIterationToWorkspaceRelease(workspaceId, releaseId, workspaceReleaseIterationDto);

                return(new ApiResponse("Iteration added to release successfully", release, (int)HttpStatusCode.OK));
            }
            else
            {
                throw new ApiException(ModelState.AllErrors());
            }
        }