public void ShouldBeAbleToAddGenericLemmingsOfDifferentTypes()
{
var serviceLemming = Lemming.From <ServiceWithGenericDependency>();
serviceLemming.Injections.OfType <ReferenceInjection>().Single().ReferencedLemming = "Test1";
var anotherServiceLemming = Lemming.From <AnotherServiceWithGenericDependency>();
anotherServiceLemming.Injections.OfType <ReferenceInjection>().Single().ReferencedLemming = "Test2";
var test1 = Lemming.From(typeof(GenericService <>));
test1.Name = "Test1";
var test2 = Lemming.From(typeof(GenericService <>));
test2.Name = "Test2";
var lemmings = new[] { serviceLemming, anotherServiceLemming, test1, test2 };
objectFactory.Configure(lemmings, new Injection[0]);
var service = objectFactory.GetObject <ServiceWithGenericDependency>();
Assert.IsNotNull(service);
Assert.IsNotNull(service.GenericDependency);
var service2 = objectFactory.GetObject <ServiceWithGenericDependency>();
Assert.IsNotNull(service2);
Assert.IsNotNull(service2.GenericDependency);
}
public void ShouldAddInjectionsDueAttributes()
{
var lemming = Lemming.From(typeof(Service));
Assert.AreEqual(1, lemming.Injections.Count());
Assert.AreEqual("Dependency", lemming.Injections.Single().Property.Name);
}
public void NonGenericLemmingUniqueNameShouldBeEqualToName()
{
var lemming = Lemming.From(typeof(Service));
Assert.AreEqual("NailsFramework.Tests.IoC.Lemmings.Service", lemming.Name);
Assert.AreEqual("NailsFramework.Tests.IoC.Lemmings.Service", lemming.UniqueName);
}
public void GenericLemmings()
{
objectFactory.Configure(new[] { Lemming.From(typeof(GenericService <>)) }, new Injection[0]);
var service = objectFactory.GetObject <GenericService <string> >();
Assert.IsNotNull(service);
}
public void SingletonsShouldBeSingletonsWhenGettedFromDifferentTypes()
{
objectFactory.Configure(new[] { Lemming.From <ServiceDependency>() }, new Injection[0]);
var o1 = objectFactory.GetObject <ServiceDependency>();
var o2 = objectFactory.GetObject <IServiceDependency>();
Assert.AreEqual(o1, o2);
}
public void InstanceInjection()
{
objectFactory.Configure(new[] { Lemming.From <ServiceDependency>() }, new Injection[0]);
var instance = new NonLemmingWithInjections();
objectFactory.Inject(instance);
Assert.IsNotNull(instance.Dependency);
Assert.AreEqual("test123", instance.Value);
}
public void ShouldSetInjectionNamesWithAttributes()
{
var lemming = Lemming.From(typeof(NamedLemming));
Assert.AreEqual(lemming.Injections.Count(), 1);
var reference = (ReferenceInjection)lemming.Injections.Single();
Assert.AreEqual("Dependency", reference.Property.Name);
Assert.AreEqual("lalala", reference.ReferencedLemming);
}
public void NonSingletonsShouldNotBeSingletons()
{
var lemming = Lemming.From <ServiceDependency>();
lemming.Singleton = false;
objectFactory.Configure(new[] { lemming }, new Injection[0]);
var o1 = objectFactory.GetObject <ServiceDependency>();
var o2 = objectFactory.GetObject <ServiceDependency>();
Assert.AreNotEqual(o1, o2);
}
public void ConfigurationInjectionsOverridenKey()
{
var lemming = Lemming.From(typeof(LemmingWithValuesFromConfigurationWithOverridenKey));
Assert.AreEqual(lemming.Injections.Count(), 1);
var value = (ConfigurationInjection)lemming.Injections.Single();
Assert.AreEqual("ConfigurationValue", value.Property.Name);
Assert.AreEqual("test123", value.Value);
}
public void ConfigurationInjectionsShouldHaveValueAsAppSetingsWithLemmingPropertyAsKeyByDefault()
{
var lemming = Lemming.From(typeof(LemmingWithValuesFromConfiguration));
Assert.AreEqual(lemming.Injections.Count(), 1);
var reference = (ConfigurationInjection)lemming.Injections.Single();
Assert.AreEqual("ConfigurationValue", reference.Property.Name);
Assert.AreEqual("testConfigurationValueForDefaultKey", reference.Value);
}
public void GenericReferenceInjections()
{
objectFactory.Configure(new[]
{
Lemming.From(typeof(GenericService <>)),
Lemming.From(typeof(ServiceWithGenericDependency))
}, new Injection[0]);
var service = objectFactory.GetObject <ServiceWithGenericDependency>();
Assert.IsInstanceOf <GenericService <string> >(service.GenericDependency);
}
public void GetFromTypeNonGeneric()
{
objectFactory.Configure(new[]
{
Lemming.From(typeof(Service)),
Lemming.From(typeof(ServiceDependency))
}, new Injection[0]);
var service = objectFactory.GetObject(typeof(Service));
Assert.IsNotNull(service);
}
public void SingletonsShouldBeSingletonsWhenGettedFromTypeAndName()
{
var lemming = Lemming.From <ServiceDependency>();
lemming.Name = "Test";
objectFactory.Configure(new[] { lemming }, new Injection[0]);
var o1 = objectFactory.GetObject <ServiceDependency>();
var o2 = objectFactory.GetObject("Test");
Assert.AreEqual(o1, o2);
}
private void InjectTestProperties()
{
var lemming = Lemming.From(GetType());
foreach (var injection in lemming.Injections)
{
if (!configured || !lemming.Singleton)
{
injection.Accept(this);
}
}
}
public void ConfigurationInjectionForGenericNamedLemmingDefaultNonGenericKey()
{
var lemming = Lemming.From(typeof(GenericLemmingWithValuesFromConfiguration <string>));
lemming.Name = "GenericLemming2";
Assert.AreEqual(lemming.Injections.Count(), 1);
var reference = (ConfigurationInjection)lemming.Injections.Single();
Assert.AreEqual("ConfigurationValue", reference.Property.Name);
Assert.AreEqual("generic2-value", reference.Value);
}
public void ConfigurationInjectionForNamedLemmingDefaultKey()
{
var lemming = Lemming.From(typeof(LemmingWithValuesFromConfiguration));
lemming.Name = "Bar";
Assert.AreEqual(lemming.Injections.Count(), 1);
var reference = (ConfigurationInjection)lemming.Injections.Single();
Assert.AreEqual("ConfigurationValue", reference.Property.Name);
Assert.AreEqual("bar-value", reference.Value);
}
public void ReferenceInjections()
{
objectFactory.Configure(new[]
{
Lemming.From(typeof(Service)),
Lemming.From(typeof(ServiceDependency))
}, new Injection[0]);
var service = objectFactory.GetObject <Service>();
Assert.IsInstanceOf <ServiceDependency>(service.Dependency);
}
public void GetGenericByNameAndTypeParameters()
{
objectFactory.Configure(new[]
{
Lemming.From(typeof(GenericService <>))
}, new Injection[0]);
var service = objectFactory.GetGenericObject <string>("NailsFramework.Tests.IoC.Lemmings.GenericService");
Assert.IsNotNull(service);
Assert.IsInstanceOf <IGenericService <string> >(service);
}
public void GetFromInterface()
{
objectFactory.Configure(new[]
{
Lemming.From(typeof(Service)),
Lemming.From(typeof(ServiceDependency))
}, new Injection[0]);
var service = objectFactory.GetObject <IService>();
Assert.IsNotNull(service);
}
public void GetFromTypeGeneric()
{
objectFactory.Configure(new[]
{
Lemming.From(typeof(ServiceWithGenericDependency)),
Lemming.From(typeof(GenericService <>))
}, new Injection[0]);
var service = objectFactory.GetObject <GenericService <string> >();
Assert.IsNotNull(service);
}
public void ValueInjections()
{
var property = typeof(LemmingWithValuesFromConfiguration).GetProperty("ConfigurationValue");
var lemming = Lemming.From(typeof(LemmingWithValuesFromConfiguration));
lemming.RemoveInjectionOf(property);
lemming.Inject(new ValueInjection(property, "test"));
objectFactory.Configure(new[] { lemming }, new Injection[0]);
var service = objectFactory.GetObject <LemmingWithValuesFromConfiguration>();
Assert.AreEqual("test", service.ConfigurationValue);
}
public void GetFromNameNonGeneric()
{
var lemming = Lemming.From(typeof(Service));
lemming.Name = "test";
objectFactory.Configure(new[]
{
lemming,
Lemming.From(typeof(ServiceDependency))
}, new Injection[0]);
var service = objectFactory.GetObject("test");
Assert.IsNotNull(service);
}
public void GetObjects()
{
var lemming = Lemming.From(typeof(ServiceDependency));
lemming.Name = "test";
objectFactory.Configure(new[]
{
lemming,
Lemming.From(typeof(ServiceDependency)),
}, new Injection[0]);
var services = objectFactory.GetObjects <IServiceDependency>();
Assert.AreEqual(2, services.Count());
}
public void GenericLemmingDefinitionUniqueNameShouldThrowInvalid()
{
var lemming = Lemming.From(typeof(GenericService <>));
Assert.Throws <InvalidOperationException>(() => { var name = lemming.UniqueName; });
}
public void ShouldConfigureNoSingletonLemmingsFromAttribute()
{
var lemming = Lemming.From(typeof(NoSingletonLemming));
Assert.IsFalse(lemming.Singleton);
}
public void TypeNameAsLemmingNameByDefault()
{
var lemming = Lemming.From(typeof(Service));
Assert.AreEqual(lemming.Name, "NailsFramework.Tests.IoC.Lemmings.Service");
}
public void SingletonByDefault()
{
var lemming = Lemming.From(typeof(Service));
Assert.IsTrue(lemming.Singleton);
}
public void GenericLemmingUniqueNameShouldContainTypeParameters()
{
var lemming = Lemming.From(typeof(GenericService <>)).MakeGenericLemming(new[] { typeof(string) });
Assert.AreEqual("NailsFramework.Tests.IoC.Lemmings.GenericService<System.String>", lemming.UniqueName);
}
public void LemmingsShouldIgnoreStaticDependencies()
{
var lemming = Lemming.From(typeof(ClassWithStaticDependencies));
Assert.AreEqual(lemming.Injections.Count(), 0);
}
public void ShouldSetLemmingName()
{
var lemming = Lemming.From(typeof(NamedLemming));
Assert.AreEqual(lemming.Name, "sarasa");
}
