public async Task Exception_from_constructor_should_rise_up_to_resolve()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <DummyWithError>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyWithError>()))
.Build())
.AsyncUsing(
async host =>
{
try
{
using (IxLock <DummyWithError> resolvedInstanceLock =
await host.Resolver.Get <DummyWithError>())
{
resolvedInstanceLock.Target.Should().NotBeNull();
}
}
catch (Exception ex)
{
ex.GetType().Should().Be <Exception>();
ex.Message.Should().Be("The Error!");
}
});
}
public async Task ExceptionInDelegateTest()
{
Task testTask = (await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <Dummy>(
instanceBuilder:
new IxClassInstanceBuilderConfig <Dummy>())
.Add <AnotherDummy>(
instanceBuilder:
IxDelegateInstanceBuilderConfig.New <Dummy, AnotherDummy>(
async dummy =>
{
throw new InvalidOperationException("My Error");
})))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <AnotherDummy> anotherDummyLock =
await host.Resolver.Get <AnotherDummy>())
{
anotherDummyLock.Target.Dummy.Should().NotBeNull();
}
});
((Func <Task>)(async() => await testTask)).ShouldThrow <InvalidOperationException>().WithMessage("My Error");
}
public async Task Resolve_by_contract_should_be_success()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add(new DummyImplementationConfig())
.Add(new DummyContractConsumerConfig()))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <IDummyConsumer> consumer = await host.Resolver.Get <IDummyConsumer>())
{
var consumerImpl = consumer.Target as DummyContractConsumer;
consumerImpl.Should().NotBeNull();
consumerImpl.Dummy.Should().NotBeNull();
}
using (IxLock <IDummyContract> impl = await host.Resolver.Get <IDummyContract>())
{
IDummyContract i = impl.Target;
i.Should().NotBeNull();
}
});
}
public async Task SimplestScopeRegistrationShouldWork()
{
var instance = new DummyObject();
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes.AddScope(
exportToParentFilter: new IxStdVisibilityFilterConfig(),
nodes: nodes =>
{
nodes.Add <DummyObject>(
instanceBuilder:
new IxExistingInstanceFactoryConfig <DummyObject>(instance),
disposeHandler: obj => Task.CompletedTask);
}))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <DummyObject> resolvedInstanceLock = await host.Resolver.Get <DummyObject>())
{
resolvedInstanceLock.Target.Should().Be(instance);
}
});
}
public async Task DependencyOverrideAndUseTest()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <IDummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyParent>())
.Add <SomeContainer>(
instanceBuilder: new IxClassInstanceBuilderConfig <SomeContainer>(),
nodes:
nodes =>
nodes.Add <IDummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyNested>())))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <SomeContainer> someContainerLock =
await host.Resolver.Get <SomeContainer>())
{
someContainerLock.Target.Dummy.AboutMe.Should().Be("I am parent; I know");
}
});
}
public async Task Instance_should_be_reused_in_one_resolve()
{
await(await new IxHostBuilder()
.Configure(
n => n
.Add <Dummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <Dummy>(),
multiplicity: new IxPerResolveMultiplicityConfig())
.Add <DummyUser1>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyUser1>(),
multiplicity: new IxPerResolveMultiplicityConfig())
.Add <DummyUser2>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyUser2>(),
multiplicity: new IxPerResolveMultiplicityConfig()))
.Build())
.AsyncUsing(
async host =>
{
Dummy dummy;
using (IxLock <DummyUser2> dummyLock = await host.Resolver.Get <DummyUser2>())
{
dummyLock.Target.Should().NotBeNull();
dummyLock.Target.DummyUser1.Dummy.Should().BeSameAs(dummyLock.Target.Dummy);
dummy = dummyLock.Target.Dummy;
}
using (IxLock <DummyUser2> dummyLock = await host.Resolver.Get <DummyUser2>())
{
dummyLock.Target.Dummy.Should().NotBeSameAs(dummy);
}
});
}
public async Task Host_should_be_resolved_by_interface()
{
await(await new IxHostBuilder()
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <IIxHost> hostLock = await host.Resolver.Get <IIxHost>())
{
hostLock.Target.Should().NotBeNull();
}
});
}
public async Task RegisteredScopeShouldBeResolved()
{
await(await new IxHostBuilder()
.Configure(n => n.AddScope("test"))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <IxScope> rootScope = await host.Resolver.Get <IxScope>("test"))
{
rootScope.Target.Should().NotBeNull();
}
});
}
public async Task ProvideConfigAttributeTest()
{
await(await new IxHostBuilder()
.Configure(
rootNodes => rootNodes.Add(new DummyConfig()))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <Dummy> resolvedInstanceLock = await host.Resolver.Get <Dummy>())
{
resolvedInstanceLock.Target.Should().NotBeNull();
}
});
}
public async Task DerivedScopeTest()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes.Add(new DummyScopeConfig()))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <IDummyConfigUser> dummy = await host.Resolver.Get <IDummyConfigUser>())
{
dummy.Target.Should().NotBeNull();
}
});
}
public async Task Invoke(HttpContext context)
{
using (IxLock <HttpRequestScope> requestScopeLock =
await _resolver.Get <HttpRequestScope, HttpContext>(null, context))
{
context.Items[RequestScopeKey] = requestScopeLock.Target;
try
{
await _next.Invoke(context);
}
finally
{
context.Items.Remove(RequestScopeKey);
requestScopeLock.Target.NotifyAutoDispose();
}
}
}
public async Task Scope_registration_should_follow_visibility_rule()
{
var instance = new DummyObject();
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes.AddScope(
"private",
nodes: nodes =>
{
nodes.Add <DummyObject>(
instanceBuilder:
new IxExistingInstanceFactoryConfig <DummyObject>(instance),
disposeHandler: obj => Task.CompletedTask);
}))
.Build())
.AsyncUsing(
host =>
{
try
{
Func <Task> action = async() =>
{
using (
IxLock <DummyObject> resolvedInstanceLock =
await host.Resolver.Get <DummyObject>())
{
resolvedInstanceLock.Target.Should().Be(instance);
}
};
action.ShouldThrow <IxResolveTargetNotFound>()
.Which.Identifier.Should()
.Be(new IxIdentifier(typeof(DummyObject)));
}
catch (Exception ex)
{
Task.FromException(ex);
}
return(Task.CompletedTask);
});
}
public async Task Simplest_class_should_be_instantiated()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes.Add <SimplestDummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <SimplestDummy>(),
disposeHandler: obj => Task.CompletedTask))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <SimplestDummy> resolvedInstanceLock = await host.Resolver.Get <SimplestDummy>()
)
{
resolvedInstanceLock.Target.Should().BeOfType <SimplestDummy>();
}
});
}
public async Task Argument_should_be_resolved()
{
await(await new IxHostBuilder()
.Configure(
n => n
.Add <Dummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <Dummy>(),
multiplicity: new IxPerResolveMultiplicityConfig()))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <Dummy> dummyLock =
await host.Resolver.Get <Dummy, string>(null, "Hello world!"))
{
dummyLock.Target.Should().NotBeNull();
dummyLock.Target.MyArg.Should().Be("Hello world!");
}
});
}
public async Task SingleInstantiateWithoutDispose()
{
var instance = new DummyObject();
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes.Add <DummyObject>(
instanceBuilder: new IxExistingInstanceFactoryConfig <DummyObject>(instance),
disposeHandler: obj => Task.CompletedTask))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <DummyObject> resolvedInstanceLock = await host.Resolver.Get <DummyObject>())
{
resolvedInstanceLock.Target.Should().Be(instance);
}
});
}
public async Task ResolveFromInstanceChildTest()
{
await(await new IxHostBuilder()
.Configure(
n => n
.Add <Dummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <Dummy>(),
exportToParentFilter:
new IxStdVisibilityFilterConfig
{
WhiteList =
new HashSet <IxIdentifier>
{
new IxIdentifier(typeof(Dummy)),
new IxIdentifier(typeof(DummyChild))
}
},
nodes:
n1 => n1
.Add <DummyChild>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyChild>())))
.Build())
.AsyncUsing(
async host =>
{
Dummy dummy;
using (IxLock <Dummy> dummyLock = await host.Resolver.Get <Dummy>())
{
dummyLock.Target.Should().NotBeNull();
dummy = dummyLock.Target;
}
using (IxLock <DummyChild> dummyChildLock = await host.Resolver.Get <DummyChild>())
{
dummyChildLock.Target.Should().NotBeNull();
dummyChildLock.Target.Parent.Should().NotBeNull();
dummyChildLock.Target.Parent.Should().BeSameAs(dummy);
}
});
}
public async Task Auto_dispose_test()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <DummyDisposable>(
instanceBuilder: new IxClassInstanceBuilderConfig <DummyDisposable>(),
multiplicity: new IxPerResolveMultiplicityConfig(),
autoDisposeEnabled: true))
.Build())
.AsyncUsing(
async host =>
{
var wasCalled = false;
DummyDisposable dummyTmp;
using (IxLock <DummyDisposable> dummyLock =
await host.Resolver.Get <DummyDisposable>())
{
dummyLock.Target.DisposeAction = () => { wasCalled = true; };
dummyTmp = dummyLock.Target;
}
dummyTmp.Disposed.Wait(TimeSpan.FromSeconds(5));
wasCalled.Should().BeTrue();
wasCalled = false;
using (IxLock <DummyDisposable> dummyLock =
await host.Resolver.Get <DummyDisposable>())
{
dummyLock.Target.DisposeAction = () => { wasCalled = true; };
dummyTmp = dummyLock.Target;
}
dummyTmp.Disposed.Wait(TimeSpan.FromSeconds(5));
wasCalled.Should().BeTrue();
});
}
public async Task Registered_scope_should_be_resolved_with_the_same_instance()
{
await(await new IxHostBuilder()
.Configure(n => n.AddScope("test"))
.Build())
.AsyncUsing(
async host =>
{
object firstResolvedInstance;
using (IxLock <IxScope> scope = await host.Resolver.Get <IxScope>("test"))
{
scope.Target.Should().NotBeNull();
firstResolvedInstance = scope.Target;
}
using (IxLock <IxScope> scope = await host.Resolver.Get <IxScope>("test"))
{
scope.Target.Should().NotBeNull();
scope.Target.Should().Be(firstResolvedInstance);
}
});
}
public async Task SimpleResolveShouldBeSynchronous()
{
var instance = new DummyObject();
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes.Add <DummyObject>(
instanceBuilder:
new IxExistingInstanceFactoryConfig <DummyObject>(
instance),
disposeHandler: obj => Task.CompletedTask))
.Build())
.AsyncUsing(
async host =>
{
int beforeAwaitThreadId = Thread.CurrentThread.ManagedThreadId;
using (IxLock <DummyObject> resolvedInstanceLock = await host.Resolver.Get <DummyObject>())
{
Thread.CurrentThread.ManagedThreadId.Should().Be(beforeAwaitThreadId);
resolvedInstanceLock.Target.Should().Be(instance);
}
});
}
public async Task Self_registered_should_be_resolved()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <Dummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <Dummy>(),
nodes:
nodes =>
nodes.Add <string>(
instanceBuilder: new IxExistingInstanceFactoryConfig <string>(
"Test me!")))
)
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <Dummy> resolvedInstanceLock = await host.Resolver.Get <Dummy>())
{
resolvedInstanceLock.Target.Should().NotBeNull();
}
});
}
public async Task Simplest_dependency_should_be_resolved()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <SimplestDummy>(
instanceBuilder: new IxClassInstanceBuilderConfig <SimplestDummy>())
.Add <WithSimplestDependencyDummy>(
instanceBuilder: new
IxClassInstanceBuilderConfig <WithSimplestDependencyDummy>()))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <SimplestDummy> dummyLock =
await host.Resolver.Get <SimplestDummy>())
using (IxLock <WithSimplestDependencyDummy> dependentOnDummyLock =
await host.Resolver.Get <WithSimplestDependencyDummy>())
{
dependentOnDummyLock.Target.Dummy.Should().Be(dummyLock.Target);
}
});
}
public async Task SimpleTest()
{
await(await new IxHostBuilder()
.Configure(
rootNodes =>
rootNodes
.Add <Dummy>(
instanceBuilder:
new IxClassInstanceBuilderConfig <Dummy>())
.Add <AnotherDummy>(
instanceBuilder:
IxDelegateInstanceBuilderConfig.New <Dummy, AnotherDummy>(
async dummy => new AnotherDummy(dummy))))
.Build())
.AsyncUsing(
async host =>
{
using (IxLock <AnotherDummy> anotherDummyLock =
await host.Resolver.Get <AnotherDummy>())
{
anotherDummyLock.Target.Dummy.Should().NotBeNull();
}
});
}
