public void registering_instances_in_different_scopes_results_in_each_consumer_getting_the_correct_registration()
{
var objectForScope1 = new TheClass();
var objectForScope2 = new TheClass();
var scope1 = new AmbientContext();
var scope2 = new AmbientContext();
Resolver.AddDependency <IContextStore, AmbientContextStore>();
IDisposable scope1Request, scope2Request;
using (new ContextScope(scope1))
{
scope1Request = Resolver.CreateRequestScope();
Resolver.AddDependencyInstance <TheClass>(objectForScope1, DependencyLifetime.PerRequest);
}
using (new ContextScope(scope2))
{
scope2Request = Resolver.CreateRequestScope();
Resolver.AddDependencyInstance <TheClass>(objectForScope2, DependencyLifetime.PerRequest);
}
using (new ContextScope(scope1))
{
Resolver.Resolve <TheClass>().ShouldBeSameAs(objectForScope1);
}
using (new ContextScope(scope2))
{
Resolver.Resolve <TheClass>().ShouldBeSameAs(objectForScope2);
}
}
registering_instances_in_different_scopes_results_in_only_the_context_specific_registrations_to_be_resolved_in_a_context()
{
var objectForScope1 = new TheClass();
var objectForScope2 = new TheClass();
var scope1 = new AmbientContext();
var scope2 = new AmbientContext();
IDisposable scope1Request, scope2Request;
Resolver.AddDependency <IContextStore, AmbientContextStore>();
using (new ContextScope(scope1))
{
Resolver.CreateRequestScope();
Resolver.AddDependencyInstance <TheClass>(objectForScope1, DependencyLifetime.PerRequest);
}
using (new ContextScope(scope2))
{
Resolver.CreateRequestScope();
Resolver.AddDependencyInstance <TheClass>(objectForScope2, DependencyLifetime.PerRequest);
}
using (new ContextScope(scope1))
{
Resolver.ResolveAll <TheClass>()
.ShouldBe(new[] { objectForScope1 });
}
}
protected void setup()
{
Host = new InMemoryHost(startup: new StartupProperties
{
OpenRasta =
{
Errors =
{
HandleAllExceptions = false,
HandleCatastrophicExceptions = false
}
}
});
Pipeline = null;
_actions = new Dictionary <Type, Func <ICommunicationContext, Task <PipelineContinuation> > >();
var manager = Host.HostManager;
Resolver.AddDependencyInstance(typeof(IErrorCollector), Errors = new TestErrorCollector());
Resolver.AddDependency <IPathManager, PathManager>();
_ambientContext = new ContextScope(new AmbientContext());
_requestScope = Resolver.CreateRequestScope();
manager.SetupCommunicationContext(Context = new WriteTrackingResponseCommunicationContext(InnerContext = new InMemoryCommunicationContext()));
}
public void instance_registered_as_per_request_are_cleared_when_context_store_is_terminating()
{
GivenInMemoryStore();
var firstInstance = new TheClass();
using (Resolver.CreateRequestScope())
{
Resolver.AddDependencyInstance <TheClass>(firstInstance, DependencyLifetime.PerRequest);
Resolver.Resolve <TheClass>().ShouldBeSameAs(firstInstance);
}
Executing(() => Resolver.Resolve <TheClass>()).ShouldThrow <DependencyResolutionException>();
}
async Task HandleHostIncompingRequestReceivedAsync(IncomingRequestEventArgs e)
{
using (DependencyManager.ScopedResolver(Resolver))
{
var context = new WriteTrackingResponseCommunicationContext(e.Context);
context.PipelineData[Keys.Request.ResolverRequestScope] = Resolver.CreateRequestScope();
// register the required dependency in the web context
SetupCommunicationContext(context);
await _pipeline.RunAsync(context);
}
}
protected override void SetUp()
{
base.SetUp();
Host = new InMemoryHost();
Pipeline = null;
_actions = new Dictionary <Type, Func <ICommunicationContext, Task <PipelineContinuation> > >();
var manager = Host.HostManager;
Resolver.AddDependencyInstance(typeof(IErrorCollector), Errors = new TestErrorCollector());
Resolver.AddDependency <IPathManager, PathManager>();
_requestScope = Resolver.CreateRequestScope();
manager.SetupCommunicationContext(Context = new InMemoryCommunicationContext());
DependencyManager.SetResolver(Resolver);
}
protected virtual void HandleHostIncomingRequestReceived(object sender, IncomingRequestEventArgs e)
{
Log.WriteDebug("Incoming host request for " + e.Context.Request.Uri);
var task = CallWithDependencyResolver(async() =>
{
e.Context.PipelineData[Keys.Request.ResolverRequestScope] = Resolver.CreateRequestScope();
// register the required dependency in the web context
var context = e.Context;
SetupCommunicationContext(context);
await _pipeline.RunAsync(context);
});
e.Context.PipelineData[Keys.Request.PipelineTask] = e.RunTask = task;
}
public void registering_two_instances_for_the_same_type_resolves_at_least_one_entry()
{
GivenInMemoryStore();
var firstInstance = new TheClass();
var secondInstance = new TheClass();
using (Resolver.CreateRequestScope())
{
Resolver.AddDependencyInstance <TheClass>(firstInstance, DependencyLifetime.PerRequest);
Resolver.AddDependencyInstance <TheClass>(secondInstance, DependencyLifetime.PerRequest);
var result = Resolver.ResolveAll <TheClass>();
(result.Contains(firstInstance) || result.Contains(secondInstance)).ShouldBeTrue();
}
}
public void resolve_succeeds()
{
Resolver.AddDependency <IContextStore, AmbientContextStore>();
Resolver.AddDependency <Contributor>(DependencyLifetime.Singleton);
Resolver.AddDependency <ErrorCollector>(DependencyLifetime.Transient);
var contributor = Resolver.Resolve <Contributor>();
using (new ContextScope(new AmbientContext()))
using (Resolver.CreateRequestScope())
{
Resolver.AddDependencyInstance(new Request(), DependencyLifetime.PerRequest);
var result = contributor.Factory();
result.ShouldHaveSingleItem();
}
}
public void a_type_registered_as_transient_gets_an_instance_stored_in_context_injected()
{
Resolver.AddDependency <IContextStore, AmbientContextStore>();
var objectForScope = new TheClass();
var scope = new AmbientContext();
Resolver.AddDependency <TheDependentClass>(DependencyLifetime.Transient);
using (new ContextScope(scope))
using (Resolver.CreateRequestScope())
{
Resolver.AddDependencyInstance(typeof(TheClass), objectForScope, DependencyLifetime.PerRequest);
var dependentClass = Resolver.Resolve <TheDependentClass>();
dependentClass.ShouldNotBeNull();
dependentClass.Dependent.ShouldBeSameAs(objectForScope);
}
}
a_type_registered_as_transient_gets_an_instance_which_is_created_with_another_instance_and_is_registered_as_perwebrequest()
{
Resolver.AddDependency <IContextStore, AmbientContextStore>();
Resolver.AddDependency <TheDependentClassThatNeedsYou>(DependencyLifetime.Transient);
var contextStore = new AmbientContext();
using (new ContextScope(contextStore))
using (Resolver.CreateRequestScope())
{
var objectForScope = new TheClassThatNeedsYou(new NeedYou());
Resolver.AddDependencyInstance(typeof(TheClassThatNeedsYou), objectForScope, DependencyLifetime.PerRequest);
var dependentClass = Resolver.Resolve <TheDependentClassThatNeedsYou>();
dependentClass.ShouldNotBeNull();
}
}
public void per_request_creates_new_instance_in_between_requests()
{
InMemoryStore = new InMemoryContextStore();
Resolver.AddDependencyInstance <IContextStore>(InMemoryStore);
Resolver.AddDependency <IUnknown, JohnDoe>(DependencyLifetime.PerRequest);
IUnknown firstInstance;
IUnknown secondInstance;
using (Resolver.CreateRequestScope())
firstInstance = Resolver.Resolve <IUnknown>();
InMemoryStore.Clear();
using (Resolver.CreateRequestScope())
secondInstance = Resolver.Resolve <IUnknown>();
firstInstance.ShouldNotBeSameAs(secondInstance);
}
public void a_dependency_registered_in_one_context_is_not_registered_in_another()
{
var objectForScope1 = new TheClass();
var scope1 = new AmbientContext();
var scope2 = new AmbientContext();
Resolver.AddDependency <IContextStore, AmbientContextStore>();
using (new ContextScope(scope1))
using (Resolver.CreateRequestScope())
{
Resolver.AddDependencyInstance <TheClass>(objectForScope1, DependencyLifetime.PerRequest);
}
using (new ContextScope(scope2))
using (Resolver.CreateRequestScope())
{
Resolver.HasDependency(typeof(TheClass)).ShouldBeFalse();
Executing(() => Resolver.Resolve <TheClass>()).ShouldThrow <DependencyResolutionException>();
}
}
