public void GivenPageTypeUpdationDisabled_SynchronizePageTypes_OnlyAddsExistingPageTypesToResolver()
{
MockRepository fakes = new MockRepository();
List <PageTypeDefinition> allPageTypeDefinitions = new List <PageTypeDefinition>
{
new PageTypeDefinition(),
new PageTypeDefinition()
};
List <PageTypeDefinition> nonExistingPageTypesDefinitions = new List <PageTypeDefinition> {
allPageTypeDefinitions[0]
};
PageTypeBuilderConfiguration configuration = fakes.Stub <PageTypeBuilderConfiguration>();
configuration.Stub(config => config.DisablePageTypeUpdation).Return(true);
configuration.Replay();
IPageTypeDefinitionLocator pageTypeDefinitionLocator = CreatePageTypeDefinitionLocatorStub(allPageTypeDefinitions);
PageTypeSynchronizer pageTypeSynchronizer = GetPageTypePartiallyMockedSynchronizer(pageTypeDefinitionLocator, configuration);
pageTypeSynchronizer.Stub(synchronizer => synchronizer.GetNonExistingPageTypes(allPageTypeDefinitions)).Return(nonExistingPageTypesDefinitions);
pageTypeSynchronizer.Replay();
pageTypeSynchronizer.SynchronizePageTypes();
pageTypeSynchronizer.AssertWasCalled(synchronizer => synchronizer.AddPageTypesToResolver(Arg <List <PageTypeDefinition> > .Matches(list => list.Count == 1)));
}
public void Constructor_SetsTabDefinitionUpdaterPropertyToInstanceOfTabDefinitionUpdater()
{
PageTypeSynchronizer synchronizer = CreatePageTypeSynchronizer();
Assert.NotNull(synchronizer.TabDefinitionUpdater);
Assert.Equal <Type>(typeof(TabDefinitionUpdater), synchronizer.TabDefinitionUpdater.GetType());
}
public void GivenPageTypeDefinition_AddPageTypesToResolver_AddsToResolver()
{
List <PageTypeDefinition> definitions = new List <PageTypeDefinition>();
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(string),
Attribute = new PageTypeAttribute()
};
definitions.Add(definition);
IPageType pageType = new NativePageType();
pageType.ID = 1;
MockRepository fakes = new MockRepository();
IPageTypeLocator pageTypeLocator = fakes.Stub <IPageTypeLocator>();
pageTypeLocator.Stub(locator => locator.GetExistingPageType(definition)).Return(pageType);
pageTypeLocator.Replay();
PageTypeResolver resolver = new PageTypeResolver();
PageTypeSynchronizer synchronizer = PageTypeSynchronizerFactory.Create(resolver, pageTypeLocator);
synchronizer.AddPageTypesToResolver(definitions);
Assert.Equal <Type>(definition.Type, resolver.GetPageTypeType(pageType.ID));
}
public void GivenPageType_UpdatePageTypePropertyDefinitions_CallsPageTypePropertyUpdaterUpdatePageTypePropertyDefinitions()
{
PageTypeDefinition definition = new PageTypeDefinition();
MockRepository fakes = new MockRepository();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Stub(fakes);
IPageType pageType = new NativePageType();
PageTypePropertyUpdater pageTypePropertyUpdater = PageTypePropertyUpdaterFactory.Stub(fakes);
pageTypePropertyUpdater.Stub(updater => updater.UpdatePageTypePropertyDefinitions(pageType, definition));
pageTypePropertyUpdater.Replay();
IPageTypeLocator pageTypeLocator = fakes.Stub <IPageTypeLocator>();
pageTypeLocator.Stub(locator => locator.GetExistingPageType(definition)).Return(pageType);
pageTypeLocator.Replay();
List <PageTypeDefinition> definitions = new List <PageTypeDefinition> {
definition
};
PageTypeSynchronizer synchronizer =
PageTypeSynchronizerFactory.Create(pageTypePropertyUpdater, pageTypeLocator);
synchronizer.PageTypeUpdater = pageTypeUpdater;
synchronizer.UpdatePageTypePropertyDefinitions(definitions);
pageTypePropertyUpdater.AssertWasCalled(updater => updater.UpdatePageTypePropertyDefinitions(pageType, definition));
}
public void Constructor_SetsPageTypeDefinitionValidatorPropertyToInstanceOfPageTypeDefinitionValidator()
{
PageTypeSynchronizer synchronizer = CreatePageTypeSynchronizer();
Assert.NotNull(synchronizer.PageTypeDefinitionValidator);
Assert.Equal <Type>(typeof(PageTypeDefinitionValidator), synchronizer.PageTypeDefinitionValidator.GetType());
}
public void Constructor_SetsPageTypeResolverPropertyToInstanceOfPageTypeResolver()
{
PageTypeSynchronizer synchronizer = CreatePageTypeSynchronizer();
Assert.NotNull(synchronizer.PageTypeResolver);
Assert.Equal <Type>(typeof(PageTypeResolver), synchronizer.PageTypeResolver.GetType());
Assert.Equal <PageTypeResolver>(PageTypeResolver.Instance, synchronizer.PageTypeResolver);
}
public void SynchronizePageTypes_CallsPageTypeDefinitionLocatorGetPageTypeDefinitions()
{
List <PageTypeDefinition> pageTypeDefinitions = new List <PageTypeDefinition>();
IPageTypeDefinitionLocator pageTypeDefinitionLocator = CreatePageTypeDefinitionLocatorStub(pageTypeDefinitions);
PageTypeSynchronizer pageTypeSynchronizer = GetPageTypePartiallyMockedSynchronizer(pageTypeDefinitionLocator);
pageTypeSynchronizer.SynchronizePageTypes();
pageTypeDefinitionLocator.AssertWasCalled(locator => locator.GetPageTypeDefinitions(), options => options.Repeat.AtLeastOnce());
}
public void SynchronizePageTypes_UpdatesPageTypePropertyDefinitionsForPageTypes()
{
List <PageTypeDefinition> pageTypeDefinitions = new List <PageTypeDefinition>();
IPageTypeDefinitionLocator pageTypeDefinitionLocator = CreatePageTypeDefinitionLocatorStub(pageTypeDefinitions);
PageTypeSynchronizer pageTypeSynchronizer = GetPageTypePartiallyMockedSynchronizer(pageTypeDefinitionLocator);
pageTypeSynchronizer.SynchronizePageTypes();
pageTypeSynchronizer.AssertWasCalled(synchronizer => synchronizer.UpdatePageTypePropertyDefinitions(pageTypeDefinitions));
}
public void SynchronizePageTypes_CreatesNonExistingPageTypes()
{
List <PageTypeDefinition> pageTypeDefinitions = new List <PageTypeDefinition>();
IPageTypeDefinitionLocator pageTypeDefinitionLocator = CreatePageTypeDefinitionLocatorStub(pageTypeDefinitions);
PageTypeSynchronizer pageTypeSynchronizer = GetPageTypePartiallyMockedSynchronizer(pageTypeDefinitionLocator);
pageTypeSynchronizer.SynchronizePageTypes();
pageTypeSynchronizer.AssertWasCalled(synchronizer => synchronizer.CreateNonExistingPageTypes(pageTypeDefinitions));
}
public void SynchronizePageTypes_AddsPageTypesToResolver()
{
List <PageTypeDefinition> pageTypeDefinitions = new List <PageTypeDefinition>();
IPageTypeDefinitionLocator pageTypeDefinitionLocator = CreatePageTypeDefinitionLocatorStub(pageTypeDefinitions);
PageTypeSynchronizer pageTypeSynchronizer = GetPageTypePartiallyMockedSynchronizer(pageTypeDefinitionLocator);
pageTypeSynchronizer.SynchronizePageTypes();
pageTypeSynchronizer.AssertWasCalled(synchronizer => synchronizer.AddPageTypesToResolver(pageTypeDefinitions));
}
public void GivenDefinition_ValidatePageTypeDefinitions_CallsValidatorsValidatePageTypeDefinitionsMethod()
{
List <PageTypeDefinition> definitions = new List <PageTypeDefinition>();
PageTypeSynchronizer synchronizer = CreateSynchronizer();
MockRepository fakes = new MockRepository();
PageTypeDefinitionValidator definitionValidator = fakes.Stub <PageTypeDefinitionValidator>((PageDefinitionTypeMapper)null);
definitionValidator.Stub(validator => validator.ValidatePageTypeDefinitions(definitions));
definitionValidator.Replay();
synchronizer.PageTypeDefinitionValidator = definitionValidator;
synchronizer.ValidatePageTypeDefinitions(definitions);
definitionValidator.AssertWasCalled(validator => validator.ValidatePageTypeDefinitions(definitions));
}
private PageTypeSynchronizer GetPageTypePartiallyMockedSynchronizer(IPageTypeDefinitionLocator definitionLocator, PageTypeBuilderConfiguration configuration)
{
MockRepository fakes = new MockRepository();
PageTypeSynchronizer pageTypeSynchronizer = PageTypeSynchronizerFactory.PartialMock(fakes, definitionLocator, configuration);
pageTypeSynchronizer.Stub(synchronizer => synchronizer.UpdateTabDefinitions());
pageTypeSynchronizer.Stub(synchronizer => synchronizer.ValidatePageTypeDefinitions(Arg <List <PageTypeDefinition> > .Is.Anything));
pageTypeSynchronizer.Stub(synchronizer => synchronizer.CreateNonExistingPageTypes(Arg <List <PageTypeDefinition> > .Is.Anything));
pageTypeSynchronizer.Stub(synchronizer => synchronizer.UpdatePageTypes(Arg <List <PageTypeDefinition> > .Is.Anything));
pageTypeSynchronizer.Stub(synchronizer => synchronizer.UpdatePageTypePropertyDefinitions(Arg <List <PageTypeDefinition> > .Is.Anything));
pageTypeSynchronizer.Stub(synchronizer => synchronizer.AddPageTypesToResolver(Arg <List <PageTypeDefinition> > .Is.Anything));
pageTypeSynchronizer.Replay();
return(pageTypeSynchronizer);
}
public void Initialize(InitializationEngine context)
{
var containerBuilder = new ContainerBuilder();
var defaultBootstrapper = new DefaultBootstrapper();
defaultBootstrapper.Configure(containerBuilder);
var container = containerBuilder.Build();
PageTypeSynchronizer synchronizer = container.Resolve <PageTypeSynchronizer>();
synchronizer.SynchronizePageTypes();
DataFactory.Instance.LoadedPage += DataFactory_LoadedPage;
DataFactory.Instance.LoadedChildren += DataFactory_LoadedChildren;
DataFactory.Instance.LoadedDefaultPageData += DataFactory_LoadedPage;
}
public void GivenPageTypeUpdationDisabled_SynchronizePageTypes_DoesNotUpdatePageTypePropertyDefinitions()
{
MockRepository fakes = new MockRepository();
PageTypeBuilderConfiguration configuration = fakes.Stub <PageTypeBuilderConfiguration>();
configuration.Stub(config => config.DisablePageTypeUpdation).Return(true);
configuration.Replay();
IPageTypeDefinitionLocator pageTypeDefinitionLocator = CreatePageTypeDefinitionLocatorStub(new List <PageTypeDefinition>());
PageTypeSynchronizer pageTypeSynchronizer = GetPageTypePartiallyMockedSynchronizer(pageTypeDefinitionLocator, configuration);
pageTypeSynchronizer.Stub(synchronizer =>
synchronizer.GetNonExistingPageTypes(Arg <List <PageTypeDefinition> > .Is.Anything)).Return(new List <PageTypeDefinition>());
pageTypeSynchronizer.SynchronizePageTypes();
pageTypeSynchronizer.AssertWasNotCalled(synchronizer => synchronizer.UpdatePageTypePropertyDefinitions(Arg <List <PageTypeDefinition> > .Is.Anything));
}
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 UpdateTabDefinitions_CallsTabDefinitionUpdaterWithDefinedTabs()
{
PageTypeSynchronizer pageTypeSynchronizer = PageTypeSynchronizerFactory.Create();
MockRepository fakes = new MockRepository();
TabLocator fakeTabLocator = TabLocatorFactory.Stub(fakes);
List <Tab> tabs = new List <Tab> {
new TestTab()
};
fakeTabLocator.Stub(locator => locator.GetDefinedTabs()).Return(tabs);
fakeTabLocator.Replay();
pageTypeSynchronizer.TabLocator = fakeTabLocator;
TabDefinitionUpdater fakeTabDefinitionUpdater = TabDefinitionUpdaterFactory.Stub(fakes);
fakeTabDefinitionUpdater.Stub(updater => updater.UpdateTabDefinitions(Arg <List <Tab> > .Is.Anything));
fakeTabDefinitionUpdater.Replay();
pageTypeSynchronizer.TabDefinitionUpdater = fakeTabDefinitionUpdater;
pageTypeSynchronizer.UpdateTabDefinitions();
pageTypeSynchronizer.TabLocator.AssertWasCalled(updater => updater.GetDefinedTabs());
pageTypeSynchronizer.TabDefinitionUpdater.AssertWasCalled(updater => updater.UpdateTabDefinitions(tabs));
}
