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(); } }); }