public void SingletonLifetime(IFrameworkAdapter framework)
{
framework.RegisterSingleton <IService, IndependentService>();
var instance1 = framework.Resolve <IService>();
var instance2 = framework.Resolve <IService>();
Assert.Same(instance1, instance2);
}
public void TransientLifetime(IFrameworkAdapter framework)
{
framework.RegisterTransient <IService, IndependentService>();
var instance1 = framework.Resolve <IService>();
var instance2 = framework.Resolve <IService>();
Assert.NotSame(instance1, instance2);
}
public void RegistrationAtAnyStage(IFrameworkAdapter framework)
{
framework.Register <IService, IndependentService>();
framework.Resolve <IService>();
framework.Register <IService2, IndependentService2>();
var resolved = framework.Resolve <IService2>();
Assert.NotNull(resolved);
}
public void OpenGenericTypes(IFrameworkAdapter framework)
{
framework.RegisterTransient(typeof(IGenericService <>), typeof(GenericService <>));
var resolved = framework.Resolve <IGenericService <int> >();
Assert.NotNull(resolved);
}
public void IndependentServiceRegisteredAsSelf(IFrameworkAdapter framework)
{
framework.Register <IndependentService>();
var component = framework.Resolve <IndependentService>();
Assert.NotNull(component);
}
public void PropertyDependencyIsOptional(IFrameworkAdapter framework)
{
framework.Register <ServiceWithSimplePropertyDependency>();
var component = framework.Resolve <ServiceWithSimplePropertyDependency>();
Assert.Null(component.Service);
}
public void ConstructorDependency(IFrameworkAdapter framework)
{
framework.Register <IService, IndependentService>();
framework.Register <ServiceWithSimpleConstructorDependency>();
var component = framework.Resolve <ServiceWithSimpleConstructorDependency>();
Assert.NotNull(component.Service);
Assert.IsAssignableFrom <IndependentService>(component.Service);
}
public void PrebuiltInstance(IFrameworkAdapter framework)
{
var instance = new IndependentService();
framework.Register <IService>(instance);
var resolved = framework.Resolve <IService>();
Assert.Same(instance, resolved);
}
public void TransientFactoryUsedBySingletonStillCreatesTransient(IFrameworkAdapter framework)
{
framework.RegisterTransient <IService, IndependentService>();
framework.RegisterSingleton <ServiceWithFuncConstructorDependency>();
var service = framework.Resolve <ServiceWithFuncConstructorDependency>();
var first = service.Factory();
var second = service.Factory();
Assert.NotSame(first, second);
}
public void ConstructorDependencyUsingInstance(IFrameworkAdapter framework)
{
var instance = new IndependentService();
framework.Register <IService>(instance);
framework.Register <ServiceWithSimpleConstructorDependency>();
var dependent = framework.Resolve <ServiceWithSimpleConstructorDependency>();
Assert.Same(instance, dependent.Service);
}
public void FactoryWithNoParameters(IFrameworkAdapter framework)
{
framework.Register <IService, IndependentService>();
framework.Register <ServiceWithSimpleConstructorDependency>();
var func = framework.Resolve <Func <ServiceWithSimpleConstructorDependency> >();
Assert.NotNull(func);
var result = func();
Assert.NotNull(result);
}
private void AssertGivesCorrectExceptionWhenResolvingRecursive <TService>(IFrameworkAdapter framework)
{
try {
framework.Resolve <TService>();
}
catch (Exception ex) {
Debug.WriteLine(framework.GetType().Name + " throws following on recursion: " + ex);
return;
}
throw new AssertException("No exception for recursion, either this use case is not supported or there is some other issue.");
}
public void ReasonableConstructorSelection(IFrameworkAdapter framework)
{
framework.Register <IService, IndependentService>();
framework.Register <ServiceWithMultipleConstructors>();
var resolved = framework.Resolve <ServiceWithMultipleConstructors>();
Assert.NotNull(resolved);
Assert.Equal(
ServiceWithMultipleConstructors.ConstructorNames.MostResolvable,
resolved.UsedConstructorName
);
}
public void AssertResolvesListDependencyFor <TTestComponent>(IFrameworkAdapter framework)
where TTestComponent : IServiceWithListDependency <IEnumerable <IService> >
{
framework.Register <IService, IndependentService>();
framework.Register <TTestComponent>();
var resolved = framework.Resolve <TTestComponent>();
Assert.NotNull(resolved);
Assert.NotNull(resolved.Services);
Assert.Equal(1, resolved.Services.Count());
Assert.IsAssignableFrom <IndependentService>(resolved.Services.First());
}
public void FactoryWithParameter(IFrameworkAdapter framework)
{
framework.Register <IService, IndependentService>();
framework.Register <ServiceWithTwoConstructorDependencies>();
var service2 = new IndependentService2();
var func = framework.Resolve <Func <IService2, ServiceWithTwoConstructorDependencies> >();
Assert.NotNull(func);
var result = func(service2);
Assert.NotNull(result);
Assert.Same(service2, result.Service2);
}
public static TService Resolve <TService>(this IFrameworkAdapter container)
{
return((TService)container.Resolve(typeof(TService)));
}