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());
}
