public void Should_Delete_Page_Content()
{
RunActionInTransaction(session =>
{
// Create content
var content = TestDataProvider.CreateNewHtmlContent();
var pageContent = TestDataProvider.CreateNewPageContent(content);
session.SaveOrUpdate(pageContent);
session.Flush();
session.Clear();
// Delete page content
var request = new DeletePageContentCommandRequest
{
PageContentId = pageContent.Id,
PageContentVersion = pageContent.Version,
ContentVersion = content.Version
};
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var securityService = new Mock <ISecurityService>().Object;
var optionService = new Mock <IOptionService>().Object;
var childContentService = new Mock <IChildContentService>().Object;
var contentService = new DefaultContentService(securityService, repository, optionService, childContentService);
var command = new DeletePageContentCommand(contentService);
command.UnitOfWork = unitOfWork;
command.Repository = repository;
var result = command.Execute(request);
Assert.IsTrue(result);
});
}
private void CreateContents(ISession session, bool saveDraft, out BetterCms.Module.Pages.Models.HtmlContent parent, out BetterCms.Module.Pages.Models.HtmlContent draft)
{
parent = TestDataProvider.CreateNewHtmlContent();
parent.Status = ContentStatus.Published;
parent.PublishedOn = DateTime.Now;
parent.PublishedByUser = "******";
session.SaveOrUpdate(parent);
if (saveDraft)
{
draft = TestDataProvider.CreateNewHtmlContent();
draft.Status = ContentStatus.Draft;
draft.PublishedOn = null;
draft.PublishedByUser = null;
draft.Original = parent;
session.SaveOrUpdate(draft);
}
else
{
draft = null;
}
session.Flush();
session.Clear();
}
public void Should_By_Xml_And_Binary_Serializable()
{
var pageContent = TestDataProvider.CreateNewPageContent();
pageContent.Content = TestDataProvider.CreateNewHtmlContent();
pageContent.Options = new[]
{
TestDataProvider.CreateNewPageContentOption(pageContent),
TestDataProvider.CreateNewPageContentOption(pageContent),
TestDataProvider.CreateNewPageContentOption(pageContent)
};
var cmsConfiguration = new Mock <ICmsConfiguration>();
var optionService = new DefaultOptionService(null, new HttpRuntimeCacheService(), cmsConfiguration.Object);
var optionValues = optionService.GetMergedOptionValues(pageContent.Options, null);
var original = new PageContentProjection(
pageContent, pageContent.Content, new HtmlContentAccessor((HtmlContent)pageContent.Content, optionValues));
RunSerializationAndDeserialization(original,
projection =>
{
Assert.AreEqual(original.ContentId, projection.ContentId);
Assert.AreEqual(original.Order, projection.Order);
Assert.AreEqual(original.RegionId, projection.RegionId);
});
}
public void Should_Delete_Page_Content()
{
RunActionInTransaction(session =>
{
// Create content
var content = TestDataProvider.CreateNewHtmlContent();
var pageContent = TestDataProvider.CreateNewPageContent(content);
session.SaveOrUpdate(pageContent);
session.Flush();
session.Clear();
// Delete page content
var request = new DeletePageContentCommandRequest
{
PageContentId = pageContent.Id,
PageContentVersion = pageContent.Version,
ContentVersion = content.Version
};
var unitOfWork = new DefaultUnitOfWork(session);
var command = new DeletePageContentCommand();
command.UnitOfWork = unitOfWork;
command.Repository = new DefaultRepository(unitOfWork);
var result = command.Execute(request);
Assert.IsTrue(result);
});
}
protected override SavePageContentModel GetCreateModel(ISession session)
{
var content = TestDataProvider.CreateNewHtmlContent(20);
var region = TestDataProvider.CreateNewRegion();
var contentOption = new ContentOption
{
Content = content,
DefaultValue = TestDataProvider.ProvideRandomString(100),
Key = TestDataProvider.ProvideRandomString(100),
Type = BetterCms.Core.DataContracts.Enums.OptionType.Text
};
session.SaveOrUpdate(content);
session.SaveOrUpdate(region);
session.SaveOrUpdate(contentOption);
var model = new SavePageContentModel
{
Order = 100,
ContentId = content.Id,
RegionId = region.Id,
};
if (setOptions)
{
model.Options = new List <OptionValueModel>
{
new OptionValueModel
{
DefaultValue = TestDataProvider.ProvideRandomString(100),
Value = TestDataProvider.ProvideRandomString(100),
Key = TestDataProvider.ProvideRandomString(100),
Type = OptionType.Text,
UseDefaultValue = false
},
new OptionValueModel
{
DefaultValue = Guid.NewGuid().ToString(),
Value = Guid.NewGuid().ToString(),
Key = TestDataProvider.ProvideRandomString(100),
Type = OptionType.Custom,
CustomTypeIdentifier = MediaManagerFolderOptionProvider.Identifier,
UseDefaultValue = false
},
new OptionValueModel
{
DefaultValue = contentOption.DefaultValue,
Value = TestDataProvider.ProvideRandomString(100),
Key = contentOption.Key,
Type = (OptionType)(int)contentOption.Type,
UseDefaultValue = true
},
};
}
return(model);
}
public void Should_Return_Page_With_PageContents_Successfully()
{
string virtualPath = "/test/" + Guid.NewGuid().ToString().Replace("-", string.Empty) + "/";
var layout = TestDataProvider.CreateNewLayout();
var regionA = TestDataProvider.CreateNewRegion();
var regionB = TestDataProvider.CreateNewRegion();
var htmlContent = TestDataProvider.CreateNewHtmlContent();
var serverWidgetContent = TestDataProvider.CreateNewServerControlWidget();
var htmlContentWidget = TestDataProvider.CreateNewHtmlContentWidget();
layout.LayoutRegions = new List <LayoutRegion>
{
TestDataProvider.CreateNewLayoutRegion(layout, regionA),
TestDataProvider.CreateNewLayoutRegion(layout, regionB)
};
var page = TestDataProvider.CreateNewPageProperties(layout);
page.PageContents = new List <PageContent>
{
TestDataProvider.CreateNewPageContent(htmlContent, page, regionA),
TestDataProvider.CreateNewPageContent(serverWidgetContent, page, regionB),
TestDataProvider.CreateNewPageContent(htmlContentWidget, page, regionB)
};
page.PageUrl = virtualPath;
RunDatabaseActionAndAssertionsInTransaction(
page,
session =>
{
session.Save(page);
session.Flush();
},
(result, session) =>
{
Page pageAlias = null;
Layout layoutAlias = null;
var entity = session.QueryOver(() => pageAlias)
.Inner.JoinAlias(() => pageAlias.Layout, () => layoutAlias)
.Where(f => f.PageUrl == virtualPath.ToLowerInvariant())
.Fetch(f => f.Layout).Eager
.Fetch(f => f.Layout.LayoutRegions).Eager
.Fetch(f => f.PageContents).Eager
.Fetch(f => f.PageContents[0].Content).Eager
.SingleOrDefault();
Assert.IsNotNull(entity);
Assert.AreEqual(page.PageContents.Count(), entity.PageContents.Distinct().Count());
Assert.AreEqual(page.Layout.LayoutRegions.Count(), entity.Layout.LayoutRegions.Distinct().Count());
});
}
private Content[] CreateFakeContents()
{
var content1 = TestDataProvider.CreateNewContent();
var content2 = TestDataProvider.CreateNewHtmlContent();
var content3 = TestDataProvider.CreateNewHtmlContentWidget();
var content4 = TestDataProvider.CreateNewServerControlWidget();
content1.Name = "Content_1";
content2.Name = "Content_2";
content3.Name = "Test_1";
content4.Name = "Test_2";
return(new[] { content1, content2, content3, content4 });
}
public void Should_Return_Page_Html_Content()
{
// Create html content
var htmlContent = TestDataProvider.CreateNewHtmlContent();
var pageContent = TestDataProvider.CreateNewPageContent(htmlContent);
htmlContent.Status = ContentStatus.Published;
// Create command
var command = new GetPageHtmlContentCommand();
command.UnitOfWork = new Mock <IUnitOfWork>().Object;
command.Repository = new Mock <IRepository>().Object;
command.Configuration = Container.Resolve <ICmsConfiguration>();
command.Context = new Mock <ICommandContext>().Object;
// Mock security service
var securityMock = new Mock <ISecurityService>();
securityMock.Setup(s => s.IsAuthorized(It.IsAny <IPrincipal>(), It.IsAny <string>())).Returns(true);
command.SecurityService = securityMock.Object;
// Mock content service
var serviceMock = new Mock <IContentService>();
serviceMock
.Setup(f => f.GetPageContentForEdit(pageContent.Id))
.Returns(new Tuple <PageContent, Content>(pageContent, htmlContent));
command.ContentService = serviceMock.Object;
// Execute command
var result = command.Execute(pageContent.Id);
Assert.IsNotNull(result);
Assert.AreEqual(result.Id, pageContent.Id);
Assert.AreEqual(result.ContentId, htmlContent.Id);
Assert.AreEqual(result.ContentName, htmlContent.Name);
Assert.AreEqual(result.ContentVersion, htmlContent.Version);
Assert.AreEqual(result.CurrentStatus, htmlContent.Status);
Assert.AreEqual(result.PageId, pageContent.Page.Id);
Assert.AreEqual(result.RegionId, pageContent.Region.Id);
Assert.AreEqual(result.LiveFrom, htmlContent.ActivationDate);
Assert.AreEqual(result.LiveTo, htmlContent.ExpirationDate);
}
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_By_Xml_And_Binary_Serializable()
{
var pageContent = TestDataProvider.CreateNewPageContent();
pageContent.Content = TestDataProvider.CreateNewHtmlContent();
pageContent.Options = new[]
{
TestDataProvider.CreateNewPageContentOption(pageContent),
TestDataProvider.CreateNewPageContentOption(pageContent),
TestDataProvider.CreateNewPageContentOption(pageContent)
};
PageContentProjection original = new PageContentProjection(
pageContent, pageContent.Content, new HtmlContentAccessor((HtmlContent)pageContent.Content, pageContent.Options.Cast <IOption>().ToList()));
RunSerializationAndDeserialization(original,
projection =>
{
Assert.AreEqual(original.ContentId, projection.ContentId);
Assert.AreEqual(original.Order, projection.Order);
Assert.AreEqual(original.RegionId, projection.RegionId);
});
}
protected override SaveHtmlContentModel GetCreateModel(ISession session)
{
var widget = TestDataProvider.CreateNewHtmlContentWidget();
session.SaveOrUpdate(widget);
var content = TestDataProvider.CreateNewHtmlContent();
var assignmentId1 = Guid.NewGuid();
var assignmentId2 = Guid.NewGuid();
content.Html = string.Format("{0}{1}{3}{2}",
TestDataProvider.ProvideRandomString(50),
TestDataProvider.CreateChildWidgetAssignment(widget.Id, assignmentId1),
TestDataProvider.ProvideRandomString(50),
TestDataProvider.CreateChildWidgetAssignment(widget.Id, assignmentId2));
var html = content.Html;
string originalText = "Just a test";
if (contentTextMode == ContentTextMode.Markdown)
{
html = null;
originalText = MarkdownOriginalText;
}
if (contentTextMode == ContentTextMode.SimpleText)
{
html = null;
originalText = SimpleOriginalText;
}
return(new SaveHtmlContentModel
{
Name = content.Name,
ActivationDate = content.ActivationDate,
ExpirationDate = content.ExpirationDate,
Html = html,
OriginalText = originalText,
ContentTextMode = contentTextMode,
CustomCss = content.CustomCss,
UseCustomCss = true,
CustomJavaScript = content.CustomJs,
UseCustomJavaScript = true,
IsPublished = true,
PublishedOn = content.PublishedOn,
PublishedByUser = content.PublishedByUser,
ChildContentsOptionValues = new List <ChildContentOptionValuesModel>
{
new ChildContentOptionValuesModel
{
AssignmentIdentifier = assignmentId1,
OptionValues = new List <OptionValueModel>
{
new OptionValueModel
{
Key = "O1",
Value = "V1",
UseDefaultValue = false,
Type = OptionType.Text
}
}
},
new ChildContentOptionValuesModel
{
AssignmentIdentifier = assignmentId2,
OptionValues = new List <OptionValueModel>
{
new OptionValueModel
{
Key = "O2",
Value = Guid.NewGuid().ToString(),
UseDefaultValue = false,
Type = OptionType.Custom,
CustomTypeIdentifier = "media-images-folder"
},
new OptionValueModel
{
Key = "O3",
Value = Guid.NewGuid().ToString(),
UseDefaultValue = true,
Type = OptionType.Text
}
}
}
}
});
}
public void Should_Sort_Page_Content_Successfully()
{
RunActionInTransaction(session =>
{
var layout = TestDataProvider.CreateNewLayout();
var region = TestDataProvider.CreateNewRegion();
layout.LayoutRegions = new List <LayoutRegion>
{
TestDataProvider.CreateNewLayoutRegion(layout, region),
};
var page = TestDataProvider.CreateNewPageProperties(layout);
page.PageContents = new[]
{
TestDataProvider.CreateNewPageContent(TestDataProvider.CreateNewHtmlContent(), page, region),
TestDataProvider.CreateNewPageContent(TestDataProvider.CreateNewHtmlContent(), page, region),
TestDataProvider.CreateNewPageContent(TestDataProvider.CreateNewHtmlContent(), page, region)
};
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
IUnitOfWork unitOfWork = new DefaultUnitOfWork(session);
SortPageContentCommand command = new SortPageContentCommand();
command.UnitOfWork = unitOfWork;
command.Repository = new DefaultRepository(unitOfWork);
var request = new PageContentSortViewModel
{
PageId = page.Id,
RegionId = region.Id,
PageContents =
new List <ContentSortViewModel>
{
new ContentSortViewModel {
Id = page.PageContents[2].Id, Version = page.PageContents[2].Version
},
new ContentSortViewModel {
Id = page.PageContents[1].Id, Version = page.PageContents[1].Version
},
new ContentSortViewModel {
Id = page.PageContents[0].Id, Version = page.PageContents[0].Version
},
}
};
var response = command.Execute(request);
Assert.AreEqual(2, response.UpdatedPageContents.Count);
session.Flush();
session.Clear();
var updatedPage = command.Repository.AsQueryable <PageContent>(f => f.Page.Id == page.Id).ToList();
Assert.AreEqual(2, updatedPage.FirstOrDefault(f => f.Id == page.PageContents[0].Id).Order);
Assert.AreEqual(1, updatedPage.FirstOrDefault(f => f.Id == page.PageContents[1].Id).Order);
Assert.AreEqual(0, updatedPage.FirstOrDefault(f => f.Id == page.PageContents[2].Id).Order);
});
}
public void Should_Sort_Page_Content_Successfully()
{
RunActionInTransaction(session =>
{
var layout = TestDataProvider.CreateNewLayout();
var region = TestDataProvider.CreateNewRegion();
layout.LayoutRegions = new List <LayoutRegion>
{
TestDataProvider.CreateNewLayoutRegion(layout, region),
};
var page = TestDataProvider.CreateNewPageProperties(layout);
page.PageContents = new[]
{
TestDataProvider.CreateNewPageContent(TestDataProvider.CreateNewHtmlContent(), page, region),
TestDataProvider.CreateNewPageContent(TestDataProvider.CreateNewHtmlContent(), page, region),
TestDataProvider.CreateNewPageContent(TestDataProvider.CreateNewHtmlContent(), page, region)
};
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
IUnitOfWork unitOfWork = new DefaultUnitOfWork(session);
var configuration = Container.Resolve <ICmsConfiguration>();
SortPageContentCommand command = new SortPageContentCommand(configuration);
command.UnitOfWork = unitOfWork;
command.Repository = new DefaultRepository(unitOfWork);
command.Context = new Mock <ICommandContext>().Object;
var accessControlService = new Mock <IAccessControlService>();
accessControlService.Setup(s => s.DemandAccess(It.IsAny <IPrincipal>(), It.IsAny <string>()));
command.AccessControlService = accessControlService.Object;
var request = new PageContentSortViewModel
{
PageId = page.Id,
PageContents =
new List <ContentSortViewModel>
{
new ContentSortViewModel {
RegionId = region.Id, PageContentId = page.PageContents[2].Id, Version = page.PageContents[2].Version
},
new ContentSortViewModel {
RegionId = region.Id, PageContentId = page.PageContents[1].Id, Version = page.PageContents[1].Version
},
new ContentSortViewModel {
RegionId = region.Id, PageContentId = page.PageContents[0].Id, Version = page.PageContents[0].Version
},
}
};
var response = command.Execute(request);
Assert.IsTrue(response);
session.Flush();
session.Clear();
var updatedPage = command.Repository.AsQueryable <PageContent>(f => f.Page.Id == page.Id).ToList();
Assert.AreEqual(2, updatedPage.FirstOrDefault(f => f.Id == page.PageContents[0].Id).Order);
Assert.AreEqual(1, updatedPage.FirstOrDefault(f => f.Id == page.PageContents[1].Id).Order);
Assert.AreEqual(0, updatedPage.FirstOrDefault(f => f.Id == page.PageContents[2].Id).Order);
});
}
public void Should_Insert_And_Retrieve_HtmlContent()
{
var htmlContent = TestDataProvider.CreateNewHtmlContent(200);
RunEntityMapTestsInTransaction(htmlContent);
}
