public void Should_ThrowValidationException_AboutNonDeletableOption()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService());
// Create layout with options
var layout = TestDataProvider.CreateNewLayout();
layout.LayoutOptions = new List <LayoutOption>();
var option1 = TestDataProvider.CreateNewLayoutOption(layout);
option1.Type = OptionType.Text;
option1.IsDeletable = false;
layout.LayoutOptions.Add(option1);
session.SaveOrUpdate(layout);
session.Flush();
session.Clear();
optionService.SetOptions <LayoutOption, Layout>(layout, new List <IOption>());
unitOfWork.Commit();
});
}
public void Should_CRUD_BlogPost_WithLayout_Successfully_WithIdSpecified()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
RunWithIdSpecified(session, 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_Save_Options_Successfully()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var cmsConfiguration = new Mock <ICmsConfiguration>();
var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);
// Create layout with options
var layout = TestDataProvider.CreateNewLayout();
layout.LayoutOptions = new List <LayoutOption>();
var option1 = TestDataProvider.CreateNewLayoutOption(layout);
option1.Type = OptionType.Text;
layout.LayoutOptions.Add(option1);
var option2 = TestDataProvider.CreateNewLayoutOption(layout);
option2.Type = OptionType.Text;
layout.LayoutOptions.Add(option2);
var option3 = TestDataProvider.CreateNewLayoutOption(layout);
option3.Type = OptionType.Text;
layout.LayoutOptions.Add(option3);
session.SaveOrUpdate(layout);
session.Flush();
session.Clear();
// Create fake options:
// 1 should be kept
// 2 should be updated
// 3 should be inserted
// option2 should be deleted
var newOption1 = new LayoutOption {
Key = option1.Key, Type = option1.Type, DefaultValue = option1.DefaultValue
};
var newOption2 = new LayoutOption {
Key = option2.Key, Type = option2.Type, DefaultValue = TestDataProvider.ProvideRandomString(100)
};
var newOption3 = new LayoutOption {
Key = TestDataProvider.ProvideRandomString(100), Type = OptionType.Text, DefaultValue = TestDataProvider.ProvideRandomString(100)
};
var newOptions = new List <IOptionEntity> {
newOption1, newOption2, newOption3
};
optionService.SetOptions <LayoutOption, Layout>(layout, newOptions);
unitOfWork.Commit();
// Load all options
var options = repository.AsQueryable <LayoutOption>(lo => lo.Layout == layout).ToList();
Assert.AreEqual(options.Count, 3);
Assert.IsTrue(options.Any(o => o.Key == option1.Key && o.DefaultValue == option1.DefaultValue && o.Type == option1.Type));
Assert.IsTrue(options.Any(o => o.Key == option2.Key && o.DefaultValue == newOption2.DefaultValue && o.Type == option2.Type));
Assert.IsTrue(options.Any(o => o.Key == newOption3.Key && o.DefaultValue == newOption3.DefaultValue && o.Type == newOption3.Type));
});
}
[Ignore] // Fails because of .ToFuture() usage inside service.GetLayouts() method.
public void Should_Return_Templates_List_Successfully()
{
BetterCms.Module.Root.Models.Layout layout1 = TestDataProvider.CreateNewLayout();
BetterCms.Module.Root.Models.Layout layout2 = TestDataProvider.CreateNewLayout();
Mock <IRepository> repositoryMock = new Mock <IRepository>();
repositoryMock
.Setup(f => f.AsQueryable <BetterCms.Module.Root.Models.Layout>())
.Returns(new[] { layout1, layout2 }.AsQueryable());
var service = new DefaultLayoutService(repositoryMock.Object,
new Mock <IOptionService>().Object,
new Mock <ICmsConfiguration>().Object,
new Mock <IAccessControlService>().Object,
new Mock <IUnitOfWork>().Object);
var response = service.GetAvailableLayouts().ToList();
Assert.IsNotNull(response);
Assert.AreEqual(response.Count, 2);
Assert.AreEqual(response[0].Title, new[] { layout1, layout2 }.OrderBy(o => o.Name).Select(o => o.Name).First());
var layout = response.FirstOrDefault(l => layout1.Id == l.TemplateId);
Assert.IsNotNull(layout);
Assert.AreEqual(layout1.Name, layout.Title);
}
public void Saving_New_Entity_With_Predefined_Empty_Id_Should_Not_Change_Id()
{
RunActionInTransaction(session =>
{
var layout = TestDataProvider.CreateNewLayout();
var region = TestDataProvider.CreateNewRegion();
layout.LayoutRegions = new List <LayoutRegion>
{
TestDataProvider.CreateNewLayoutRegion(layout, region),
};
var page = TestDataProvider.CreateNewPageProperties(layout);
var pageId = page.Id = Guid.NewGuid();
Assert.AreEqual(page.Id, pageId);
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
Assert.AreEqual(page.Id, pageId);
});
}
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());
});
}
public void Should_CRUD_BlogPost_WithNoLayoutSpecified_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 = null;
layout = null;
masterPage = null;
defaultLayout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = defaultLayout, Region = region
};
defaultLayout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(defaultLayout);
session.SaveOrUpdate(layoutRegion);
// Set default layout
var repository = GetRepository(session);
var option = repository.AsQueryable <Option>().FirstOrDefault();
if (option == null)
{
option = new Option();
}
option.DefaultMasterPage = null;
option.DefaultLayout = defaultLayout;
session.SaveOrUpdate(defaultLayout);
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_LayoutRegions_Successfully()
{
var layout = TestDataProvider.CreateNewLayout();
var layoutRegions = new[]
{
TestDataProvider.CreateNewLayoutRegion(layout),
TestDataProvider.CreateNewLayoutRegion(layout),
TestDataProvider.CreateNewLayoutRegion(layout)
};
layout.LayoutRegions = layoutRegions;
SaveEntityAndRunAssertionsInTransaction(
layout,
result =>
{
Assert.AreEqual(layout, result);
Assert.AreEqual(layoutRegions.OrderBy(f => f.Id), result.LayoutRegions.OrderBy(f => f.Id));
});
}
protected override SaveLayoutModel GetCreateModel(ISession session)
{
var layout = TestDataProvider.CreateNewLayout();
return(new SaveLayoutModel
{
Name = layout.Name,
LayoutPath = layout.LayoutPath,
PreviewUrl = layout.PreviewUrl,
Options = new List <OptionModel>
{
new OptionModel
{
DefaultValue = "1",
Key = "K1",
Type = OptionType.Text
},
new OptionModel
{
DefaultValue = Guid.NewGuid().ToString(),
Key = "K2",
Type = OptionType.Custom,
CustomTypeIdentifier = MediaManagerFolderOptionProvider.Identifier
}
},
Regions = new List <RegionSaveModel>
{
new RegionSaveModel
{
Description = TestDataProvider.ProvideRandomString(MaxLength.Name),
RegionIdentifier = TestDataProvider.ProvideRandomString(MaxLength.Name)
},
new RegionSaveModel
{
Description = TestDataProvider.ProvideRandomString(MaxLength.Name),
RegionIdentifier = TestDataProvider.ProvideRandomString(MaxLength.Name)
}
}
});
}
public void Saving_Entity_With_Duplicated_Id_Should_Fail2()
{
RunActionInTransaction(
session =>
{
var layout = TestDataProvider.CreateNewLayout();
var region = TestDataProvider.CreateNewRegion();
layout.LayoutRegions = new List <LayoutRegion> {
TestDataProvider.CreateNewLayoutRegion(layout, region),
};
var page = TestDataProvider.CreateNewPageProperties(layout);
var pageId = page.Id;
Assert.AreNotEqual(pageId, Guid.Empty);
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
Assert.AreEqual(page.Id, pageId);
var originalPage = session.Get <Page>(pageId);
Assert.AreEqual(page, originalPage);
var page2 = TestDataProvider.CreateNewPageProperties(layout);
page2.Id = pageId;
session.Clear();
Assert.Throws <NHibernate.Exceptions.GenericADOException>(
() =>
{
session.SaveOrUpdate(page2);
session.Flush();
});
});
}
public void Should_CRUD_BlogPost_WithLayout_Successfully()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogCreated += CheckTagCount;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
isNullUrl = true;
isMarkdown = false;
isHtmlSet = true;
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
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.BlogCreated -= CheckTagCount;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
public void Should_CRUD_PageProperties_WithLayout_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 = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
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 Changing_Saved_Entity_Id_Should_Fail()
{
RunActionInTransaction(
session =>
{
var layout = TestDataProvider.CreateNewLayout();
var region = TestDataProvider.CreateNewRegion();
layout.LayoutRegions = new List <LayoutRegion> {
TestDataProvider.CreateNewLayoutRegion(layout, region),
};
var page = TestDataProvider.CreateNewPageProperties(layout);
var pageId = page.Id;
Assert.AreNotEqual(pageId, Guid.Empty);
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
Assert.AreEqual(page.Id, pageId);
var originalPage = session.Get <Page>(pageId);
Assert.AreEqual(page, originalPage);
var newId = Guid.NewGuid();
originalPage.Id = newId;
Assert.Throws <NHibernate.HibernateException>(
() =>
{
session.SaveOrUpdate(originalPage);
session.Flush();
});
});
}
public void Should_Create_New_Page_With_Access_Rules()
{
RunActionInTransaction(
session =>
{
var tempLayout = TestDataProvider.CreateNewLayout();
session.SaveOrUpdate(tempLayout);
session.Flush();
var uow = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(uow);
var configMock = new Mock <ICmsConfiguration>();
configMock.SetupAllProperties().Setup(f => f.Security.AccessControlEnabled).Returns(true);
configMock.Setup(f => f.Security.DefaultAccessRules).Returns(new AccessControlCollection
{
DefaultAccessLevel = "readwrite"
});
var config = configMock.Object;
var command = new CreatePageCommand(
new Mock <IPageService>().SetupAllProperties().Object,
new DefaultUrlService(uow, config),
config,
new Mock <IOptionService>().SetupAllProperties().Object,
new Mock <IMasterPageService>().SetupAllProperties().Object);
command.UnitOfWork = uow;
command.Repository = repository;
command.AccessControlService = new DefaultAccessControlService(Container.Resolve <ISecurityService>(), new HttpRuntimeCacheService(), config, repository);
var contextMock = new Mock <ICommandContext>();
contextMock.Setup(c => c.Principal).Returns(new GenericPrincipal(new GenericIdentity("John Doe"), new[] { RootModuleConstants.UserRoles.EditContent }));
command.Context = contextMock.Object;
var request = new AddNewPageViewModel();
request.AccessControlEnabled = true;
request.PageTitle = "TestCreatePageCommand";
request.PageUrl = "/test-CreatePageCommand/";
request.TemplateId = tempLayout.Id;
request.UserAccessList = new List <UserAccessViewModel>(
new[]
{
new UserAccessViewModel
{
Identity = "test 1",
AccessLevel = AccessLevel.ReadWrite
},
new UserAccessViewModel
{
Identity = "test 2",
AccessLevel = AccessLevel.Deny
}
});
var response = command.Execute(request);
session.Clear();
Assert.IsNotNull(response);
var page = session.Query <Page>().FirstOrDefault(f => f.Id == response.PageId);
Assert.IsNotNull(page);
Assert.IsNotNull(page.AccessRules);
Assert.AreEqual(2, page.AccessRules.Count());
});
}
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_Insert_And_Retrieve_Layout_Successfully()
{
var layout = TestDataProvider.CreateNewLayout();
RunEntityMapTestsInTransaction(layout);
}
private PageProperties[] CreateNestedOptions(ISession session, int level)
{
var pages = new PageProperties[3];
// Create layout and options
var layout = TestDataProvider.CreateNewLayout();
var lo1 = TestDataProvider.CreateNewLayoutOption(layout);
lo1.Type = OptionType.Text;
lo1.Key = "l1";
lo1.DefaultValue = "l1";
var lo2 = TestDataProvider.CreateNewLayoutOption(layout);
lo2.Type = OptionType.Text;
lo2.Key = "l2";
lo2.DefaultValue = "l2";
var lo3 = TestDataProvider.CreateNewLayoutOption(layout);
lo3.Type = OptionType.Text;
lo3.Key = "l3";
lo3.DefaultValue = "l3";
layout.LayoutOptions = new List <LayoutOption> {
lo1, lo2, lo3
};
session.SaveOrUpdate(layout);
// Create Master page
var page1 = TestDataProvider.CreateNewPageProperties(layout);
var o11 = TestDataProvider.CreateNewPageOption(page1);
o11.Type = OptionType.Text;
o11.Key = "p1";
o11.Value = "p1";
var o12 = TestDataProvider.CreateNewPageOption(page1);
o12.Type = OptionType.Text;
o12.Key = "l3";
o12.Value = "l3p1";
page1.Options = new List <PageOption> {
o11, o12
};
session.SaveOrUpdate(page1);
pages[0] = page1;
if (level > 1)
{
// Create First Child With Options
var page2 = TestDataProvider.CreateNewPageProperties();
page2.Layout = null;
page2.MasterPage = page1;
var o21 = TestDataProvider.CreateNewPageOption(page2);
o21.Type = OptionType.Text;
o21.Key = "p2";
o21.Value = "p2";
var o22 = TestDataProvider.CreateNewPageOption(page2);
o22.Type = OptionType.Text;
o22.Key = "l3";
o22.Value = "l3p2";
var o23 = TestDataProvider.CreateNewPageOption(page2);
o23.Type = OptionType.Text;
o23.Key = "l2";
o23.Value = "l2p2";
page2.Options = new List <PageOption> {
o21, o22, o23
};
session.SaveOrUpdate(page2);
pages[1] = page2;
var master21 = new MasterPage {
Page = page2, Master = page1
};
session.SaveOrUpdate(master21);
if (level > 2)
{
// Create Second Child With Options
var page3 = TestDataProvider.CreateNewPageProperties();
page3.Layout = null;
page3.MasterPage = page2;
var o31 = TestDataProvider.CreateNewPageOption(page3);
o31.Type = OptionType.Text;
o31.Key = "l3";
o31.Value = "l3p3";
page3.Options = new List <PageOption> {
o31
};
session.SaveOrUpdate(page3);
pages[2] = page3;
var master31 = new MasterPage {
Page = page3, Master = page1
};
session.SaveOrUpdate(master31);
var master32 = new MasterPage {
Page = page3, Master = page2
};
session.SaveOrUpdate(master32);
}
}
session.Flush();
session.Clear();
return(pages);
}
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_CRUD_BlogPost_WithLayout_TestPermalink_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) =>
{
var permalinkCreation = UrlHelper.GeneratePageUrl;
try
{
var failedToCheckCategory = true;
UrlHelper.GeneratePageUrl = request =>
{
if ((request.CategoryId == null && categories != null) ||
(request.CategoryId != null && categories == null) ||
request.CategoryId.Count() != categories.Count ||
request.CategoryId.Any(c => categories.All(c1 => c1 != c)))
{
throw new Exception("Failed to check category");
}
failedToCheckCategory = false;
return(permalinkCreation(request));
};
isNullUrl = true;
isMarkdown = false;
isHtmlSet = true;
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
Run(
session,
api.Blog.BlogPost.Properties.Post,
api.Blog.BlogPost.Properties.Get,
api.Blog.BlogPost.Properties.Put,
api.Blog.BlogPost.Properties.Delete);
Assert.IsFalse(failedToCheckCategory, "Failed to check category passed to the URL creation function.");
}
finally
{
UrlHelper.GeneratePageUrl = permalinkCreation;
}
});
// Detach from events
Events.BlogEvents.Instance.BlogCreated -= Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
