public void ExtendedActivator_ShouldThrowOnNonInterfaceArguments()
{
ConstructorInfo ctor = typeof(MyClass).GetConstructor(new[] { typeof(IDisposable), typeof(IList), typeof(int) });
//
// Sima Get() hivas nem fog mukodni (nem interface parameter).
//
Assert.Throws <ArgumentException>(() => ServiceActivator.Get(ctor), Resources.INVALID_CONSTRUCTOR);
//
// Ne mock-oljuk az injector-t h a megfelelo kiveteleket kapjuk
//
using (IServiceContainer container = new ServiceContainer())
{
IInjector injector = container
.Factory <IDisposable>(i => new Disposable(), Lifetime.Scoped)
.Factory <IList>(i => new List <object>(), Lifetime.Scoped)
.CreateInjector();
//
// Ez mukodne viszont nem adtuk meg a nem interface parametert.
//
Assert.Throws <ArgumentException>(() => ServiceActivator.GetExtended(ctor).Invoke(injector, new Dictionary <string, object>(0)), Resources.PARAMETER_NOT_AN_INTERFACE);
}
}
/// <summary>
/// Instantiates the given class.
/// </summary>
/// <param name="self">The injector itself.</param>
/// <param name="class">The class to be instantiated.</param>
/// <param name="explicitArgs">The explicit arguments (in the form of [parameter name - parameter value]). Explicit arguments won't be resolved by the injector.</param>
/// <returns>The new instance.</returns>
/// <remarks>
/// <list type="bullet">
/// <item><description>The <paramref name="class"/> you passed must have only one public constructor or you must annotate the appropriate one with the <see cref="ServiceActivatorAttribute"/>.</description></item>
/// <item><description>Constructor parameteres that are not present in the <paramref name="explicitArgs"/> are treated as a normal dependency.</description></item>
/// <item><description>The caller is responsible for freeing the returned instance.</description></item>
/// </list>
/// </remarks>
/// <exception cref="ServiceNotFoundException">One or more dependecies could not be found.</exception>
public static object Instantiate(this IInjector self, Type @class, IReadOnlyDictionary <string, object?>?explicitArgs = null)
{
Ensure.Parameter.IsNotNull(self, nameof(self));
Ensure.Parameter.IsNotNull(@class, nameof(@class));
return(ServiceActivator.GetExtended(@class).Invoke(self, explicitArgs ?? new Dictionary <string, object?>(0)));
}
public void ExtendedActivator_ExplicitArgumentsMayContainNonInterfaceValues()
{
const int TEN = 10;
ConstructorInfo ctor = typeof(MyClass).GetConstructor(new[] { typeof(IDisposable), typeof(IList), typeof(int) });
var mockInjector = new Mock <IInjector>(MockBehavior.Strict);
mockInjector
.Setup(i => i.Get(It.IsAny <Type>(), It.IsAny <string>()))
.Returns <Type, string>((type, name) => null);
MyClass obj = ServiceActivator.GetExtended(ctor).Invoke(mockInjector.Object, new Dictionary <string, object> {
{ "int", TEN }
}) as MyClass;
Assert.That(obj, Is.Not.Null);
Assert.That(obj.Int, Is.EqualTo(TEN));
}
public void ExtendedActivator_ShouldHandleOptionalArguments()
{
var mockInjector = new Mock <IInjector>(MockBehavior.Strict);
mockInjector
.Setup(i => i.Get(typeof(IList <IDictionary>), null))
.Returns(new List <IDictionary>());
mockInjector
.Setup(i => i.TryGet(typeof(IDisposable), null))
.Returns(null);
Func <IInjector, IReadOnlyDictionary <string, object>, object> factory = ServiceActivator
.GetExtended(typeof(MyInterceptor));
Assert.DoesNotThrow(() => factory.Invoke(mockInjector.Object, new Dictionary <string, object>()));
mockInjector.Verify(i => i.Get(typeof(IList <IDictionary>), null), Times.Once);
mockInjector.Verify(i => i.TryGet(typeof(IDisposable), null), Times.Once);
}
public void ExtendedActivator_ShouldHandleExplicitArguments()
{
var mockInjector = new Mock <IInjector>(MockBehavior.Strict);
mockInjector.Setup(i => i.Get(It.IsAny <Type>(), It.IsAny <string>()));
Func <IInjector, IReadOnlyDictionary <string, object>, object> factory = ServiceActivator
.GetExtended(typeof(List <string>).GetConstructor(new[] { typeof(int) }));
object lst = factory(mockInjector.Object, new Dictionary <string, object>
{
{ "capacity", 10 }
});
Assert.That(lst, Is.InstanceOf <List <string> >());
Assert.That(((List <string>)lst).Capacity, Is.EqualTo(10));
mockInjector.Verify(i => i.Get(It.IsAny <Type>(), It.IsAny <string>()), Times.Never);
}
public void GetExtended_ShouldSupportProxyTypes()
{
Type proxy = ProxyGenerator <IList <IDictionary>, MyInterceptor> .GetGeneratedType();
Func <IInjector, IReadOnlyDictionary <string, object>, object> factory = ServiceActivator.GetExtended(proxy);
var mockInjector = new Mock <IInjector>(MockBehavior.Strict);
mockInjector
.Setup(i => i.Get(typeof(IList <IDictionary>), null))
.Returns(new List <IDictionary>());
mockInjector
.Setup(i => i.TryGet(typeof(IDisposable), null))
.Returns(null);
Assert.DoesNotThrow(() => factory.Invoke(mockInjector.Object, new Dictionary <string, object>()));
mockInjector.Verify(i => i.Get(typeof(IList <IDictionary>), null), Times.Once);
mockInjector.Verify(i => i.TryGet(typeof(IDisposable), null), Times.Once);
}
public void ExtendedActivator_ExplicitArgumentsShouldSuppressTheInjectorInvocation()
{
var mockInjector = new Mock <IInjector>(MockBehavior.Strict);
mockInjector
.Setup(i => i.Get(It.IsAny <Type>(), It.IsAny <string>()))
.Returns <Type, string>((type, name) => null);
Func <IInjector, IReadOnlyDictionary <string, object>, object> factory = ServiceActivator
.GetExtended(typeof(MyClass).GetConstructor(new[] { typeof(IDisposable), typeof(IList) }));
object obj = factory(mockInjector.Object, new Dictionary <string, object>
{
{ "dep2", null }
});
Assert.That(obj, Is.InstanceOf <MyClass>());
mockInjector.Verify(i => i.Get(It.Is <Type>(t => t == typeof(IDisposable)), null), Times.Once);
mockInjector.Verify(i => i.Get(It.Is <Type>(t => t == typeof(IList)), It.IsAny <string>()), Times.Never);
}
public void Activator_ShouldResolveDependencies(Type dep1, string name1, Type dep2, string name2)
{
var mockDisposable = new Mock <IDisposable>();
var mockServiceFactory = new Mock <IList>();
var mockInjector = new Mock <IInjector>(MockBehavior.Strict);
foreach (Func <IInjector, object> activator in GetActivators(typeof(MyClass).GetConstructor(new[] { dep1, dep2 })))
{
mockInjector
.Setup(i => i.Get(It.IsAny <Type>(), It.IsAny <string>()))
.Returns <Type, string>((type, name) =>
{
if (type == typeof(IDisposable) && name == name1)
{
return(mockDisposable.Object);
}
if (type == typeof(IList) && name == name2)
{
return(mockServiceFactory.Object);
}
Assert.Fail("Unknown type");
return(null);
});
MyClass instance = (MyClass)activator(mockInjector.Object);
Assert.That(instance, Is.Not.Null);
Assert.That(instance.Dep1, Is.SameAs(mockDisposable.Object));
Assert.That(instance.Dep2, Is.SameAs(mockServiceFactory.Object));
mockInjector.Verify(i => i.Get(It.Is <Type>(t => t == typeof(IDisposable)), It.Is <string>(n => n == name1)), Times.Once);
mockInjector.Verify(i => i.Get(It.Is <Type>(t => t == typeof(IList)), It.Is <string>(n => n == name2)), Times.Once);
mockInjector.Verify(i => i.Get(It.IsAny <Type>(), It.IsAny <string>()), Times.Exactly(2));
mockInjector.Reset();
}
IEnumerable <Func <IInjector, object> > GetActivators(ConstructorInfo ctor)
{
Func <IInjector, Type, object> factory = ServiceActivator.Get(ctor);
yield return(injector => factory(injector, null));
Func <IInjector, IReadOnlyDictionary <string, object>, object> factoryEx = ServiceActivator.GetExtended(ctor);
yield return(injector => factoryEx(injector, new Dictionary <string, object>(0)));
}
}
public void GetExtended_ShouldCache()
{
Assert.AreSame(ServiceActivator.GetExtended(typeof(Disposable)), ServiceActivator.GetExtended(typeof(Disposable)));
Assert.AreSame(ServiceActivator.GetExtended(typeof(Disposable).GetApplicableConstructor()), ServiceActivator.GetExtended(typeof(Disposable).GetApplicableConstructor()));
}
public void GetExtended_ShouldValidate()
{
Assert.Throws <ArgumentException>(() => ServiceActivator.GetExtended(typeof(IDisposable)), Resources.PARAMETER_NOT_A_CLASS);
Assert.Throws <ArgumentException>(() => ServiceActivator.GetExtended(typeof(IList <>)), Resources.PARAMETER_IS_GENERIC);
Assert.Throws <ArgumentException>(() => ServiceActivator.GetExtended(typeof(AbstractClass)), Resources.PARAMETER_IS_ABSTRACT);
}
