public void ManyResolverCannotRemoveTypeOnceFrozen()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
resolver.RemoveType <Resolved2>(); // throws
}
public void ManyResolverCannotAddInvalidType()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>());
//resolver.AddType<Resolved4>(); // does not compile
resolver.AddType(typeof(Resolved4)); // throws
}
public void ManyResolverCannotRemoveInvalidType()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
//resolver.RemoveType<Resolved4>(); // does not compile
resolver.RemoveType(typeof(Resolved4)); // throws
}
public void ManyResolverCannotAddTypeOnceFrozen()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>());
Resolution.Freeze();
resolver.AddType <Resolved1>();
}
public void ManyResolverCannotInsertBeforeTypeOnceFrozen()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
resolver.InsertTypeBefore <Resolved2, Resolved3>();
}
public void ManyResolverCannotInsertBeforeTypeOnceFrozen()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
resolver.InsertTypeBefore <Resolved2, Resolved3>();
}
public void ManyResolverCannotAddTypeAgain()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>());
resolver.AddType <Resolved1>();
resolver.AddType <Resolved1>();
}
public void ManyResolverCannotRemoveTypeOnceFrozen()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
resolver.RemoveType <Resolved2>(); // throws
}
public void ManyResolverCannotAddTypeAgain()
{
var resolver = new ManyResolver();
resolver.AddType <Resolved1>();
resolver.AddType <Resolved1>();
}
public void ManyResolverCannotAddInvalidType()
{
var resolver = new ManyResolver();
//resolver.AddType<Resolved4>(); // does not compile
resolver.AddType(typeof(Resolved4)); // throws
}
public void ManyResolverHttpRequestLifetimeScope()
{
var httpContextFactory = new FakeHttpContextFactory("~/Home");
var httpContext = httpContextFactory.HttpContext;
var resolver = new ManyResolver(httpContext);
resolver.AddType <Resolved1>();
resolver.AddType <Resolved2>();
Resolution.Freeze();
var values = resolver.ResolvedObjects;
Assert.AreEqual(2, values.Count());
Assert.IsInstanceOf <Resolved1>(values.ElementAt(0));
Assert.IsInstanceOf <Resolved2>(values.ElementAt(1));
var values2 = resolver.ResolvedObjects;
Assert.AreEqual(2, values2.Count());
Assert.AreSame(values.ElementAt(0), values2.ElementAt(0));
Assert.AreSame(values.ElementAt(1), values2.ElementAt(1));
httpContextFactory.HttpContext.Items.Clear(); // new context
var values3 = resolver.ResolvedObjects;
Assert.AreEqual(2, values3.Count());
Assert.AreNotSame(values.ElementAt(0), values3.ElementAt(0));
Assert.AreNotSame(values.ElementAt(1), values3.ElementAt(1));
}
public void ManyResolverCannotAddTypeOnceFrozen()
{
var resolver = new ManyResolver();
Resolution.Freeze();
resolver.AddType <Resolved1>();
}
public void ManyResolverCannotGetValuesBeforeFreezeUnless()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
resolver.CanResolveBeforeFrozen = true;
var values = resolver.ResolvedObjects;
}
public void ManyResolverCannotGetValuesBeforeFreezeUnless()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
resolver.CanResolveBeforeFrozen = true;
var values = resolver.ResolvedObjects;
}
public void ManyResolverCannotInsertBeforeInvalidType()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
//resolver.InsertTypeBefore<Resolved2, Resolved4>(); // does not compile
resolver.InsertTypeBefore(typeof(Resolved2), typeof(Resolved4)); // throws
}
public void ManyResolverCannotInsertBeforeInvalidType()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
//resolver.InsertTypeBefore<Resolved2, Resolved4>(); // does not compile
resolver.InsertTypeBefore(typeof(Resolved2), typeof(Resolved4)); // throws
}
public void ManyResolverContainsTypes()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
Assert.IsTrue(resolver.ContainsType <Resolved1>());
Assert.IsTrue(resolver.ContainsType <Resolved2>());
Assert.IsFalse(resolver.ContainsType <Resolved3>());
//Assert.IsFalse(resolver.ContainsType<Resolved4>()); // does not compile
}
public void ManyResolverCanClearBeforeFreeze()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>());
resolver.AddType <Resolved1>();
resolver.AddType <Resolved2>();
resolver.Clear();
Assert.IsFalse(resolver.ContainsType <Resolved1>());
Assert.IsFalse(resolver.ContainsType <Resolved2>());
}
public void ManyResolverCanInsertBeforeTypeBeforeFreeze()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
resolver.InsertTypeBefore <Resolved2, Resolved3>();
Assert.IsTrue(resolver.ContainsType <Resolved1>());
Assert.IsTrue(resolver.ContainsType <Resolved2>());
Assert.IsTrue(resolver.ContainsType <Resolved3>());
}
public void ManyResolverCanClearBeforeFreeze()
{
var resolver = new ManyResolver();
resolver.AddType <Resolved1>();
resolver.AddType <Resolved2>();
resolver.Clear();
Assert.IsFalse(resolver.ContainsType <Resolved1>());
Assert.IsFalse(resolver.ContainsType <Resolved2>());
}
public void ManyResolverCanInsertBeforeTypeBeforeFreeze()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
resolver.InsertTypeBefore <Resolved2, Resolved3>();
Assert.IsTrue(resolver.ContainsType <Resolved1>());
Assert.IsTrue(resolver.ContainsType <Resolved2>());
Assert.IsTrue(resolver.ContainsType <Resolved3>());
}
public void ManyResolverCanGetValuesOnceFrozen()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
var values = resolver.ResolvedObjects;
Assert.AreEqual(2, values.Count());
Assert.IsInstanceOf <Resolved1>(values.ElementAt(0));
Assert.IsInstanceOf <Resolved2>(values.ElementAt(1));
}
public void ManyResolverContainsTypes()
{
var resolver = new ManyResolver(
new ActivatorServiceProvider(), Mock.Of <ILogger>(),
new Type[] { typeof(Resolved1), typeof(Resolved2) });
Assert.IsTrue(resolver.ContainsType <Resolved1>());
Assert.IsTrue(resolver.ContainsType <Resolved2>());
Assert.IsFalse(resolver.ContainsType <Resolved3>());
//Assert.IsFalse(resolver.ContainsType<Resolved4>()); // does not compile
}
public void ManyResolverWeightedResolution()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
var values = resolver.SortedResolvedObjects;
Assert.AreEqual(2, values.Count());
Assert.IsInstanceOf <Resolved2>(values.ElementAt(0));
Assert.IsInstanceOf <Resolved1>(values.ElementAt(1));
}
public void ManyResolverDefaultOrderOfTypes()
{
var resolver = new ManyResolver();
resolver.AddType <Resolved3>();
resolver.InsertType <Resolved1>(0);
resolver.InsertTypeBefore <Resolved3, Resolved2>();
Resolution.Freeze();
var values = resolver.ResolvedObjects;
Assert.AreEqual(3, values.Count());
Assert.IsInstanceOf <Resolved1>(values.ElementAt(0));
Assert.IsInstanceOf <Resolved2>(values.ElementAt(1));
Assert.IsInstanceOf <Resolved3>(values.ElementAt(2));
}
public void ManyResolverDefaultLifetimeScopeIsApplication()
{
var resolver = new ManyResolver(new ActivatorServiceProvider(), Mock.Of <ILogger>(), new Type[] { typeof(Resolved1), typeof(Resolved2) });
Resolution.Freeze();
var values = resolver.ResolvedObjects;
Assert.AreEqual(2, values.Count());
Assert.IsInstanceOf <Resolved1>(values.ElementAt(0));
Assert.IsInstanceOf <Resolved2>(values.ElementAt(1));
var values2 = resolver.ResolvedObjects;
Assert.AreEqual(2, values2.Count());
Assert.AreSame(values.ElementAt(0), values2.ElementAt(0));
Assert.AreSame(values.ElementAt(1), values2.ElementAt(1));
}
public void ManyResolverTransientLifetimeScope()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) }, ObjectLifetimeScope.Transient);
Resolution.Freeze();
var values = resolver.ResolvedObjects;
Assert.AreEqual(2, values.Count());
Assert.IsInstanceOf <Resolved1>(values.ElementAt(0));
Assert.IsInstanceOf <Resolved2>(values.ElementAt(1));
var values2 = resolver.ResolvedObjects;
Assert.AreEqual(2, values2.Count());
Assert.AreNotSame(values.ElementAt(0), values2.ElementAt(0));
Assert.AreNotSame(values.ElementAt(1), values2.ElementAt(1));
}
public void ManyResolverCannotGetValuesBeforeFreeze()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
var values = resolver.ResolvedObjects;
}
public void ManyResolverCannotInsertBeforeTypeAgain()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1), typeof(Resolved2) });
resolver.InsertTypeBefore <Resolved2, Resolved1>();
}
public void ManyResolverCannotInsertBeforeAbsentType()
{
var resolver = new ManyResolver(new Type[] { typeof(Resolved1) });
resolver.InsertTypeBefore <Resolved2, Resolved3>();
}
