public void DisableMissing()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer6), typeof(Composer8) }; // 8 disables 7 which is not in the list
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count);
Assert.AreEqual(typeof(Composer6), Composed[0]);
Assert.AreEqual(typeof(Composer8), Composed[1]);
}
public void Requires2A()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(3, Composed.Count);
Assert.AreEqual(typeof(Composer4), Composed[0]);
Assert.AreEqual(typeof(Composer2), Composed[1]);
}
public void Boot2()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer20, Composer21>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 21 is required by 20
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer21, Composer20>(), Composed);
}
public void Boot1B()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer1, Composer2, Composer3, Composer4>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 2 is Core and requires 4
// 3 is User - stays with RuntimeLevel.Run
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer1, Composer4, Composer2, Composer3>(), Composed);
}
public void BrokenRequired()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer2, Composer4, Composer13>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 2 is Core and requires 4
// 13 is required by 1
// 1 is missing
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer4, Composer2, Composer13>(), Composed);
}
public void AttributesPriorities()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer26) };
DisableComposerAttribute[] enableDisableAttributes = new[] { new DisableComposerAttribute(typeof(Composer26)) };
var composers = new ComposerGraph(composition, types, enableDisableAttributes, Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(0, Composed.Count); // 26 gone
types = new[] { typeof(Composer26), typeof(Composer27) }; // 26 disabled by assembly attribute, enabled by 27
composers = new ComposerGraph(composition, types, enableDisableAttributes, Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count); // both
Assert.AreEqual(typeof(Composer26), Composed[0]);
Assert.AreEqual(typeof(Composer27), Composed[1]);
}
public void AllComposers()
{
ITypeFinder typeFinder = TestHelper.GetTypeFinder();
var typeLoader = new TypeLoader(typeFinder, new VaryingRuntimeHash(), AppCaches.Disabled.RuntimeCache, new DirectoryInfo(TestHelper.GetHostingEnvironment().MapPathContentRoot(Constants.SystemDirectories.TempData)), Mock.Of <ILogger <TypeLoader> >(), Mock.Of <IProfiler>());
IServiceCollection register = MockRegister();
var builder = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
var allComposers = typeLoader.GetTypes <IComposer>().ToList();
var types = allComposers.Where(x => x.FullName.StartsWith("Umbraco.Core.") || x.FullName.StartsWith("Umbraco.Web")).ToList();
var composers = new ComposerGraph(builder, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Dictionary <Type, List <Type> > requirements = composers.GetRequirements();
string report = ComposerGraph.GetComposersReport(requirements);
Console.WriteLine(report);
IEnumerable <Type> composerTypes = composers.SortComposers(requirements);
foreach (Type type in composerTypes)
{
Console.WriteLine(type);
}
}
public void WeakDependencies()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer10) };
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer10), Composed[0]);
types = new[] { typeof(Composer11) };
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
Console.WriteLine("throws:");
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Dictionary <Type, List <Type> > requirements = composers.GetRequirements(false);
Console.WriteLine(ComposerGraph.GetComposersReport(requirements));
types = new[] { typeof(Composer2) };
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
Console.WriteLine("throws:");
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
requirements = composers.GetRequirements(false);
Console.WriteLine(ComposerGraph.GetComposersReport(requirements));
types = new[] { typeof(Composer12) };
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer12), Composed[0]);
}
public void Requires2B()
{
IServiceCollection register = MockRegister();
TypeLoader typeLoader = MockTypeLoader();
IServiceProvider factory = MockFactory();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
ComponentCollectionBuilder builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
ComponentCollection components = builder.CreateCollection(factory);
Assert.AreEqual(3, Composed.Count);
Assert.AreEqual(typeof(Composer4), Composed[0]);
Assert.AreEqual(typeof(Composer2), Composed[1]);
Assert.AreEqual(typeof(Composer9), Composed[2]);
}
public void BrokenRequire()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer1, Composer2, Composer3>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
try
{
// 2 is Core and requires 4
// 4 is missing
// => throw
composers.Compose();
Assert.Fail("Expected exception.");
}
catch (Exception e)
{
Assert.AreEqual("Broken composer dependency: Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Components.ComponentTests+Composer2 -> Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Components.ComponentTests+Composer4.", e.Message);
}
}
public void Boot1A()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer1, Composer2, Composer4>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 2 is Core and requires 4
// 3 is User
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer1, Composer4, Composer2>(), Composed);
IServiceProvider factory = MockFactory(m =>
{
m.Setup(x => x.GetService(It.Is <Type>(t => t == typeof(ISomeResource)))).Returns(() => new SomeResource());
m.Setup(x => x.GetService(It.IsAny <Type>())).Returns <Type>((type) =>
{
if (type == typeof(Composer1))
{
return(new Composer1());
}
if (type == typeof(Composer5))
{
return(new Composer5());
}
if (type == typeof(Component5))
{
return(new Component5(new SomeResource()));
}
if (type == typeof(IProfilingLogger))
{
return(new ProfilingLogger(Mock.Of <ILogger <ProfilingLogger> >(), Mock.Of <IProfiler>()));
}
if (type == typeof(ILogger <ComponentCollection>))
{
return(Mock.Of <ILogger <ComponentCollection> >());
}
throw new NotSupportedException(type.FullName);
});
});
ComponentCollectionBuilder builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
ComponentCollection components = builder.CreateCollection(factory);
Assert.IsEmpty(components);
components.Initialize();
Assert.IsEmpty(Initialized);
components.Terminate();
Assert.IsEmpty(Terminated);
}
