public async Task SegmentControllerUpsertReturnsSuccessForUpdate(string mediaTypeName)
        {
            // Arrange
            var existingModel = A.Fake <RelatedCareersSegmentModel>();

            existingModel.SequenceNumber = 123;

            var modelToUpsert = A.Fake <RelatedCareersSegmentModel>();

            modelToUpsert.SequenceNumber = 124;

            var controller             = BuildSegmentController(mediaTypeName);
            var expectedUpsertResponse = HttpStatusCode.OK;

            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(existingModel);
            A.CallTo(() => FakeRelatedCareersSegmentService.UpsertAsync(A <RelatedCareersSegmentModel> .Ignored)).Returns(expectedUpsertResponse);

            // Act
            var result = await controller.Put(modelToUpsert).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeRelatedCareersSegmentService.UpsertAsync(A <RelatedCareersSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();
            var okResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)HttpStatusCode.OK, okResult.StatusCode);

            controller.Dispose();
        }
コード例 #2
0
        public async Task SegmentControllerGetBodyJsonReturnsSuccess(string mediaTypeName)
        {
            // Arrange
            var relatedCareersSegmentModel = new RelatedCareersSegmentModel {
                CanonicalName = "SomeCanonicalName"
            };
            var fakeRelatedCareerApiModel = new List <RelatedCareerApiModel>
            {
                new RelatedCareerApiModel
                {
                    Title = "SomeTitle1",
                    Url   = "someurl1",
                },
            };

            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(relatedCareersSegmentModel);
            A.CallTo(() => FakeMapper.Map <List <RelatedCareerApiModel> >(A <RelatedCareersSegmentModel> .Ignored)).Returns(fakeRelatedCareerApiModel);

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <List <RelatedCareerApiModel> >(A <RelatedCareersSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            var jsonResult = Assert.IsType <OkObjectResult>(result);

            Assert.IsAssignableFrom <List <RelatedCareerApiModel> >(jsonResult.Value);

            controller.Dispose();
        }
コード例 #3
0
        public async Task SegmentControllerGetBodyHtmlReturnsNoContentWhenNoData(string mediaTypeName)
        {
            // Arrange
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns((RelatedCareersSegmentModel)null);

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            var statusResult = Assert.IsType <NoContentResult>(result);

            Assert.Equal((int)HttpStatusCode.NoContent, statusResult.StatusCode);

            controller.Dispose();
        }
コード例 #4
0
        public async Task SegmentControllerGetBodyHtmlReturnsSuccess(string mediaTypeName)
        {
            // Arrange
            var expectedResult = A.Fake <RelatedCareersSegmentModel>();
            var controller     = BuildSegmentController(mediaTypeName);

            var model = new DocumentViewModel
            {
                DocumentId     = Guid.NewGuid(),
                CanonicalName  = "nurse",
                RoutePrefix    = "segment",
                SequenceNumber = 123,
                Data           = new DocumentDataViewModel
                {
                    LastReviewed   = DateTime.UtcNow,
                    RelatedCareers = new List <RelatedCareerDataViewModel>
                    {
                        new RelatedCareerDataViewModel
                        {
                            Id          = Guid.NewGuid(),
                            ProfileLink = "related-job-1",
                            Title       = "RelatedJobTitle1",
                        },
                    },
                },
            };

            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <RelatedCareersSegmentModel> .Ignored)).Returns(model);

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <RelatedCareersSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            var viewResult = Assert.IsType <ViewResult>(result);

            Assert.IsAssignableFrom <DocumentViewModel>(viewResult.ViewData.Model);

            controller.Dispose();
        }
コード例 #5
0
        public async Task SegmentControllerGetBodyPlainMediaTypeReturnsNotAcceptable(string mediaTypeName)
        {
            // Arrange
            var expectedResult = A.Fake <RelatedCareersSegmentModel>();
            var controller     = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <RelatedCareersSegmentModel> .Ignored)).Returns(A.Fake <DocumentViewModel>());

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            var viewResult = Assert.IsType <StatusCodeResult>(result);

            // Assert
            A.CallTo(() => FakeRelatedCareersSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <RelatedCareersSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            Assert.Equal((int)HttpStatusCode.NotAcceptable, viewResult.StatusCode);
            controller.Dispose();
        }