public void Should_Insert_And_Retrieve_Page_PageContents_Successfully()
{
var page = TestDataProvider.CreateNewPage();
var pageContents = new[]
{
TestDataProvider.CreateNewPageContent(null, page),
TestDataProvider.CreateNewPageContent(null, page),
TestDataProvider.CreateNewPageContent(null, page)
};
page.PageContents = pageContents;
var pageOptions = new[]
{
TestDataProvider.CreateNewPageOption(page),
TestDataProvider.CreateNewPageOption(page),
TestDataProvider.CreateNewPageOption(page)
};
page.Options = pageOptions;
SaveEntityAndRunAssertionsInTransaction(
page,
result =>
{
Assert.AreEqual(page, result);
Assert.AreEqual(pageContents.OrderBy(f => f.Id), result.PageContents.OrderBy(f => f.Id));
});
}
public void Should_Return_Highest_AccessLevel_Based_On_Role()
{
RunActionInTransaction(session =>
{
var accessRules = new List <AccessRule>(new[] {
new AccessRule {
Identity = "RoleA", AccessLevel = AccessLevel.Deny, IsForRole = true
},
new AccessRule {
Identity = "Admin", AccessLevel = AccessLevel.ReadWrite, IsForRole = true
},
new AccessRule {
Identity = "RoleB", AccessLevel = AccessLevel.Read, IsForRole = true
}
});
var page = TestDataProvider.CreateNewPage();
accessRules.ForEach(page.AddRule);
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
var service = CreateAccessControlService();
var principal = new GenericPrincipal(new GenericIdentity("John"), new[] { "Admin" });
var accessLevel = service.GetAccessLevel(page, principal);
Assert.AreEqual(AccessLevel.ReadWrite, accessLevel);
});
}
public void Should_CRUD_PageProperties_WithMasterPage_Successfully()
{
changingPageProepertiesCount = 0;
// Attach to events
Events.PageEvents.Instance.PageCreated += Instance_EntityCreated;
Events.PageEvents.Instance.PagePropertiesChanging += Instance_PagePropertiesChanging;
Events.PageEvents.Instance.PagePropertiesChanged += Instance_EntityUpdated;
Events.PageEvents.Instance.PageDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
masterPage = TestDataProvider.CreateNewPage();
masterPage.IsMasterPage = true;
layout = null;
region = TestDataProvider.CreateNewRegion();
session.SaveOrUpdate(region);
session.SaveOrUpdate(masterPage);
Run(session, api.Pages.Page.Properties.Post, api.Pages.Page.Properties.Get, api.Pages.Page.Properties.Put, api.Pages.Page.Properties.Delete);
});
Assert.AreEqual(1, changingPageProepertiesCount, "Page properties changing events fired count");
// Detach from events
Events.PageEvents.Instance.PageCreated -= Instance_EntityCreated;
Events.PageEvents.Instance.PagePropertiesChanging -= Instance_PagePropertiesChanging;
Events.PageEvents.Instance.PagePropertiesChanged -= Instance_EntityUpdated;
Events.PageEvents.Instance.PageDeleted -= Instance_EntityDeleted;
}
public void Should_Insert_HtmlWidget_To_Page_Successfully()
{
// Create html content
var widget = TestDataProvider.CreateNewHtmlContentWidget();
widget.Status = ContentStatus.Published;
var page = TestDataProvider.CreateNewPage();
var region = TestDataProvider.CreateNewRegion();
var pageContent = TestDataProvider.CreateNewPageContent(widget, page, region);
pageContent.Order = TestDataProvider.ProvideRandomNumber(1, 99999);
// Mock
var repository = new Mock <IRepository>();
repository
.Setup(r => r.AsProxy <Page>(It.IsAny <Guid>()))
.Returns(TestDataProvider.CreateNewPage());
repository
.Setup(r => r.AsProxy <Region>(It.IsAny <Guid>()))
.Returns(TestDataProvider.CreateNewRegion());
repository
.Setup(r => r.AsQueryable <PageContent>())
.Returns(new List <PageContent> {
pageContent
}.AsQueryable());
repository
.Setup(r => r.Save(It.IsAny <PageContent>()))
.Callback <PageContent>(pc =>
{
Assert.AreEqual(pc.Order, pageContent.Order + 1);
});
// Create command
var command = new InsertContentToPageCommand();
command.UnitOfWork = new Mock <IUnitOfWork>().Object;
command.Repository = repository.Object;
// Execute
var request = new InsertContentToPageRequest {
ContentId = widget.Id, PageId = page.Id, RegionId = region.Id
};
var result = command.Execute(request);
Assert.IsNotNull(result);
Assert.IsTrue(result);
}
public void Should_Get_Page_Access_Control()
{
RunActionInTransaction(session =>
{
var accessRule = TestDataProvider.CreateNewAccessRule();
var page = TestDataProvider.CreateNewPage();
page.AddRule(accessRule);
session.SaveOrUpdate(page);
session.Flush();
var accessControlService = CreateAccessControlService();
var level = accessControlService.GetAccessLevel(page, new GenericPrincipal(new GenericIdentity(accessRule.Identity), null));
Assert.AreEqual(accessRule.AccessLevel, level);
});
}
public void Should_CRUD_BlogPost_WithMasterPage_Successfully()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
isMarkdown = false;
isHtmlSet = true;
isNullUrl = false;
masterPage = TestDataProvider.CreateNewPage();
masterPage.IsMasterPage = true;
layout = null;
var htmlContent = TestDataProvider.CreateNewHtmlContent(100);
region = TestDataProvider.CreateNewRegion();
var contentRegion = new ContentRegion {
Content = htmlContent, Region = region
};
htmlContent.ContentRegions = new[] { contentRegion };
var pageContent = new PageContent {
Page = masterPage, Content = htmlContent, Region = region
};
session.SaveOrUpdate(region);
session.SaveOrUpdate(htmlContent);
session.SaveOrUpdate(masterPage);
session.SaveOrUpdate(pageContent);
Run(session, api.Blog.BlogPost.Properties.Post, api.Blog.BlogPost.Properties.Get, api.Blog.BlogPost.Properties.Put, api.Blog.BlogPost.Properties.Delete);
});
// Detach from events
Events.BlogEvents.Instance.BlogCreated -= Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
public void Should_Insert_And_Retrieve_Layout_Pages_Successfully()
{
var layout = TestDataProvider.CreateNewLayout();
var pages = new[]
{
TestDataProvider.CreateNewPage(layout),
TestDataProvider.CreateNewPage(layout),
TestDataProvider.CreateNewPage(layout)
};
layout.Pages = pages;
SaveEntityAndRunAssertionsInTransaction(
layout,
result =>
{
Assert.AreEqual(layout, result);
Assert.AreEqual(pages.OrderBy(f => f.Id), result.Pages.OrderBy(f => f.Id));
});
}
public void Should_Insert_And_Retrieve_Page_Successfully()
{
var entity = TestDataProvider.CreateNewPage();
RunEntityMapTestsInTransaction(entity);
}
public void Should_Insert_HtmlWidget_To_Page_Successfully()
{
// Create html content
var widget = TestDataProvider.CreateNewHtmlContentWidget();
widget.Status = ContentStatus.Published;
var page = TestDataProvider.CreateNewPage();
var region = TestDataProvider.CreateNewRegion();
var pageContent = TestDataProvider.CreateNewPageContent(widget, page, region);
pageContent.Order = TestDataProvider.ProvideRandomNumber(1, 99999);
pageContent.Id = Guid.NewGuid();
pageContent.Version = 10;
widget.Version = 20;
// Mock content Service
var contentService = new Mock <IContentService>();
contentService
.Setup(r => r.GetPageContentNextOrderNumber(It.IsAny <Guid>(), It.IsAny <Guid?>()))
.Returns(pageContent.Order + 1);
// Mock
var repository = new Mock <IRepository>();
repository
.Setup(r => r.AsProxy <Page>(It.IsAny <Guid>()))
.Returns(TestDataProvider.CreateNewPage());
repository
.Setup(r => r.AsProxy <Region>(It.IsAny <Guid>()))
.Returns(TestDataProvider.CreateNewRegion());
repository
.Setup(r => r.AsQueryable <PageContent>())
.Returns(new List <PageContent> {
pageContent
}.AsQueryable());
repository
.Setup(r => r.AsQueryable <Content>())
.Returns(new List <Content> {
widget
}.AsQueryable());
repository
.Setup(r => r.Save(It.IsAny <PageContent>()))
.Callback <PageContent>(pc =>
{
Assert.AreEqual(pc.Order, pageContent.Order + 1);
pc.Id = pageContent.Id;
pc.Version = pageContent.Version;
});
// Create command
var command = new InsertContentToPageCommand(contentService.Object,
new FakePageContentProjectionFactory(null, null),
new Mock <IWidgetService>().Object);
command.UnitOfWork = new Mock <IUnitOfWork>().Object;
command.Repository = repository.Object;
// Execute
var request = new InsertContentToPageRequest {
ContentId = widget.Id, PageId = page.Id, RegionId = region.Id
};
var result = command.Execute(request);
Assert.IsNotNull(result);
Assert.AreEqual(result.PageContentId, pageContent.Id);
Assert.AreEqual(result.PageId, page.Id);
Assert.AreEqual(result.ContentId, widget.Id);
Assert.AreEqual(result.ContentType, "html-widget");
Assert.AreEqual(result.ContentVersion, widget.Version);
Assert.AreEqual(result.PageContentVersion, pageContent.Version);
Assert.AreEqual(result.Title, widget.Name);
Assert.AreEqual(result.RegionId, region.Id);
Assert.AreEqual(result.DesirableStatus, widget.Status);
}
