public async Task SitemapControllerSitemapReturnsSuccess()
{
// Arrange
const int resultsCount = 3;
var expectedResults = A.CollectionOfFake <ContentPageModel>(resultsCount);
var controller = BuildSitemapController();
expectedResults[0].IncludeInSitemap = true;
expectedResults[0].CanonicalName = "help";
expectedResults[1].IncludeInSitemap = false;
expectedResults[1].CanonicalName = "not-in-sitemap";
expectedResults[2].IncludeInSitemap = true;
expectedResults[2].CanonicalName = "in-sitemap";
A.CallTo(() => FakeContentPageService.GetAllAsync(A <string> .Ignored)).Returns(expectedResults);
// Act
var result = await controller.Sitemap(PagesController.CategoryNameForHelp).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync(A <string> .Ignored)).MustHaveHappenedOnceExactly();
var contentResult = Assert.IsType <ContentResult>(result);
contentResult.ContentType.Should().Be(MediaTypeNames.Application.Xml);
controller.Dispose();
}
public async Task WebhookContentProcessorProcessContentAsyncForUpdateReturnsNoContent()
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.NoContent;
var expectedValidApiContentModel = BuildValidPagesApiContentModel();
ContentPageModel?expectedValidContentPageModel = default;
var url = new Uri("https://somewhere.com");
var service = BuildWebhookContentProcessor();
A.CallTo(() => FakeCmsApiService.GetItemAsync <CmsApiDataModel>(A <Uri> .Ignored)).Returns(expectedValidApiContentModel);
A.CallTo(() => FakeMapper.Map <ContentPageModel?>(A <CmsApiDataModel> .Ignored)).Returns(expectedValidContentPageModel);
// Act
var result = await service.ProcessContentAsync(url, ContentIdForCreate).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeCmsApiService.GetItemAsync <CmsApiDataModel>(A <Uri> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map <ContentPageModel>(A <CmsApiDataModel> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.UpdateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.CreateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventGridService.CompareAndSendEventAsync(A <ContentPageModel> .Ignored, A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.DeleteAsync(A <Guid> .Ignored)).MustNotHaveHappened();
Assert.Equal(expectedResponse, result);
}
public async Task SitemapControllerSitemapReturnsSuccess()
{
// Arrange
const int resultsCount = 3;
var expectedResults = A.CollectionOfFake <JobCategory>(resultsCount);
var controller = BuildSitemapController();
expectedResults[0].CanonicalName = "default-article";
expectedResults[1].CanonicalName = "yes-in-sitemap";
expectedResults[2].CanonicalName = "in-sitemap";
A.CallTo(() => FakeContentPageService.GetAllAsync()).Returns(expectedResults);
// Act
var result = await controller.Sitemap().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync()).MustHaveHappenedOnceExactly();
var contentResult = Assert.IsType <ContentResult>(result);
contentResult.ContentType.Should().Be(MediaTypeNames.Application.Xml);
controller.Dispose();
}
public async Task PagesControllerBreadcrumbHtmlReturnsSuccessForDefaultArticleName(string mediaTypeName)
{
// Arrange
const string category = "a-category";
const string article = DefaultHelpArticleName;
var expectedResult = A.Fake <ContentPageModel>();
var controller = BuildPagesController(mediaTypeName);
expectedResult.CanonicalName = article;
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
// Act
var result = await controller.Breadcrumb(category, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <BreadcrumbViewModel>(viewResult.ViewData.Model);
model.Paths.Count.Should().BeGreaterThan(0);
controller.Dispose();
}
public async Task PagesControllerHeadWithNullArticleHtmlReturnsSuccess(string mediaTypeName)
{
// Arrange
const string category = "a-category";
const string article = null;
var expectedResult = A.Fake<ContentPageModel>();
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByNameAsync(A<string>.Ignored, A<string>.Ignored)).Returns(expectedResult);
A.CallTo(() => FakeMapper.Map(A<ContentPageModel>.Ignored, A<HeadViewModel>.Ignored)).Returns(A.Fake<HeadViewModel>());
// Act
var result = await controller.Head(category, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A<string>.Ignored, A<string>.Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map(A<ContentPageModel>.Ignored, A<HeadViewModel>.Ignored)).MustHaveHappenedOnceExactly();
var viewResult = Assert.IsType<ViewResult>(result);
var model = Assert.IsAssignableFrom<HeadViewModel>(viewResult.ViewData.Model);
model.CanonicalUrl.Should().NotBeNullOrWhiteSpace();
controller.Dispose();
}
public async Task PagesControllerPutReturnsAlreadyReportedForUpdate(string mediaTypeName)
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.AlreadyReported;
var existingModel = A.Fake <ContentPageModel>();
existingModel.SequenceNumber = 123;
var modelToUpsert = A.Fake <ContentPageModel>();
modelToUpsert.SequenceNumber = existingModel.SequenceNumber - 1;
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored)).Returns(existingModel);
// Act
var result = await controller.Update(modelToUpsert).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
var statusCodeResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal((int)expectedResponse, statusCodeResult.StatusCode);
controller.Dispose();
}
public async Task WebhookContentProcessorDeletePageLocationAsyncForCreateReturnsSuccess()
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.OK;
var exptectedGuidList = new List <Guid> {
PageLocationIdForCreate, Guid.NewGuid()
};
var expectedValidContentPageModel = BuildValidContentPageModel();
var service = BuildWebhookContentProcessor();
A.CallTo(() => FakeContentCacheService.GetContentIdsContainingContentItemId(A <Guid> .Ignored)).Returns(exptectedGuidList);
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedValidContentPageModel);
A.CallTo(() => FakeEventMessageService.UpdateAsync(A <ContentPageModel> .Ignored)).Returns(HttpStatusCode.OK);
A.CallTo(() => FakeContentCacheService.RemoveContentItem(A <Guid> .Ignored, A <Guid> .Ignored));
// Act
var result = await service.DeleteContentItemAsync(PageLocationIdForDelete).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentCacheService.GetContentIdsContainingContentItemId(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceOrMore();
A.CallTo(() => FakeEventMessageService.UpdateAsync(A <ContentPageModel> .Ignored)).MustHaveHappenedOnceOrMore();
A.CallTo(() => FakeEventMessageService.CreateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.DeleteAsync(A <Guid> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeContentCacheService.RemoveContentItem(A <Guid> .Ignored, A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResponse, result);
}
public async Task WebhookContentProcessorProcessContentItemAsyncReturnsNoContentWhenNoContentIds()
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.NoContent;
var exptectedEmptyGuidList = new List <Guid>();
var url = new Uri("https://somewhere.com");
var service = BuildWebhookContentProcessor();
A.CallTo(() => FakeContentCacheService.GetContentIdsContainingContentItemId(A <Guid> .Ignored)).Returns(exptectedEmptyGuidList);
// Act
var result = await service.ProcessContentItemAsync(url, ContentItemIdForUpdate).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentCacheService.GetContentIdsContainingContentItemId(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakePageLocatonUpdater.FindAndUpdateAsync(A <Uri> .Ignored, A <Guid> .Ignored, A <List <PageLocationModel> > .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeContentItemUpdater.FindAndUpdateAsync(A <Uri> .Ignored, A <Guid> .Ignored, A <List <ContentItemModel> > .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.UpdateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.CreateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.DeleteAsync(A <Guid> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventGridService.CompareAndSendEventAsync(A <ContentPageModel> .Ignored, A <ContentPageModel> .Ignored)).MustNotHaveHappened();
Assert.Equal(expectedResponse, result);
}
public async void PagesControllerBodyWithNullArticleHtmlReturnsSuccess(string mediaTypeName)
{
// Arrange
const string article = null;
var expectedResult = new ContentPageModel()
{
Content = "<h1>A document ({0})</h1>"
};
var controller = BuildPagesController(mediaTypeName);
expectedResult.CanonicalName = article;
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
A.CallTo(() => FakeMapper.Map(A <ContentPageModel> .Ignored, A <BodyViewModel> .Ignored)).Returns(A.Fake <BodyViewModel>());
// Act
var result = await controller.Body(PagesController.CategoryNameForHelp, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map(A <ContentPageModel> .Ignored, A <BodyViewModel> .Ignored)).MustHaveHappenedOnceExactly();
var viewResult = Assert.IsType <ViewResult>(result);
_ = Assert.IsAssignableFrom <BodyViewModel>(viewResult.ViewData.Model);
controller.Dispose();
}
public async void PagesControllerBodyReturnsNotAcceptable(string mediaTypeName)
{
// Arrange
const string article = "an-article-name";
var expectedResult = new ContentPageModel()
{
Content = "<h1>A document ({0})</h1>"
};
var controller = BuildPagesController(mediaTypeName);
expectedResult.CanonicalName = article;
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
A.CallTo(() => FakeMapper.Map(A <ContentPageModel> .Ignored, A <BodyViewModel> .Ignored)).Returns(A.Fake <BodyViewModel>());
// Act
var result = await controller.Body(PagesController.CategoryNameForAlert, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map(A <ContentPageModel> .Ignored, A <BodyViewModel> .Ignored)).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <StatusCodeResult>(result);
A.Equals((int)HttpStatusCode.NotAcceptable, statusResult.StatusCode);
controller.Dispose();
}
public async void PagesControllerBodyHtmlReturnsRedirectWhenAlternateArticleExistsForDefaultArticleName(string mediaTypeName)
{
// Arrange
const string article = null;
ContentPageModel expectedResult = null;
var expectedAlternativeResult = A.Fake <ContentPageModel>();
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
A.CallTo(() => FakeContentPageService.GetByAlternativeNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedAlternativeResult);
// Act
var result = await controller.Body(PagesController.CategoryNameForAlert, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeContentPageService.GetByAlternativeNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <RedirectResult>(result);
statusResult.Url.Should().NotBeNullOrWhiteSpace();
A.Equals(true, statusResult.Permanent);
controller.Dispose();
}
public async Task HealthControllerViewJsonReturnsSuccess(string mediaTypeName)
{
// Arrange
bool expectedResult = true;
using var controller = BuildHealthController(mediaTypeName);
A.CallTo(() => FakeContentPageService.PingAsync()).Returns(expectedResult);
// Act
var result = await controller.HealthView().ConfigureAwait(false);
// Assert
var jsonResult = Assert.IsType <OkObjectResult>(result);
_ = Assert.IsAssignableFrom <IList <HealthItemViewModel> >(jsonResult.Value);
}
public async Task HealthControllerHealthViewReturnsNotAcceptable(string mediaTypeName)
{
// Arrange
bool expectedResult = true;
using var controller = BuildHealthController(mediaTypeName);
A.CallTo(() => FakeContentPageService.PingAsync()).Returns(expectedResult);
// Act
var result = await controller.HealthView().ConfigureAwait(false);
// Assert
var statusResult = Assert.IsType <StatusCodeResult>(result);
A.Equals((int)HttpStatusCode.NotAcceptable, statusResult.StatusCode);
}
public async Task HealthControllerViewHtmlReturnsSuccess(string mediaTypeName)
{
// Arrange
bool expectedResult = true;
using var controller = BuildHealthController(mediaTypeName);
A.CallTo(() => FakeContentPageService.PingAsync()).Returns(expectedResult);
// Act
var result = await controller.HealthView().ConfigureAwait(false);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
_ = Assert.IsAssignableFrom <HealthViewModel>(viewResult.ViewData.Model);
}
public async Task SitemapControllerViewReturnsSuccessWhenNoData()
{
// Arrange
const int resultsCount = 0;
var expectedResults = A.CollectionOfFake <ContentPageModel>(resultsCount);
var controller = BuildSitemapController();
A.CallTo(() => FakeContentPageService.GetAllAsync(A <string> .Ignored)).Returns(expectedResults);
// Act
var result = await controller.SitemapView().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync(A <string> .Ignored)).MustHaveHappenedOnceExactly();
_ = Assert.IsType <NoContentResult>(result);
controller.Dispose();
}
public async Task HealthControllerHealthReturnsServiceUnavailableWhenUnhealthy()
{
// Arrange
bool expectedResult = false;
using var controller = BuildHealthController(MediaTypeNames.Application.Json);
A.CallTo(() => FakeContentPageService.PingAsync()).Returns(expectedResult);
// Act
var result = await controller.Health().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.PingAsync()).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <StatusCodeResult>(result);
A.Equals((int)HttpStatusCode.ServiceUnavailable, statusResult.StatusCode);
}
public async Task HealthControllerHealthReturnsServiceUnavailableWhenException()
{
// Arrange
var controller = BuildHealthController();
A.CallTo(() => FakeContentPageService.PingAsync()).Throws <Exception>();
// Act
var result = await controller.Health().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.PingAsync()).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <StatusCodeResult>(result);
A.Equals((int)HttpStatusCode.ServiceUnavailable, statusResult.StatusCode);
controller.Dispose();
}
public async Task PagesControllerDeleteReturnsNotFound(string mediaTypeName)
{
// Arrange
Guid documentId = Guid.NewGuid();
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.DeleteAsync(A <Guid> .Ignored)).Returns(false);
// Act
var result = await controller.Delete(documentId).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.DeleteAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <NotFoundResult>(result);
A.Equals((int)HttpStatusCode.NotFound, statusResult.StatusCode);
controller.Dispose();
}
public async Task PagesControllerPostReturnsSuccessForCreate(string mediaTypeName)
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.Created;
var contentPageModel = A.Fake <ContentPageModel>();
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored)).Returns((ContentPageModel)null);
A.CallTo(() => FakeContentPageService.UpsertAsync(A <ContentPageModel> .Ignored)).Returns(expectedResponse);
// Act
var result = await controller.Create(contentPageModel).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.UpsertAsync(A <ContentPageModel> .Ignored)).MustHaveHappenedOnceExactly();
var okResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal((int)expectedResponse, okResult.StatusCode);
controller.Dispose();
}
public async Task WebhookContentProcessorDeleteContentAsyncForCreateReturnsNoContent()
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.NoContent;
ContentPageModel? nullContentPageModel = null;
var service = BuildWebhookContentProcessor();
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(nullContentPageModel);
A.CallTo(() => FakeEventMessageService.DeleteAsync(A <Guid> .Ignored)).Returns(expectedResponse);
A.CallTo(() => FakeContentCacheService.Remove(A <Guid> .Ignored));
// Act
var result = await service.DeleteContentAsync(ContentIdForDelete).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeEventMessageService.DeleteAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeEventGridService.SendEventAsync(A <WebhookCacheOperation> .Ignored, A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeContentCacheService.Remove(A <Guid> .Ignored)).MustNotHaveHappened();
Assert.Equal(expectedResponse, result);
}
public async Task PagesControllerDocumentJsonReturnsNoContentWhenNoData(string mediaTypeName)
{
// Arrange
const string category = "a-category";
const string article = "an-article-name";
ContentPageModel expectedResult = null;
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
// Act
var result = await controller.Document(category, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <NoContentResult>(result);
A.Equals((int)HttpStatusCode.NoContent, statusResult.StatusCode);
controller.Dispose();
}
public async Task WebhookContentProcessorDeleteContentItemAsyncForUpdateReturnsNoContent()
{
// Arrange
const HttpStatusCode expectedResponse = HttpStatusCode.NoContent;
var exptectedEmptyGuidList = new List <Guid>();
var service = BuildWebhookContentProcessor();
A.CallTo(() => FakeContentCacheService.GetContentIdsContainingContentItemId(A <Guid> .Ignored)).Returns(exptectedEmptyGuidList);
// Act
var result = await service.DeleteContentItemAsync(ContentItemIdForDelete).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentCacheService.GetContentIdsContainingContentItemId(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.UpdateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.CreateAsync(A <ContentPageModel> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeEventMessageService.DeleteAsync(A <Guid> .Ignored)).MustNotHaveHappened();
A.CallTo(() => FakeContentCacheService.RemoveContentItem(A <Guid> .Ignored, A <Guid> .Ignored)).MustNotHaveHappened();
Assert.Equal(expectedResponse, result);
}
public async Task HealthControllerHealthReturnsSuccessWhenHealthy()
{
// Arrange
bool expectedResult = true;
using var controller = BuildHealthController(MediaTypeNames.Application.Json);
A.CallTo(() => FakeContentPageService.PingAsync()).Returns(expectedResult);
// Act
var result = await controller.Health().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.PingAsync()).MustHaveHappenedOnceExactly();
var jsonResult = Assert.IsType <OkObjectResult>(result);
var models = Assert.IsAssignableFrom <List <HealthItemViewModel> >(jsonResult.Value);
models.Count.Should().BeGreaterThan(0);
models.First().Service.Should().NotBeNullOrWhiteSpace();
models.First().Message.Should().NotBeNullOrWhiteSpace();
}
public async Task SitemapControllerViewReturnsSuccess()
{
// Arrange
const int resultsCount = 5;
var expectedResults = A.CollectionOfFake <ContentPageModel>(resultsCount);
var controller = BuildSitemapController();
expectedResults[0].IncludeInSitemap = true;
expectedResults[0].PageLocation = "/default-location";
expectedResults[0].CanonicalName = "default-article";
expectedResults[0].IsDefaultForPageLocation = true;
expectedResults[1].IncludeInSitemap = false;
expectedResults[1].PageLocation = "/default-location";
expectedResults[1].CanonicalName = "not-in-sitemap";
expectedResults[2].IncludeInSitemap = true;
expectedResults[2].PageLocation = "/default-location";
expectedResults[2].CanonicalName = "in-sitemap";
expectedResults[3].IncludeInSitemap = true;
expectedResults[3].PageLocation = "/";
expectedResults[3].CanonicalName = "slash-location";
expectedResults[4].IncludeInSitemap = true;
expectedResults[4].PageLocation = string.Empty;
expectedResults[4].CanonicalName = "empty-location";
A.CallTo(() => FakeContentPageService.GetAllAsync(A <string> .Ignored)).Returns(expectedResults);
// Act
var result = await controller.SitemapView().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync(A <string> .Ignored)).MustHaveHappenedOnceExactly();
var contentResult = Assert.IsType <ContentResult>(result);
contentResult.ContentType.Should().Be(MediaTypeNames.Application.Xml);
controller.Dispose();
}
public async void PagesControllerIndexReturnsNotAcceptable(string mediaTypeName)
{
// Arrange
const int resultsCount = 0;
IEnumerable <ContentPageModel> expectedResults = null;
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetAllAsync()).Returns(expectedResults);
A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <ContentPageModel> .Ignored)).Returns(A.Fake <IndexDocumentViewModel>());
// Act
var result = await controller.Index().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync()).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <ContentPageModel> .Ignored)).MustHaveHappened(resultsCount, Times.Exactly);
var statusResult = Assert.IsType <StatusCodeResult>(result);
A.Equals((int)HttpStatusCode.NotAcceptable, statusResult.StatusCode);
controller.Dispose();
}
public async Task PagesControllerDocumentJsonReturnsSuccess(string mediaTypeName)
{
// Arrange
const string category = "a-category";
const string article = "an-article-name";
var expectedResult = A.Fake <ContentPageModel>();
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <ContentPageModel> .Ignored)).Returns(A.Fake <DocumentViewModel>());
// Act
var result = await controller.Document(category, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <ContentPageModel> .Ignored)).MustHaveHappenedOnceExactly();
var jsonResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <DocumentViewModel>(jsonResult.Value);
controller.Dispose();
}
public async Task PagesControllerBreadcrumbJsonReturnsSuccessWhenNoData(string mediaTypeName)
{
// Arrange
const string category = "a-category";
const string article = "an-article-name";
ContentPageModel expectedResult = null;
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
// Act
var result = await controller.Breadcrumb(category, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
var jsonResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <BreadcrumbViewModel>(jsonResult.Value);
model.Paths.Count.Should().BeGreaterThan(0);
controller.Dispose();
}
public async Task PagesControllerBreadcrumbReturnsNotAcceptable(string mediaTypeName)
{
// Arrange
const string category = "a-category";
const string article = "an-article-name";
var expectedResult = A.Fake <ContentPageModel>();
var controller = BuildPagesController(mediaTypeName);
expectedResult.CanonicalName = article;
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).Returns(expectedResult);
// Act
var result = await controller.Breadcrumb(category, article).ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetByNameAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
var statusResult = Assert.IsType <StatusCodeResult>(result);
A.Equals((int)HttpStatusCode.NotAcceptable, statusResult.StatusCode);
controller.Dispose();
}
public async void PagesControllerIndexHtmlReturnsSuccess(string mediaTypeName)
{
// Arrange
const int resultsCount = 2;
var expectedResults = A.CollectionOfFake <ContentPageModel>(resultsCount);
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetAllAsync()).Returns(expectedResults);
A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <ContentPageModel> .Ignored)).Returns(A.Fake <IndexDocumentViewModel>());
// Act
var result = await controller.Index().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync()).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <ContentPageModel> .Ignored)).MustHaveHappened(resultsCount, Times.Exactly);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IndexViewModel>(viewResult.ViewData.Model);
A.Equals(resultsCount, model.Documents.Count());
controller.Dispose();
}
public async void PagesControllerIndexJsonReturnsSuccessWhenNoData(string mediaTypeName)
{
// Arrange
const int resultsCount = 0;
IEnumerable <ContentPageModel> expectedResults = null;
var controller = BuildPagesController(mediaTypeName);
A.CallTo(() => FakeContentPageService.GetAllAsync()).Returns(expectedResults);
A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <ContentPageModel> .Ignored)).Returns(A.Fake <IndexDocumentViewModel>());
// Act
var result = await controller.Index().ConfigureAwait(false);
// Assert
A.CallTo(() => FakeContentPageService.GetAllAsync()).MustHaveHappenedOnceExactly();
A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <ContentPageModel> .Ignored)).MustHaveHappened(resultsCount, Times.Exactly);
var jsonResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <IndexViewModel>(jsonResult.Value);
A.Equals(null, model.Documents);
controller.Dispose();
}
