public override void SetUp()
{
base.SetUp();
activator = new ContentActivator(stateChanger = new N2.Edit.Workflow.StateChanger(), notifier = new ItemNotifier(), new InterceptingProxyFactory());
activator.Initialize(new[] { new ItemDefinition(typeof(Definitions.PersistableItem)), new ItemDefinition(typeof(Definitions.PersistableItem1b)) });
}
public FakeEngine(params Type[] types)
{
AddComponentInstance <ITypeFinder>(new FakeTypeFinder(types));
var definitionManager = TestSupport.SetupDefinitions(types.Where(t => typeof(ContentItem).IsAssignableFrom(t)).ToArray());
AddComponentInstance <IDefinitionManager>(definitionManager);
var adapterProvider = new ContentAdapterProvider(this, Resolve <ITypeFinder>());
AddComponentInstance <IContentAdapterProvider>(adapterProvider);
var itemRepository = new FakeContentItemRepository();
AddComponentInstance <IRepository <ContentItem> >(itemRepository);
AddComponentInstance <IContentItemRepository>(itemRepository);
var webContext = new ThreadContext();
AddComponentInstance <IWebContext>(webContext);
var host = new Host(webContext, 1, 1);
AddComponentInstance <IHost>(host);
var security = new FakeSecurityManager();
AddComponentInstance <ISecurityManager>(security);
var source = new ContentSource(security, new [] { new DatabaseSource(host, itemRepository) });
AddComponentInstance(source);
AddComponentInstance <IPersister>(new ContentPersister(source, itemRepository));
AddComponentInstance <IWebContext>(webContext);
var proxyFactory = new InterceptingProxyFactory();
AddComponentInstance <IProxyFactory>(proxyFactory);
var activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), new ItemNotifier(), proxyFactory);
AddComponentInstance <ContentActivator>(activator);
activator.Initialize(definitionManager.GetDefinitions());
}
public void Start()
{
activator.ItemCreated += activator_ItemCreated;
stateChanger.StateChanged += stateChanger_StateChanged;
activator.Initialize(definitionProviders.SelectMany(dp => dp.GetDefinitions()).Select(d => d.ItemType));
}
public override void SetUp()
{
base.SetUp();
activator = new ContentActivator(stateChanger = new N2.Edit.Workflow.StateChanger(), notifier = new ItemNotifier(), new InterceptingProxyFactory());
activator.Initialize(new[] { new ItemDefinition(typeof(Definitions.PersistableItem)), new ItemDefinition(typeof(Definitions.PersistableItem1b)) });
}
public static N2.Edit.Versioning.ContentVersionRepository CreateVersionRepository(ref IPersister persister, ref ContentActivator activator, params Type[] definedTypes)
{
if (persister == null)
{
persister = SetupFakePersister();
}
var definitions = SetupDefinitions(definedTypes);
var parser = new UrlParser(persister, new ThreadContext(), new Host(new ThreadContext(), new HostSection()), new ConnectionMonitor(), new HostSection());
var proxyFactory = new InterceptingProxyFactory();
if (activator == null)
{
activator = new ContentActivator(new StateChanger(), new ItemNotifier(), proxyFactory);
activator.Initialize(definitions.GetDefinitions());
}
var importer = new Importer(persister,
new ItemXmlReader(definitions,
activator,
persister.Repository),
new Fakes.FakeMemoryFileSystem());
var exporter = new Exporter(
new ItemXmlWriter(
definitions,
parser,
new FakeMemoryFileSystem()));
return(new ContentVersionRepository(
new FakeRepository <ContentVersion>(),
exporter,
importer,
parser,
proxyFactory));
}
public DefinitionManager(IDefinitionProvider[] definitionProviders, ContentActivator activator, StateChanger changer, DefinitionMap map)
{
this.definitionProviders = definitionProviders.OrderBy(dp => dp.SortOrder).ToArray();
this.activator = activator;
this.stateChanger = changer;
this.map = map;
activator.Initialize(GetDefinitions());
}
public DefinitionManager(IDefinitionProvider[] definitionProviders, ITemplateProvider[] templateProviders, ContentActivator activator, StateChanger changer)
{
this.definitionProviders = definitionProviders.OrderBy(dp => dp.SortOrder).ToArray();
this.providers = templateProviders.OrderBy(tp => tp.SortOrder).ToArray();
this.activator = activator;
this.stateChanger = changer;
activator.Initialize(GetDefinitions());
}
public DefinitionManager(IDefinitionProvider[] definitionProviders, ITemplateProvider[] providers, ContentActivator activator, StateChanger changer)
{
this.definitionProviders = definitionProviders;
this.providers = providers;
this.activator = activator;
this.stateChanger = changer;
activator.Initialize(GetDefinitions().Select(d => d.ItemType));
}
public static void Setup(out IDefinitionProvider[] definitionProviders, out IDefinitionManager definitions, out ContentActivator activator, out IItemNotifier notifier, out InterceptingProxyFactory proxyFactory, params Type[] itemTypes)
{
var map = new DefinitionMap();
definitionProviders = SetupDefinitionProviders(map, itemTypes);
notifier = new ItemNotifier();
proxyFactory = new InterceptingProxyFactory();
activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, proxyFactory);
definitions = new DefinitionManager(definitionProviders, activator, new StateChanger(), new DefinitionMap());
((DefinitionManager)definitions).Start();
activator.Initialize(definitions.GetDefinitions());
}
public void Start()
{
activator.Initialize(definitionProviders.SelectMany(dp => dp.GetDefinitions()).Select(d => d.ItemType));
activator.ItemCreated += new EventHandler <ItemEventArgs>(activator_ItemCreated);
}
