public async Task WebhooksServiceProcessContentAsyncForUpdateReturnsSuccess()
        {
            // Arrange
            const HttpStatusCode expectedResponse    = HttpStatusCode.OK;
            var expectedValidContentItemApiDataModel = BuildValidContentItemApiDataModel();
            var expectedValidContentItemModel        = BuildValidContentItemModel();
            var url     = new Uri("https://somewhere.com");
            var service = BuildWebhooksService();

            A.CallTo(() => FakeCmsApiService.GetItemAsync <SharedContentItemApiDataModel>(A <Uri> .Ignored)).Returns(expectedValidContentItemApiDataModel);
            A.CallTo(() => FakeMapper.Map <SharedContentItemModel>(A <SharedContentItemApiDataModel> .Ignored)).Returns(expectedValidContentItemModel);
            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedValidContentItemModel);
            A.CallTo(() => FakeSharedContentItemDocumentService.UpsertAsync(A <SharedContentItemModel> .Ignored)).Returns(HttpStatusCode.OK);

            // Act
            var result = await service.ProcessContentAsync(url).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCmsApiService.GetItemAsync <SharedContentItemApiDataModel>(A <Uri> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <SharedContentItemModel>(A <SharedContentItemApiDataModel> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeSharedContentItemDocumentService.UpsertAsync(A <SharedContentItemModel> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeSharedContentItemDocumentService.DeleteAsync(A <Guid> .Ignored)).MustNotHaveHappened();

            Assert.Equal(expectedResponse, result);
        }
Exemplo n.º 2
0
        public async Task PagesControllerDocumentHtmlReturnsSuccess(string mediaTypeName)
        {
            // Arrange
            var expectedResult = A.Fake <SharedContentItemModel>();

            using var controller = BuildPagesController(mediaTypeName);
            var expectedModel = new DocumentViewModel
            {
                Id            = Guid.NewGuid(),
                Title         = "A title",
                PartitionKey  = "partition-key",
                Url           = new Uri("https://somewhere.com", UriKind.Absolute),
                BodyViewModel = new BodyViewModel {
                    Body = new Microsoft.AspNetCore.Html.HtmlString("some content")
                },
                LastReviewed = DateTime.Now,
            };

            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <SharedContentItemModel> .Ignored)).Returns(expectedModel);

            // Act
            var result = await controller.Document(expectedModel.Id).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <SharedContentItemModel> .Ignored)).MustHaveHappenedOnceExactly();

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

            _ = Assert.IsAssignableFrom <DocumentViewModel>(viewResult.ViewData.Model);
            var model = viewResult.ViewData.Model as DocumentViewModel;

            Assert.Equal(expectedModel, model);
        }
Exemplo n.º 3
0
        public async Task PagesControllerDocumentReturnsNoContentWhenNoData(string mediaTypeName)
        {
            // Arrange
            SharedContentItemModel?expectedResult = null;

            using var controller = BuildPagesController(mediaTypeName);

            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedResult);

            // Act
            var result = await controller.Document(Guid.NewGuid()).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();

            var statusResult = Assert.IsType <NoContentResult>(result);

            A.Equals((int)HttpStatusCode.NoContent, statusResult.StatusCode);
        }
Exemplo n.º 4
0
        public async Task PagesControllerDocumentJsonReturnsSuccess(string mediaTypeName)
        {
            // Arrange
            var expectedResult = A.Fake <SharedContentItemModel>();

            using var controller = BuildPagesController(mediaTypeName);

            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <SharedContentItemModel> .Ignored)).Returns(A.Fake <DocumentViewModel>());

            // Act
            var result = await controller.Document(Guid.NewGuid()).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <SharedContentItemModel> .Ignored)).MustHaveHappenedOnceExactly();

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

            _ = Assert.IsAssignableFrom <DocumentViewModel>(jsonResult.Value);
        }
Exemplo n.º 5
0
        public async Task PagesControllerCallsContentPageServiceUsingPagesRouteForOkResult(string route, Guid documentId, string actionMethod)
        {
            // Arrange
            using var controller = BuildController(route);
            var expectedResult = new SharedContentItemModel()
            {
                Content = "<h1>A document</h1>"
            };
            var expectedResults = new List <SharedContentItemModel> {
                expectedResult
            };

            A.CallTo(() => FakeSharedContentItemDocumentService.GetAllAsync(A <string> .Ignored)).Returns(expectedResults);
            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedResult);

            // Act
            var result = await RunControllerAction(controller, documentId, actionMethod).ConfigureAwait(false);

            // Assert
            Assert.IsType <OkObjectResult>(result);
            A.CallTo(() => FakeSharedContentItemDocumentService.GetAllAsync(A <string> .Ignored)).MustHaveHappenedOnceOrLess();
            A.CallTo(() => FakeSharedContentItemDocumentService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceOrLess();
        }