/// <summary>
/// Used to create the Container for the HttpHandler. Not used by Console Compiler and T4CSS
/// </summary>
/// <param name="configuration">Configuration for the HttpHandler</param>
/// <returns></returns>
private PandoraContainer CreateContainer(DotlessConfiguration configuration)
{
var container = new PandoraContainer();
container.Register(p =>
{
p.Service<ILessSource>()
.Implementor(configuration.LessSource);
p.Service<ICache>()
.Implementor<CssCache>();
p.Service<IRequest>()
.Implementor<Request>();
if (!configuration.CacheEnabled)
{
p.Service<IResponse>()
.Implementor<CssResponse>();
}
else
{
p.Service<IResponse>()
.Implementor<CachedCssResponse>();
p.Service<ILessEngine>()
.Implementor<AspCacheDecorator>();
}
});
return RegisterCoreServices(container, configuration);
}
public void NoRegistrationIsRequiredToInstantiateConcreteClassWithoutDependencies()
{
var container = new PandoraContainer(new ComponentStore());
var dependencies = container.Resolve <ClassWithNoDependencies>();
Assert.IsType <ClassWithNoDependencies>(dependencies);
}
public void CanSplitGraph()
{
/*
* Dotty Graph:
*
* digraph G {
* a [label="IService :: A"] ;
* a -> b [label="service1"] ;
* a -> c [label="service2"] ;
* b [label="IService :: B"] ;
* b -> d ;
* d [label="IService :: C"] ;
* c [label="IService :: B"] ;
* c -> f ;
* f [label="IService :: C"] ;
* }
*/
var store = new ComponentStore();
store.Add <IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.IsType(typeof(ClassWithTwoDependenciesOnItsOwnService), service);
}
public IServiceLocator GetContainer(DotlessConfiguration configuration)
{
Container = new PandoraContainer();
Container.Register(pandora => RegisterServices(pandora, configuration));
return new CommonServiceLocatorAdapter(Container);
}
public void ClassWithDependencyOnConcreteClassResolves()
{
var container = new PandoraContainer(new ComponentStore());
var dependency =
container.Resolve <GenericWithDependency <ClassWithNoDependencies> >();
Assert.IsType <ClassWithNoDependencies>(dependency.Dependency);
}
public IServiceLocator GetContainer(DotlessConfiguration configuration)
{
Container = new PandoraContainer();
Container.Register(pandora => RegisterServices(pandora, configuration));
return(new CommonServiceLocatorAdapter(Container));
}
public void CanResolveConcreteType()
{
var store = new ComponentStore();
store.Add<ClassWithNoDependencies, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
Assert.DoesNotThrow(() => container.Resolve<ClassWithNoDependencies>());
}
public void ConcreteClassInstantiationCanBeTurnedOff()
{
var behaviorConfiguration = new BehaviorConfiguration
{
EnableImplicitTypeInstantiation = false
};
var container = new PandoraContainer(behaviorConfiguration);
Assert.Throws<ServiceNotFoundException>(() => container.Resolve<ClassWithNoDependencies>());
}
public void CanResolveConcreteType()
{
var store = new ComponentStore();
store.Add <ClassWithNoDependencies, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
container.Resolve <ClassWithNoDependencies>();
}
public void ImplicitlyInstantiatedConcreteClassHasDefaultLifestyle()
{
var container = new PandoraContainer(new ComponentStore());
var c1 = container.Resolve<ClassWithNoDependencies>();
var c2 = container.Resolve<ClassWithNoDependencies>();
Assert.Same(c1, c2);
}
public void ThrowsExceptionIfDependencyCouldNotBeSatisfied()
{
var store = new ComponentStore();
store.Add <ClassWithOneDependency, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws <DependencyMissingException>(() => container.Resolve <ClassWithOneDependency>());
}
public void ImplicitlyInstantiatedConcreteClassHasDefaultLifestyle()
{
var container = new PandoraContainer(new ComponentStore());
var c1 = container.Resolve <ClassWithNoDependencies>();
var c2 = container.Resolve <ClassWithNoDependencies>();
Assert.Same(c1, c2);
}
public void CanResolveClassWithoutDependencies()
{
var componentStore = new ComponentStore();
componentStore.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(componentStore);
var result = container.Resolve<IService>();
Assert.IsType<ClassWithNoDependencies>(result);
}
public void CanResolveWhenGivenTwoConstructorsWhereOneCantBeSatisfied()
{
var store = new ComponentStore();
store.Add <IService4, ClassWithMultipleConstructors>();
var container = new PandoraContainer(store);
container.Resolve <IService4>();
}
public void ContainerSetup()
{
var store = new ComponentStore();
//Add components to the store.
store.Register(p => p.Service <IService>()
.Implementor <ClassWithNoDependencies>());
//Create the container
var container = new PandoraContainer(store);
}
public void ExcludesServicesThatCantBeCreated()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll<IService>();
Assert.Equal(0, enumerable.Count());
}
public void ConcreteClassInstantiationCanBeTurnedOff()
{
var behaviorConfiguration = new BehaviorConfiguration
{
EnableImplicitTypeInstantiation = false
};
var container = new PandoraContainer(behaviorConfiguration);
Assert.Throws <ServiceNotFoundException>(() => container.Resolve <ClassWithNoDependencies>());
}
public void ThrowsDependencyMissingExceptionIfDependencyChainCannotBeSatisfied()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
Assert.Throws <DependencyMissingException>(() => container.Resolve <IService>());
}
public void NoRegistrationIsRequiredToInstantiateConcreteClassWithoutDependencies()
{
var container = new PandoraContainer(new ComponentStore());
Assert.DoesNotThrow(() =>
{
var dependencies = container.Resolve<ClassWithNoDependencies>();
Assert.IsType<ClassWithNoDependencies>(dependencies);
});
}
public void ThrowsExceptionIfTypeNotRegistered()
{
var store = new ComponentStore();
var container = new PandoraContainer(store);
Assert.Throws <ServiceNotFoundException>(() => {
var result = container.Resolve <IService>();
});
}
public void ExcludesServicesThatCantBeCreated()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll <IService>();
Assert.Equal(0, enumerable.Count());
}
public void CanInsertInstanceWithoutName()
{
var store = new ComponentStore();
var instance = new ClassWithNoDependencies();
store.AddInstance<IService>(instance);
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.Same(instance, service);
}
public void CanResolveClassWithOneDependency()
{
IComponentStore componentStore = new ComponentStore();
componentStore.Add<IService, ClassWithNoDependencies>();
componentStore.Add<IService2, ClassWithOneDependency>();
PandoraContainer locator = new PandoraContainer(componentStore);
var result = locator.Resolve<IService2>();
Assert.IsType<ClassWithOneDependency>(result);
}
public void CanResolveClassWithTwoDependenciesOnItsOwnServiceWithOnlyOneSubdependencyRegistration()
{
var store = new ComponentStore();
store.Add<IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.IsType(typeof (ClassWithTwoDependenciesOnItsOwnService), service);
}
public void CanRetrieveServiceByName()
{
var store = new ComponentStore();
//This registration is to give the container something to choose from, in case named lookup won't work
store.Add<IService, ClassWithDependencyOnItsOwnService>("memory.repository");
store.Add<IService, ClassWithNoDependencies>("db.repository");
var container = new PandoraContainer(store);
var service = container.Resolve<IService>("db.repository");
Assert.IsType<ClassWithNoDependencies>(service);
}
public void ClassWithDependencyOnConcreteClassResolves()
{
var container = new PandoraContainer(new ComponentStore());
Assert.DoesNotThrow(() =>
{
var dependency =
container.Resolve<GenericWithDependency<ClassWithNoDependencies>>();
Assert.IsType<ClassWithNoDependencies>(dependency.Dependency);
});
}
public void RetrievalByNameThrowsExceptionWhenNameNotRegistered()
{
var store = new ComponentStore();
var container = new PandoraContainer(store);
//To make it lookup something
container.Register(p =>
p.Service<ClassWithNoDependencies>()
.Implementor<ClassWithNoDependencies>());
Assert.Throws<ServiceNotFoundException>(() => container.Resolve<ClassWithNoDependencies>("test"));
}
public void DependencyMissingExceptionPropagatesThroughMultipleLevels()
{
var store = new ComponentStore();
store.Add <IService3, ClassDependingOnClassWithOneDependency>();
store.Add <IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws <DependencyMissingException>(() => container.Resolve <IService3>());
}
public void CanResolveClassWithoutDependencies()
{
var componentStore = new ComponentStore();
componentStore.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(componentStore);
var result = container.Resolve <IService>();
Assert.IsType <ClassWithNoDependencies>(result);
}
public void ActivationHappensEveryTime()
{
var store = new ComponentStore();
var registration = store.Add<IService, ClassWithNoDependencies>();
registration.Lifestyle = ComponentLifestyles.Transient;
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
var service2 = container.Resolve<IService>();
Assert.NotSame(service, service2);
}
public void ReturnsAllServicesForGivenType()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>("test1");
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll<IService>();
Assert.Equal(2, enumerable.Count());
}
public void CanResolveClassWithOneDependency()
{
IComponentStore componentStore = new ComponentStore();
componentStore.Add <IService, ClassWithNoDependencies>();
componentStore.Add <IService2, ClassWithOneDependency>();
PandoraContainer locator = new PandoraContainer(componentStore);
var result = locator.Resolve <IService2>();
Assert.IsType <ClassWithOneDependency>(result);
}
public void RetrievalByNameThrowsExceptionWhenNameNotRegistered()
{
var store = new ComponentStore();
var container = new PandoraContainer(store);
//To make it lookup something
container.Register(p =>
p.Service <ClassWithNoDependencies>()
.Implementor <ClassWithNoDependencies>());
Assert.Throws <ServiceNotFoundException>(() => container.Resolve <ClassWithNoDependencies>("test"));
}
public void CanInsertInstanceWithoutName()
{
var store = new ComponentStore();
var instance = new ClassWithNoDependencies();
store.AddInstance <IService>(instance);
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.Same(instance, service);
}
public void CanResolveClassWithMultipleDependencies()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>();
store.Add<IService2, ClassWithOneDependency>();
store.Add<IService3, ClassDependingOnClassWithOneDependency>();
var container = new PandoraContainer(store);
var result = container.Resolve<IService3>();
Assert.IsType<ClassDependingOnClassWithOneDependency>(result);
}
public void ActivationHappensEveryTime()
{
var store = new ComponentStore();
var registration = store.Add<IService, ClassWithNoDependencies>();
registration.Lifestyle = ComponentLifestyles.Transient;
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
var service2 = container.Resolve<IService>();
Assert.NotSame(service, service2);
}
public void ReturnsAllServicesForGivenType()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>("test1");
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll <IService>();
Assert.Equal(2, enumerable.Count());
}
public void CanResolveClassWithMultipleDependencies()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>();
store.Add <IService2, ClassWithOneDependency>();
store.Add <IService3, ClassDependingOnClassWithOneDependency>();
var container = new PandoraContainer(store);
var result = container.Resolve <IService3>();
Assert.IsType <ClassDependingOnClassWithOneDependency>(result);
}
public void CanResolveClassWithTwoDependenciesOnItsOwnServiceWithOnlyOneSubdependencyRegistration()
{
var store = new ComponentStore();
store.Add <IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.IsType(typeof(ClassWithTwoDependenciesOnItsOwnService), service);
}
public void ImplicitlyInstantiatedConcreteClassLifestyleCanBeConfigured()
{
var configuration = new BehaviorConfiguration
{
ImplicitTypeLifestyle = BehaviorConfiguration.Lifestyle.Transient
};
var container = new PandoraContainer(configuration);
var c1 = container.Resolve<ClassWithNoDependencies>();
var c2 = container.Resolve<ClassWithNoDependencies>();
Assert.NotSame(c1, c2);
}
public void CanRetrieveServiceByName()
{
var store = new ComponentStore();
//This registration is to give the container something to choose from, in case named lookup won't work
store.Add <IService, ClassWithDependencyOnItsOwnService>("memory.repository");
store.Add <IService, ClassWithNoDependencies>("db.repository");
var container = new PandoraContainer(store);
var service = container.Resolve <IService>("db.repository");
Assert.IsType <ClassWithNoDependencies>(service);
}
public void ImplicitlyInstantiatedConcreteClassLifestyleCanBeConfigured()
{
var configuration = new BehaviorConfiguration
{
ImplicitTypeLifestyle = BehaviorConfiguration.Lifestyle.Transient
};
var container = new PandoraContainer(configuration);
var c1 = container.Resolve <ClassWithNoDependencies>();
var c2 = container.Resolve <ClassWithNoDependencies>();
Assert.NotSame(c1, c2);
}
public void CanSpecifyDependencyByName()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>("service1");
store.Add<IService, ClassWithNoDependencies2>("service2");
store.Add<ClassWithOneDependency, ClassWithOneDependency>()
.Parameters["dependency"] = "service2";
var container = new PandoraContainer(store);
var service2 = container.Resolve<ClassWithOneDependency>();
Assert.IsType<ClassWithNoDependencies2>(service2.Dependency);
}
public void CanSpecifyDependencyByName()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>("service1");
store.Add <IService, ClassWithNoDependencies2>("service2");
store.Add <ClassWithOneDependency, ClassWithOneDependency>()
.Parameters["dependency"] = "service2";
var container = new PandoraContainer(store);
var service2 = container.Resolve <ClassWithOneDependency>();
Assert.IsType <ClassWithNoDependencies2>(service2.Dependency);
}
public void ActivationHappensOnlyOnceForSingletonComponents()
{
var store = new ComponentStore();
var registration = store.Add <IService, ClassWithNoDependencies>("test");
registration.Lifestyle = ComponentLifestyles.Singleton;
var container = new PandoraContainer(store);
var service = container.Resolve <IService>("test");
var service2 = container.Resolve <IService>("test");
Assert.Same(service, service2);
}
public void CanResolveDependencyChainOfSameService()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), service);
var ownService = (ClassWithDependencyOnItsOwnService)service;
Assert.IsType(typeof(ClassWithNoDependencies), ownService.SubService);
}
public IServiceLocator GetContainer()
{
if (_container == null)
{
lock (LockObject)
{
if (_container == null)
{
DotlessConfiguration configuration = new WebConfigConfigurationLoader().GetConfiguration();
_container = CreateContainer(configuration);
}
}
}
return new CommonServiceLocatorAdapter(_container);
}
private PandoraContainer RegisterCoreServices(PandoraContainer container, DotlessConfiguration configuration)
{
container.Register(p =>
{
if (configuration.MinifyOutput)
{
p.Service<ILessEngine>()
.Implementor<MinifierDecorator>();
}
p.Service<ILessEngine>()
.Implementor<ExtensibleEngine>();
p.Service<ILessSource>()
.Implementor<FileSource>();
});
return container;
}
public void CanInstantiateClassThatDependsOnAString()
{
var store = new ComponentStore();
store.Register(
p =>
{
p.Service<ClassDependingOnAString>()
.Implementor<ClassDependingOnAString>()
.Parameters("string1");
p.Service<string>("string1")
.Instance("Hello World");
});
var container = new PandoraContainer(store);
var resolve = container.Resolve<ClassDependingOnAString>();
Assert.Equal("Hello World", resolve.Dependency);
}
public void CanInstantiateClassThatDependsOnAString()
{
var store = new ComponentStore();
store.Register(
p =>
{
p.Service <ClassDependingOnAString>()
.Implementor <ClassDependingOnAString>()
.Parameters("string1");
p.Service <string>("string1")
.Instance("Hello World");
});
var container = new PandoraContainer(store);
var resolve = container.Resolve <ClassDependingOnAString>();
Assert.Equal("Hello World", resolve.Dependency);
}
public void CanResolveDependencyChainOfSameServiceWithMultipleLevels()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
var level1 = (ClassWithDependencyOnItsOwnService)service;
var level2 = (ClassWithDependencyOnItsOwnService)level1.SubService;
var level3 = (ClassWithNoDependencies)level2.SubService;
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level1);
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level2);
Assert.IsType(typeof(ClassWithNoDependencies), level3);
}
public void CanResolveDependencyChainOfSameService()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.IsType(typeof (ClassWithDependencyOnItsOwnService), service);
var ownService = (ClassWithDependencyOnItsOwnService)service;
Assert.IsType(typeof (ClassWithNoDependencies), ownService.SubService);
}
public PandoraSurfaceInterface()
{
var store = new ComponentStore();
container = new PandoraContainer(store);
}
public FluentInterface()
{
store = new ComponentStore();
container = new PandoraContainer(store);
}
public void CanSplitGraph()
{
/*
* Dotty Graph:
*
digraph G {
a [label="IService :: A"] ;
a -> b [label="service1"] ;
a -> c [label="service2"] ;
b [label="IService :: B"] ;
b -> d ;
d [label="IService :: C"] ;
c [label="IService :: B"] ;
c -> f ;
f [label="IService :: C"] ;
}
*/
var store = new ComponentStore();
store.Add<IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.IsType(typeof (ClassWithTwoDependenciesOnItsOwnService), service);
}
public void DependencyMissingExceptionPropagatesThroughMultipleLevels()
{
var store = new ComponentStore();
store.Add<IService3, ClassDependingOnClassWithOneDependency>();
store.Add<IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws<DependencyMissingException>(() => container.Resolve<IService3>());
}
public void ThrowsDependencyMissingExceptionIfDependencyChainCannotBeSatisfied()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
Assert.Throws<DependencyMissingException>(() => container.Resolve<IService>());
}
public void ThrowsExceptionIfDependencyCouldNotBeSatisfied()
{
var store = new ComponentStore();
store.Add<ClassWithOneDependency, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws<DependencyMissingException>(() => container.Resolve<ClassWithOneDependency>());
}
public PandoraSurfaceInterface()
{
var store = new ComponentStore();
container = new PandoraContainer(store);
}
public void ThrowsExceptionIfTypeNotRegistered()
{
var store = new ComponentStore();
var container = new PandoraContainer(store);
Assert.Throws<ServiceNotFoundException>(() => {
var result = container.Resolve<IService>();
});
}
