public void SingletonServiceIsUnique(string registerName) // fixme - but what is LightInject actually doing { var register = RegisterSource.CreateRegister(registerName); // fixme // LightInject is 'unique' per serviceType+serviceName // but that's not how all containers work // and we should not rely on it // if we need unique, use RegisterUnique // for Core services that ppl may want to redefine in components, // it is important to be able to have a unique, singleton implementation, // and to redefine it - how it's done at container's level depends // on each container // redefine the service register.Register <IThing, Thing1>(Lifetime.Singleton); register.Register <IThing, Thing2>(Lifetime.Singleton); var factory = register.CreateFactory(); var things = factory.GetInstance <IEnumerable <IThing> >(); Assert.AreEqual(1, things.Count()); var thing = factory.GetInstance <IThing>(); Assert.IsInstanceOf <Thing2>(thing); }
public void CanTryGetUnregistered(string registerName) { var register = RegisterSource.CreateRegister(registerName); var factory = register.CreateFactory(); var thing = factory.TryGetInstance <IThing>(); Assert.IsNull(thing); }
public void CanResolveEmptyEnumerable(string registerName) { var register = RegisterSource.CreateRegister(registerName); var factory = register.CreateFactory(); var things = factory.GetInstance <IEnumerable <IThing> >(); Assert.IsEmpty(things); }
public void CanInjectEmptyEnumerable(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <WithEnumerable>(); var factory = register.CreateFactory(); var withEnumerable = factory.GetInstance <WithEnumerable>(); Assert.IsEmpty(withEnumerable.Things); }
public void CannotRegisterAndGetImplicitService(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <Thing>(); var factory = register.CreateFactory(); var thing = factory.TryGetInstance <IThing>(); Assert.IsNull(thing); }
[Ignore("Only LightInject supports this.")] // fixme - but we rely on it! public void CanRegisterAndGetAllImplicitService(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <Thing>(); var factory = register.CreateFactory(); var thing = factory.GetAllInstances <IThing>(); Assert.IsNotEmpty(thing); }
[Ignore("Only LightInject supports this.")] // fixme - but we rely on it! public void CanRegisterAndInjectImplicitService(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <Thing>(); register.Register <WithEnumerable>(); var factory = register.CreateFactory(); var withEnumerable = factory.GetInstance <WithEnumerable>(); Assert.IsNotEmpty(withEnumerable.Things); }
public void CanRegisterManySingletonsAndGetAll(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing1>(Lifetime.Singleton); register.Register <IThing, Thing2>(Lifetime.Singleton); var factory = register.CreateFactory(); var things = factory.GetAllInstances <IThing>(); Assert.AreEqual(2, things.Count()); }
public void CanResolveEnumerableOfSingletons(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing1>(Lifetime.Singleton); register.Register <IThing, Thing2>(Lifetime.Singleton); var factory = register.CreateFactory(); var things = factory.GetInstance <IEnumerable <IThing> >(); Assert.AreEqual(2, things.Count()); }
public void CanInjectLazy(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing>(); register.Register <WithLazy>(); var factory = register.CreateFactory(); var withLazy = factory.GetInstance <WithLazy>(); var thing = withLazy.Thing; Assert.IsNotNull(thing); }
public void CannotGetUnregistered(string registerName) { var register = RegisterSource.CreateRegister(registerName); var factory = register.CreateFactory(); try { var thing = factory.GetInstance <IThing>(); Assert.Fail("Expected an exception."); } catch { /* expected */ } }
public void CanInjectEnumerable(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing1>(); register.Register <IThing, Thing2>(); register.Register <WithEnumerable>(); var factory = register.CreateFactory(); var withEnumerable = factory.GetInstance <WithEnumerable>(); Assert.AreEqual(2, withEnumerable.Things.Count()); }
public void CanResolveAll(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing1>(); register.Register <IThing, Thing2>(); register.Register <WithEnumerable>(); var factory = register.CreateFactory(); var things = factory.GetAllInstances <IThing>(); Assert.AreEqual(2, things.Count()); }
public void CannotRegisterAndGetAllImplicitService(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <Thing>(); var factory = register.CreateFactory(); var things = factory.GetAllInstances <IThing>(); Assert.AreEqual(0, things.Count()); // lightInject: is zero with option EnableVariance set to false // others: always zero }
public void CanResolveLazy(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing>(); var factory = register.CreateFactory(); var lazything = factory.GetInstance <Lazy <IThing> >(); Assert.IsNotNull(lazything); var thing = lazything.Value; Assert.IsNotNull(thing); }
public void CanTryGetEnumerableOfBase(string registerName) // NOT SUPPORTED DON'T DO IT { var register = RegisterSource.CreateRegister(registerName); register.Register <Thing1>(); register.Register <Thing2>(); var factory = register.CreateFactory(); var things = factory.TryGetInstance <IEnumerable <ThingBase> >(); Assert.AreEqual(2, things.Count()); }
public void CanRegisterAndGetTransient(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing>(); var factory = register.CreateFactory(); var thing = factory.GetInstance <IThing>(); Assert.IsNotNull(thing); var thing2 = factory.GetInstance <IThing>(); Assert.IsNotNull(thing2); Assert.AreNotSame(thing, thing2); }
public void CanRegisterAndGetSingletonWithFactory(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing>(f => new Thing(), Lifetime.Singleton); var factory = register.CreateFactory(); var thing = factory.GetInstance <IThing>(); Assert.IsNotNull(thing); var thing2 = factory.GetInstance <IThing>(); Assert.IsNotNull(thing2); Assert.AreSame(thing, thing2); }
public void CanInjectEnumerableOfBase(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <Thing1>(); register.Register <Thing2>(); register.Register <NeedThings>(); var factory = register.CreateFactory(); var needThings = factory.GetInstance <NeedThings>(); Assert.AreEqual(2, needThings.Things.Count()); }
public void SingletonImplementationIsNotUnique(string registerName) { var register = RegisterSource.CreateRegister(registerName); // define two implementations register.Register <Thing1>(Lifetime.Singleton); register.Register <Thing2>(Lifetime.Singleton); var factory = register.CreateFactory(); var things = factory.GetInstance <IEnumerable <IThing> >(); Assert.AreEqual(2, things.Count()); Assert.IsNull(factory.TryGetInstance <IThing>()); }
public void CanRegisterAndGetInstance(string registerName) { var register = RegisterSource.CreateRegister(registerName); var instance = new Thing(); register.RegisterInstance <IThing>(instance); var factory = register.CreateFactory(); var thing = factory.GetInstance <IThing>(); Assert.IsNotNull(thing); Assert.AreSame(instance, thing); var thing2 = factory.GetInstance <IThing>(); Assert.IsNotNull(thing2); Assert.AreSame(thing, thing2); }
public void ActualInstanceIsNotUnique(string registerName) { var register = RegisterSource.CreateRegister(registerName); // define two instances register.RegisterInstance(typeof(Thing1), new Thing1()); register.RegisterInstance(typeof(Thing1), new Thing2()); var factory = register.CreateFactory(); var things = factory.GetInstance <IEnumerable <IThing> >(); //Assert.AreEqual(2, things.Count()); Assert.AreEqual(1, things.Count()); // well, yes they are unique? Assert.IsNull(factory.TryGetInstance <IThing>()); }
public void CanReRegisterAndGetInstance(string registerName) { var register = RegisterSource.CreateRegister(registerName); var instance = new Thing(); register.RegisterInstance <IThing>(instance); var instance2 = new Thing(); register.RegisterInstance <IThing>(instance2); // Castle throws here var factory = register.CreateFactory(); var thing = factory.GetInstance <IThing>(); Assert.IsNotNull(thing); Assert.AreSame(instance2, thing); // what we get is unspecified here var thing2 = factory.GetInstance <IThing>(); Assert.IsNotNull(thing2); Assert.AreSame(thing, thing2); }
public void CanInjectAll(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.RegisterFor <IThing, int>(_ => new Thing1()); register.RegisterFor <IThing, string>(_ => new Thing2()); register.Register(f => new Things(f), Lifetime.Singleton); var factory = register.CreateFactory(); // this can be injected var things = factory.GetInstance <Things>(); // no need to use the factory var thingForInt = things.For <int>(); var thingForString = things.For <string>(); Assert.IsInstanceOf <Thing1>(thingForInt); Assert.IsInstanceOf <Thing2>(thingForString); }
public void CanGetTransientInstanceFor(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.RegisterFor <IThing, int>(_ => new Thing1()); register.RegisterFor <IThing, string>(_ => new Thing2()); var factory = register.CreateFactory(); var thingForInt = factory.GetInstanceFor <IThing, int>(); var thingForString = factory.GetInstanceFor <IThing, string>(); Assert.IsInstanceOf <Thing1>(thingForInt); Assert.IsInstanceOf <Thing2>(thingForString); var thingForInt2 = factory.GetInstanceFor <IThing, int>(); var thingForString2 = factory.GetInstanceFor <IThing, string>(); Assert.AreNotSame(thingForInt, thingForInt2); Assert.AreNotSame(thingForString, thingForString2); }
public void CanRegisterManySingletonsAndGetOne(string registerName) { var register = RegisterSource.CreateRegister(registerName); register.Register <IThing, Thing1>(Lifetime.Singleton); register.Register <IThing, Thing2>(Lifetime.Singleton); var factory = register.CreateFactory(); var thing = factory.GetInstance <IThing>(); // what we get is unspecified here Assert.IsNotNull(thing); Assert.IsInstanceOf <Thing1>(thing); var thing2 = factory.GetInstance <IThing>(); Assert.IsNotNull(thing2); Assert.AreSame(thing, thing2); var things = factory.GetAllInstances <IThing>(); Assert.AreEqual(2, things.Count()); }