public void TestBeforeInject() { var eventCalled = false; IReflectionCache cache = new ReflectionCache(); IBinder binder = new Binder(); IInjector injector = new Injector(cache, binder); var instanceToInject = new MockClassVerySimple(); injector.beforeInject += delegate(IInjector source, ref object instance, ReflectedClass reflectedClass) { //The if below is just to avoid checking when injecting on MockIClass. if (reflectedClass.type != typeof(MockClassVerySimple)) return; Assert.AreEqual(injector, source); Assert.AreEqual(instanceToInject, instance); Assert.IsNull(instanceToInject.field); eventCalled = true; }; binder.Bind<IMockInterface>().To<MockIClass>(); injector.Inject(instanceToInject); Assert.IsTrue(eventCalled); Assert.AreEqual(typeof(MockIClass), instanceToInject.field.GetType()); }
public void TestAfterResolve() { var eventCalled = false; IReflectionCache cache = new ReflectionCache(); IBinder binder = new Binder(); IInjector injector = new Injector(cache, binder); IMockInterface resolvedInstance = null; injector.afterResolve += delegate(IInjector source, Type type, InjectionMember member, object parentInstance, object identifier, ref object resolutionInstance) { Assert.AreEqual(injector, source); Assert.AreEqual(typeof(IMockInterface), type); Assert.AreEqual(InjectionMember.None, member); Assert.IsNull(parentInstance); Assert.IsNull(identifier); Assert.IsNotNull(resolutionInstance); resolvedInstance = (IMockInterface)resolutionInstance; eventCalled = true; return false; }; binder.Bind<IMockInterface>().To<MockIClass>(); var instance = injector.Resolve<IMockInterface>(); Assert.IsTrue(eventCalled); Assert.AreEqual(typeof(MockIClass), instance.GetType()); Assert.AreEqual(resolvedInstance, instance); }
public void TestCacheAll() { var cache = new ReflectionCache(); cache.CacheFromBinder(this.binder); Assert.True(cache.Contains(typeof(MockIClassWithAttributes))); Assert.True(cache.Contains(typeof(MockClassWithDependencies))); }
public void TestAddType() { var cache = new ReflectionCache(); var type = typeof(MockIClassWithoutAttributes); cache.Add(type); Assert.True(cache.Contains(type)); }
public void TestBindingEvaluation() { var eventCalled = false; IReflectionCache cache = new ReflectionCache(); IBinder binder = new Binder(); IInjector injector = new Injector(cache, binder); injector.bindingEvaluation += delegate(IInjector source, ref BindingInfo binding) { Assert.AreEqual(injector, source); Assert.NotNull(binding); eventCalled = true; return new MockIClassWithoutAttributes(); }; binder.Bind<IMockInterface>().To<MockIClass>(); var instance = injector.Resolve<IMockInterface>(); Assert.IsTrue(eventCalled); Assert.AreEqual(typeof(MockIClassWithoutAttributes), instance.GetType()); }