public void Should_Delete_Media_With_Access_Rules()
{
RunActionInTransaction(session =>
{
var uow = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(uow);
var file = TestDataProvider.CreateNewMediaFileWithAccessRules(3);
session.SaveOrUpdate(file);
session.Flush();
session.Clear();
var command = new DeleteMediaCommand();
command.Repository = repository;
command.UnitOfWork = uow;
var result = command.Execute(new DeleteMediaCommandRequest
{
Id = file.Id,
Version = file.Version
});
Assert.IsTrue(result);
session.Clear();
var deletedFile = session.Query<MediaFile>().FirstOrDefault(f => f.Id == file.Id && !f.IsDeleted);
Assert.IsNull(deletedFile);
});
}
public void Should_Delete_HtmlContentWidget_Successfully()
{
var htmlContentWidget = TestDataProvider.CreateNewHtmlContentWidget();
RunActionInTransaction(session =>
{
session.SaveOrUpdate(htmlContentWidget);
session.Flush();
session.Clear();
var uow = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(uow);
var optionService = new Mock<IOptionService>().Object;
var contentService = new Mock<IContentService>().Object;
var childContentService = new Mock<IChildContentService>().Object;
var categoryService = new Mock<ICategoryService>();
var widgetService = new DefaultWidgetService(repository, uow, optionService, contentService, childContentService, categoryService.Object);
DeleteWidgetCommand command = new DeleteWidgetCommand(widgetService);
bool success = command.Execute(new DeleteWidgetRequest
{
WidgetId = htmlContentWidget.Id,
Version = htmlContentWidget.Version
});
Assert.IsTrue(success);
});
}
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 contentService = Container.Resolve<IContentService>();
var command = new DeletePageContentCommand(contentService);
command.UnitOfWork = unitOfWork;
command.Repository = repository;
var result = command.Execute(request);
Assert.IsTrue(result);
});
}
public void Should_ThrowValidationException_AboutNonDeletableOption()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var optionService = new DefaultOptionService(repository);
// 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_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<ContentViewModel>
{
new ContentViewModel { Id = page.PageContents[2].Id, Version = page.PageContents[2].Version },
new ContentViewModel { Id = page.PageContents[1].Id, Version = page.PageContents[1].Version },
new ContentViewModel { 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_Clone_Page_With_Tags_Options_Contents_AccessRules()
{
RunActionInTransaction(session =>
{
const string url = "/test-link";
var uow = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(uow);
var pageToClone = TestDataProvider.CreateNewPageWithTagsContentsOptionsAndAccessRules(session, 2, 2, 2, 2);
session.SaveOrUpdate(pageToClone);
session.Flush();
session.Clear();
var pageService = new Mock<IPageService>();
pageService.Setup(f => f.ValidatePageUrl(It.IsAny<string>(), It.IsAny<Guid?>()));
pageService.Setup(f => f.CreatePagePermalink(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>())).Returns(url);
var urlService = new Mock<IUrlService>();
urlService.Setup(f => f.FixUrl(It.IsAny<string>())).Returns(url);
var rules = new List<IAccessRule>();
var rule1 = TestDataProvider.CreateNewAccessRule();
rules.Add(rule1);
var rule2 = TestDataProvider.CreateNewAccessRule();
rules.Add(rule2);
var pageCloningService = new DefaultPageCloneService(pageService.Object, urlService.Object,
new Mock<ISecurityService>().Object, new Mock<IAccessControlService>().Object, repository, uow,
Container.Resolve<ICmsConfiguration>());
var command = new ClonePageCommand(pageCloningService);
command.Repository = repository;
command.UnitOfWork = uow;
var result = command.Execute(new ClonePageViewModel
{
PageId = pageToClone.Id,
PageTitle = "new cloned page",
PageUrl = url,
UserAccessList = pageToClone.AccessRules.Select(u => new UserAccessViewModel(u)).ToList()
});
Assert.IsNotNull(result);
session.Clear();
var actual = repository.AsQueryable<PageProperties>().Where(f => f.Id == result.PageId).ToList().FirstOrDefault();
Assert.IsNotNull(actual);
Assert.AreEqual(2, actual.AccessRules.Count(), "AccessRules");
Assert.AreEqual(2, actual.PageTags.Count(), "Tags");
Assert.AreEqual(2, actual.PageContents.Count(), "Contents");
Assert.AreEqual(2, actual.Options.Count(), "Options");
});
}
public void Should_Return_Page_Content_Options_Successfully()
{
RunActionInTransaction(session =>
{
var content = TestDataProvider.CreateNewContent();
var pageContent = TestDataProvider.CreateNewPageContent(content);
FillContentWithOptions(content);
FillPageContentWithOptions(content, pageContent);
session.SaveOrUpdate(pageContent);
session.Flush();
session.Clear();
// Create command
var unitOfWork = new DefaultUnitOfWork(session);
var command = new GetPageContentOptionsCommand();
var repository = new DefaultRepository(unitOfWork);
command.UnitOfWork = unitOfWork;
command.Repository = repository;
command.OptionService = new DefaultOptionService(repository);
command.CmsConfiguration = Container.Resolve<ICmsConfiguration>();
// Execute command
var result = command.Execute(pageContent.Id);
// Should return 4 options: 2 with assigned values, 1 without parent option and 1 unassigned
Assert.IsNotNull(result);
Assert.IsNotNull(result.OptionValues);
Assert.AreEqual(result.OptionValues.Count, 5);
Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == content.ContentOptions[0].Key
&& o.OptionValue == pageContent.Options[0].Value
&& o.OptionDefaultValue == content.ContentOptions[0].DefaultValue
&& !o.UseDefaultValue
&& !o.CanEditOption));
Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == content.ContentOptions[1].Key
&& o.OptionValue == pageContent.Options[1].Value
&& o.OptionDefaultValue == content.ContentOptions[1].DefaultValue
&& !o.UseDefaultValue
&& !o.CanEditOption));
Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == content.ContentOptions[2].Key
&& o.OptionValue == content.ContentOptions[2].DefaultValue
&& o.OptionDefaultValue == content.ContentOptions[2].DefaultValue
&& o.UseDefaultValue
&& !o.CanEditOption));
Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == pageContent.Options[2].Key
&& o.OptionValue == pageContent.Options[2].Value
&& o.OptionDefaultValue == null
&& o.CanEditOption));
Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == pageContent.Options[3].Key
&& o.OptionValue == pageContent.Options[3].Value
&& o.OptionDefaultValue == null
&& o.CanEditOption));
});
}
public void Sould_Delete_Page_Successfully()
{
RunActionInTransaction(session =>
{
const string url = "/test-link/";
var uow = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(uow);
var page = TestDataProvider.CreateNewPageWithTagsContentsOptionsAndAccessRules(session);
session.SaveOrUpdate(page);
session.Flush();
session.Clear();
var pageService = new Mock<IPageService>();
pageService.Setup(f => f.ValidatePageUrl(It.IsAny<string>(), It.IsAny<Guid?>()));
pageService.Setup(f => f.CreatePagePermalink(It.IsAny<string>(), It.IsAny<string>())).Returns(url);
var sitemapService = new Mock<ISitemapService>();
sitemapService
.Setup(service => service.GetNodesByPage(It.IsAny<PageProperties>()))
.Returns(() => new List<SitemapNode>());
var urlService = new Mock<IUrlService>();
urlService.Setup(f => f.FixUrl(It.IsAny<string>())).Returns((string a) => a);
var securityService = new Mock<ICmsSecurityConfiguration>();
securityService.Setup(f => f.AccessControlEnabled).Returns(false);
var configurationService = new Mock<ICmsConfiguration>();
configurationService.Setup(f => f.Security).Returns(securityService.Object);
var command = new DeletePageCommand(null, sitemapService.Object, urlService.Object, configurationService.Object);
command.Repository = repository;
command.UnitOfWork = uow;
var result = command.Execute(new DeletePageViewModel
{
PageId = page.Id,
UpdateSitemap = false,
RedirectUrl = null,
SecurityWord = "DELETE",
Version = page.Version
});
Assert.IsTrue(result);
session.Clear();
var actual = repository.AsQueryable<PageProperties>().FirstOrDefault(f => f.Id == page.Id && !f.IsDeleted);
Assert.IsNull(actual);
});
}
public void Should_Save_Options_Successfully()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var optionService = new DefaultOptionService(repository);
// 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<IOption> { 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));
});
}
public void Should_Retrieve_Widgets_From_Database_Paged_And_Sorted_By_CategoryName()
{
RunActionInTransaction(session =>
{
var widgets = new Widget[]
{
this.TestDataProvider.CreateNewServerControlWidget(),
this.TestDataProvider.CreateNewServerControlWidget(),
this.TestDataProvider.CreateNewHtmlContentWidget()
};
int i = 0;
foreach (var widget in widgets)
{
widget.Name = "test name " + i++;
session.SaveOrUpdate(widget);
}
session.Flush();
session.Clear();
IUnitOfWork unitOfWork = new DefaultUnitOfWork(session);
GetSiteSettingsWidgetsCommand command = new GetSiteSettingsWidgetsCommand();
command.UnitOfWork = unitOfWork;
command.Repository = new DefaultRepository(unitOfWork);
var result = command.Execute(new SearchableGridOptions
{
PageSize = 20,
Column = "CategoryName",
Direction = SortDirection.Ascending,
PageNumber = 1,
SearchQuery = "test name 2"
});
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Items.TotalItems);
Assert.AreEqual(widgets[2].Name, result.Items.First().WidgetName);
});
}
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 DefaultAccessControlService(Container.Resolve<ISecurityService>(), new HttpRuntimeCacheService(), config),
new Mock<IOptionService>().SetupAllProperties().Object);
command.UnitOfWork = uow;
command.Repository = repository;
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_Save_Page_Content_Options_Successfully()
{
RunActionInTransaction(session =>
{
// Create page content with options
var content = TestDataProvider.CreateNewContent();
var pageContent = TestDataProvider.CreateNewPageContent(content);
FillContentWithOptions(content);
FillPageContentWithOptions(content, pageContent);
session.SaveOrUpdate(pageContent);
session.Flush();
session.Clear();
// Random option value
var randomOptionValue = TestDataProvider.CreateNewPageContentOption();
// Create request
var request = new ContentOptionValuesViewModel
{
OptionValues = new List<OptionValueEditViewModel>
{
new OptionValueEditViewModel
{
// Must be updated
OptionKey = pageContent.Options[0].Key,
OptionValue = content.ContentOptions[0].DefaultValue,
UseDefaultValue = false
},
new OptionValueEditViewModel
{
// Must be deleted
OptionKey = pageContent.Options[1].Key,
OptionValue = null,
UseDefaultValue = true
},
new OptionValueEditViewModel
{
// Must be updated
OptionKey = pageContent.Options[2].Key,
OptionValue = null,
UseDefaultValue = false
},
new OptionValueEditViewModel
{
// Must be created
OptionValue = randomOptionValue.Value,
OptionKey = randomOptionValue.Key,
Type = OptionType.Text
}
},
OptionValuesContainerId = pageContent.Id
};
// Create command
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var command = new SavePageContentOptionsCommand();
command.UnitOfWork = unitOfWork;
command.Repository = repository;
command.OptionService = new DefaultOptionService(repository, new HttpRuntimeCacheService());
var result = command.Execute(request);
Assert.IsNotNull(result);
Assert.Greater(result.PageContentVersion, pageContent.Version);
// Check results: one of page content values must be deleted after save
var results = repository
.AsQueryable<PageContentOption>(pco => pco.PageContent.Id == pageContent.Id
&& !pco.IsDeleted
&& !pco.PageContent.IsDeleted)
.ToList();
Assert.AreEqual(results.Count, 3);
Assert.IsNotNull(results.FirstOrDefault(pco => {
return pco.Key == pageContent.Options[0].Key && pco.Value == content.ContentOptions[0].DefaultValue;
}));
Assert.IsNotNull(results.FirstOrDefault(pco => {
return pco.Key == pageContent.Options[2].Key && pco.Value == null;
}));
Assert.IsNotNull(results.FirstOrDefault(pco => pco.Key == randomOptionValue.Key
&& pco.Value == randomOptionValue.Value));
});
}
public void Should_Save_Page_Content_Options_Successfully()
{
RunActionInTransaction(session =>
{
// Create page content with options
var content = TestDataProvider.CreateNewContent();
var pageContent = TestDataProvider.CreateNewPageContent(content);
FillContentWithOptions(content);
FillPageContentWithOptions(content, pageContent);
session.SaveOrUpdate(pageContent);
session.Flush();
session.Clear();
// Random option value
var randomOptionValue = TestDataProvider.CreateNewPageContentOption();
// Create request
var request = new PageContentOptionsViewModel
{
WidgetOptions = new List<PageContentOptionViewModel>
{
new PageContentOptionViewModel
{
// Will be deleted because of default value
OptionValue = content.ContentOptions[0].DefaultValue,
OptionKey = pageContent.Options[0].Key,
OptionDefaultValue = content.ContentOptions[0].DefaultValue
},
new PageContentOptionViewModel
{
// Will be deleted because of null value
OptionValue = null,
OptionKey = pageContent.Options[1].Key
},
new PageContentOptionViewModel
{
OptionValue = pageContent.Options[2].Value,
OptionKey = pageContent.Options[2].Key
},
new PageContentOptionViewModel
{
// Random value
OptionValue = randomOptionValue.Value,
OptionKey = randomOptionValue.Key
}
},
PageContentId = pageContent.Id
};
// Create command
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var command = new SavePageContentOptionsCommand();
command.UnitOfWork = unitOfWork;
command.Repository = repository;
var result = command.Execute(request);
Assert.IsTrue(result);
// Check results: one of page content values must be deleted after save
var results = repository
.AsQueryable<PageContentOption>(pco => pco.PageContent.Id == pageContent.Id
&& !pco.IsDeleted
&& !pco.PageContent.IsDeleted)
.ToList();
Assert.AreEqual(results.Count, 2);
Assert.IsNotNull(results.FirstOrDefault(pco => pco.Key == pageContent.Options[2].Key
&& pco.Value == pageContent.Options[2].Value));
Assert.IsNotNull(results.FirstOrDefault(pco => pco.Key == randomOptionValue.Key
&& pco.Value == randomOptionValue.Value));
});
}
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.IsNotNull(response);
Assert.IsNotNull(response.PageContents);
Assert.AreEqual(response.PageContents.Count, request.PageContents.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);
});
}
private IRepository CreateRepository(ISession session)
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
return repository;
}
public void ShouldRetrieveSecondChildPageOptionsSuccessfully()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var pages = CreateNestedOptions(session, 3);
var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService());
var optionValues = optionService.GetMergedMasterPagesOptionValues(pages[2].Id, pages[2].MasterPage.Id, null);
Assert.AreEqual(optionValues.Count, 5);
Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l1" && o.OptionValue == "l1"));
Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l2" && o.OptionValue == "l2p2"));
Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l3" && o.OptionValue == "l3p3"));
Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p1" && o.OptionValue == "p1"));
Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p2" && o.OptionValue == "p2"));
});
}