public void GivenDefinitionWithASpecifiedFilename_CreateNewPageType_ReturnsPageTypeWithThatFilename()
{
PageTypeDefinition definition = PageTypeUpdaterTestsUtility.CreateBasicPageTypeDefinition();
definition.Attribute.Filename = TestValueUtility.CreateRandomString();
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
SetupPageTypeUpdaterWithFakePageTypeFactory(pageTypeUpdater);
IPageType returnedPageType = pageTypeUpdater.CreateNewPageType(definition);
Assert.Equal <string>(definition.Attribute.Filename, returnedPageType.FileName);
}
public void GivenNoDefaultPeerOrderRuleInAttribute_WhenUpdateDefaultPeerOrderRuleCalled_SetsPageTypeDefaultPeerOrderRuleToDefaultValue()
{
PageTypeAttribute attribute = new PageTypeAttribute();
IPageType pageType = new NativePageType();
pageType.DefaultPeerOrder = 1;
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.NewlyCreatedPageTypes.Add(pageType);
pageTypeUpdater.UpdateDefaultPeerOrder(pageType, attribute);
Assert.Equal <int>(PageTypeUpdater.DefaultDefaultPageTypePeerOrder, pageType.DefaultPeerOrder);
}
public void GivenNameSetInAttribute_WhenUpdatePageTypeCalled_UpdatesPageTypeNameWithName()
{
PageTypeDefinition definition = PageTypeUpdaterTestsUtility.CreateBasicPageTypeDefinition();
IPageType pageType = new NativePageType();
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
string name = TestValueUtility.CreateRandomString();
definition.Attribute.Name = name;
pageTypeUpdater.UpdateName(pageType, definition);
Assert.Equal <string>(name, pageType.Name);
}
public void GivenNoDefaultVisibleInMenuInAttribute_UpdateDefaultVisibleInMenuCalled_SetsPageTypeDefaultVisibleInMenuToDefaultValue()
{
IPageType pageType = new NativePageType();
pageType.DefaultVisibleInMenu = !PageTypeUpdater.DefaultDefaultVisibleInMenu;
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.NewlyCreatedPageTypes.Add(pageType);
pageTypeUpdater.UpdateDefaultVisibleInMenu(pageType, new PageTypeAttribute());
Assert.Equal <bool>(PageTypeUpdater.DefaultDefaultVisibleInMenu, pageType.DefaultVisibleInMenu);
}
public void GivenPageType_WhenUpdateDefaultPeerOrderRuleCalled_UpdatesPageTypeDefaultPeerOrderRule(int defaultSortIndex)
{
PageTypeAttribute attribute = new PageTypeAttribute();
attribute.DefaultSortIndex = defaultSortIndex;
IPageType pageType = new NativePageType();
pageType.DefaultPeerOrder = 1;
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.UpdateDefaultPeerOrder(pageType, attribute);
Assert.Equal <int>(defaultSortIndex, pageType.DefaultPeerOrder);
}
public void GivenName_WhenUpdateDefaultNameCalled_UpdatesPageTypeDefaultPageName(string defaultPageName)
{
PageTypeAttribute attribute = new PageTypeAttribute();
attribute.DefaultPageName = defaultPageName;
IPageType pageType = new NativePageType();
pageType.DefaultPageName = TestValueUtility.CreateRandomString();
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.UpdateDefaultPageName(pageType, attribute);
Assert.Equal <string>(defaultPageName, pageType.DefaultPageName);
}
public void GivenFilterSortOrder_WhenUpdatePageTypeCalled_UpdatesPageTypeDefaultChildOrderRule(FilterSortOrder sortOrder)
{
PageTypeAttribute attribute = new PageTypeAttribute();
attribute.DefaultChildSortOrder = sortOrder;
IPageType pageType = new NativePageType();
pageType.DefaultChildOrderRule = FilterSortOrder.PublishedAscending;
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.UpdateDefaultChildOrderRule(pageType, attribute);
Assert.Equal <FilterSortOrder>(sortOrder, pageType.DefaultChildOrderRule);
}
public void GivenAttribueDefaultArchiveToPageIDPageTypeIDIsNotSet_WhenUpdateDefaultArchiveToPageIDCalled_UpdatesPageTypeDefaultArchivePageLink()
{
PageTypeAttribute attribute = new PageTypeAttribute();
IPageType pageType = new NativePageType();
pageType.DefaultArchivePageLink = new PageReference(1);
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.NewlyCreatedPageTypes.Add(pageType);
pageTypeUpdater.UpdateDefaultArchivePageLink(pageType, attribute);
Assert.Equal <PageReference>(null, pageType.DefaultArchivePageLink);
}
public void GivenDefinitionWithASpecifiedGuid_CreateNewPageType_ReturnsPageTypeWithThatGuid()
{
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(object),
Attribute = new PageTypeAttribute(Guid.NewGuid().ToString())
};
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
SetupPageTypeUpdaterWithFakePageTypeFactory(pageTypeUpdater);
IPageType returnedPageType = pageTypeUpdater.CreateNewPageType(definition);
Assert.Equal <Guid?>(definition.Attribute.Guid, returnedPageType.GUID);
}
public void Given_definition_without_a_specified_filename_CreateNewPageType_returns_PageType_with_default_filename()
{
PageTypeDefinition definition = PageTypeUpdaterTestsUtility.CreateBasicPageTypeDefinition();
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
SetupPageTypeUpdaterWithFakePageTypeFactory(pageTypeUpdater);
//Override the default filename to something without a slash in the beginning as
//the PageType.Filename set method requires that EPiServer is started if
//the filename begins with a slash
pageTypeUpdater.DefaultFilename = TestValueUtility.CreateRandomString();
IPageType returnedPageType = pageTypeUpdater.CreateNewPageType(definition);
Assert.Equal <string>(pageTypeUpdater.DefaultFilename, returnedPageType.FileName);
}
public void GivenAPageTypeAndANumberOfMinutes_WhenUpdateDefaultStopPublishOffsetIsCalled_ItUpdatesPageTypeDefaultStopPublishOffset(int defaultOffsetMinutes)
{
PageTypeAttribute attribute = new PageTypeAttribute();
attribute.DefaultStopPublishOffsetMinutes = defaultOffsetMinutes;
IPageType pageType = new NativePageType();
pageType.DefaultStopPublishOffset = new TimeSpan(0, 0, 1, 0);
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
pageTypeUpdater.UpdateDefaultStopPublishOffset(pageType, attribute);
TimeSpan expectedOffset = new TimeSpan(0, 0, defaultOffsetMinutes, 0);
Assert.Equal <TimeSpan>(expectedOffset, pageType.DefaultStopPublishOffset);
}
public void GivenPageTypeWithNoGuidOrSpecifiedName_GetExistingPageType_ReturnsPageTypeReturnedFromPageTypeFactoryLoad()
{
MockRepository mockRepository = new MockRepository();
PageTypeDefinition pageTypeDefinition = PageTypeUpdaterTestsUtility.CreateBasicPageTypeDefinition();
PageTypeRepository fakePageTypeRepository = mockRepository.Stub <PageTypeRepository>();
IPageType pageTypeFromFactory = new NativePageType();
pageTypeFromFactory.ID = 1;
fakePageTypeRepository.Expect(factory => factory.Load(pageTypeDefinition.Type.Name)).Return(pageTypeFromFactory);
fakePageTypeRepository.Replay();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Create(
PageTypeDefinitionLocatorFactory.Stub(), fakePageTypeRepository);
IPageType returnedPageType = pageTypeUpdater.GetExistingPageType(pageTypeDefinition);
fakePageTypeRepository.AssertWasCalled(factory => factory.Load(pageTypeDefinition.Type.Name));
Assert.Equal <int>(pageTypeFromFactory.ID, returnedPageType.ID);
}
public void GivenPageType_UpdatePageTypes_CallsPageTypeUpdaterUpdatePageType()
{
PageTypeSynchronizer synchronizer = PageTypeSynchronizerFactory.Create();
MockRepository fakes = new MockRepository();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Stub(fakes);
PageTypeDefinition definition = new PageTypeDefinition();
pageTypeUpdater.Stub(updater => updater.UpdatePageType(definition));
pageTypeUpdater.Replay();
synchronizer.PageTypeUpdater = pageTypeUpdater;
List <PageTypeDefinition> definitions = new List <PageTypeDefinition> {
definition
};
synchronizer.UpdatePageTypes(definitions);
pageTypeUpdater.AssertWasCalled(updater => updater.UpdatePageType(definition));
}
public void GivenExistingPageTypeFound_CreateNonExistingPageTypes_PageTypeUpdaterCreateNewPageTypeNotCalled()
{
MockRepository fakes = new MockRepository();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Stub(fakes);
PageTypeDefinition definition = new PageTypeDefinition();
List <PageTypeDefinition> definitions = new List <PageTypeDefinition>();
definitions.Add(definition);
pageTypeUpdater.Replay();
IPageTypeLocator pageTypeLocator = fakes.Stub <IPageTypeLocator>();
pageTypeLocator.Stub(locator => locator.GetExistingPageType(definition)).Return(new NativePageType());
pageTypeLocator.Replay();
PageTypeSynchronizer synchronizer = CreateSynchronizer(pageTypeLocator);
synchronizer.CreateNonExistingPageTypes(definitions);
pageTypeUpdater.AssertWasNotCalled(updater => updater.CreateNewPageType(Arg <PageTypeDefinition> .Is.Anything));
}
public void Initialize(InitializationEngine context)
{
var pageTypeLocator = new PageTypeLocator(new PageTypeFactory());
var pageTypeDefinitionLocator = new PageTypeDefinitionLocator(
new AppDomainAssemblyLocator());
var pageTypeUpdater = new PageTypeUpdater(
pageTypeDefinitionLocator,
new PageTypeFactory(),
new PageTypeValueExtractor(),
pageTypeLocator);
var pageTypePropertyUpdater = new PageTypePropertyUpdater(
new PageDefinitionFactory(),
new PageDefinitionTypeFactory(),
new TabFactory(),
new PropertySettingsRepository());
var tabDefinitionUpdater = new TabDefinitionUpdater(new TabFactory());
var tabLocator = new TabLocator(new AppDomainAssemblyLocator());
PageTypeSynchronizer synchronizer = new PageTypeSynchronizer(
pageTypeDefinitionLocator,
Configuration,
pageTypePropertyUpdater,
new PageTypeDefinitionValidator(new PageDefinitionTypeMapper(new PageDefinitionTypeFactory())),
PageTypeResolver.Instance,
pageTypeLocator,
pageTypeUpdater,
tabDefinitionUpdater,
tabLocator);
synchronizer.SynchronizePageTypes();
DataFactory.Instance.LoadedPage += DataFactory_LoadedPage;
DataFactory.Instance.LoadedChildren += DataFactory_LoadedChildren;
DataFactory.Instance.LoadedDefaultPageData += DataFactory_LoadedPage;
}
public void GivenPageTypeWithGuid_GetExistingPageType_ReturnsPageTypeReturnedFromPageTypeFactoryLoad()
{
MockRepository mockRepository = new MockRepository();
Type pageTypeType = typeof(object);
Guid pageTypeGuid = Guid.NewGuid();
PageTypeDefinition pageTypeDefinition = new PageTypeDefinition
{
Type = pageTypeType,
Attribute = new PageTypeAttribute(pageTypeGuid.ToString())
};
PageTypeRepository fakePageTypeRepository = mockRepository.Stub <PageTypeRepository>();
IPageType pageTypeFromFactory = new NativePageType();
pageTypeFromFactory.ID = 1;
fakePageTypeRepository.Expect(factory => factory.Load(pageTypeGuid)).Return(pageTypeFromFactory);
fakePageTypeRepository.Replay();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Create(
PageTypeDefinitionLocatorFactory.Stub(), fakePageTypeRepository);
IPageType returnedPageType = pageTypeUpdater.GetExistingPageType(pageTypeDefinition);
fakePageTypeRepository.AssertWasCalled(factory => factory.Load(pageTypeGuid));
Assert.Equal <int>(pageTypeFromFactory.ID, returnedPageType.ID);
}
public void GivenTypeArray_WhenUpdateAvailablePageTypesCalled_SetsPageTypeAllowedPageTypes()
{
PageTypeDefinition definition = PageTypeUpdaterTestsUtility.CreateBasicPageTypeDefinition();
definition.Attribute.AvailablePageTypes = new[] { typeof(object) };
IPageType existingPageType = new NativePageType();
MockRepository mocks = new MockRepository();
List <PageTypeDefinition> definitions = new List <PageTypeDefinition>();
PageTypeDefinition definitionToReturn = new PageTypeDefinition
{
Type = typeof(object),
Attribute = new PageTypeAttribute()
};
definitions.Add(definitionToReturn);
var pageTypeDefinitionLocator = PageTypeDefinitionLocatorFactory.Mock();
pageTypeDefinitionLocator.Setup(locator => locator.GetPageTypeDefinitions()).Returns(definitions);
PageTypeUpdater pageTypeUpdater = mocks.PartialMock <PageTypeUpdater>(
pageTypeDefinitionLocator.Object,
new PageTypeRepository(),
new PageTypeValueExtractor(),
new PageTypeLocator(new PageTypeRepository()));
IPageType allowedPageType = new NativePageType();
allowedPageType.ID = 1;
pageTypeUpdater.Stub(updater => updater.GetExistingPageType(definitionToReturn)).Return(allowedPageType);
pageTypeUpdater.Stub(updater => updater.IsValidPageType(typeof(object))).Return(true);
pageTypeUpdater.Replay();
pageTypeUpdater.UpdateAvailablePageTypes(existingPageType, definition.Attribute.AvailablePageTypes);
Assert.Equal <int[]>(new[] { 1 }, existingPageType.AllowedPageTypes);
}
public void WhenDefaultFilenameNotSet_DefaultsToDefaultPageTypeFilenameConstant()
{
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
Assert.Equal <string>(PageTypeUpdater.DefaultPageTypeFilename, pageTypeUpdater.DefaultFilename);
}
