public void Dispose_WithTrackedInstances_DisposesTrackedInstances() { var disposable = new DisposableFoo(); Scope scope = scopeManagers.Value.BeginScope(); scope.TrackInstance(disposable); scope.Dispose(); Assert.True(disposable.IsDisposed); }
public void Dispose_WithTrackedInstances_DisposesTrackedInstances() { var disposable = new DisposableFoo(); Scope scope = scopeManagers.Value.BeginScope(); scope.TrackInstance(disposable); scope.Dispose(); Assert.IsTrue(disposable.IsDisposed); }
public void DisposedEventListenedByContainerForSingletonObject() { BuilderContainer container = new BuilderContainer(); DisposableFoo foo = container.BuildUp <DisposableFoo>("Foo"); foo.Dispose(); Assert.IsFalse(container.Contains("Foo")); }
public void Dispose_WithTrackedInstances_DisposesTrackedInstances() { var container = new ServiceContainer(); var scopeManager = new PerThreadScopeManager(container); var disposable = new DisposableFoo(); Scope scope = scopeManager.BeginScope(); scope.TrackInstance(disposable); scope.Dispose(); Assert.True(disposable.IsDisposed); }
public void Dispose_WithTrackedInstances_DisposesTrackedInstances() { var container = new ServiceContainer(); var scopeManager = new PerThreadScopeManager(container); var disposable = new DisposableFoo(); Scope scope = scopeManager.BeginScope(); scope.TrackInstance(disposable); scope.Dispose(); Assert.True(disposable.IsDisposed); }
public void Disposable_services_should_be_disposed_when_released() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Transient); var foo = Container.Resolve <DisposableFoo>(); Container.Release(foo); Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Registered_Delegate_prefered_over_factory() { var foo = new DisposableFoo(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Transient, Component.For <Func <int, DisposableFoo> >().Instance(i => foo), Component.For <UsesDisposableFooDelegate>().LifeStyle.Transient); var dependsOnFoo = Container.Resolve <UsesDisposableFooDelegate>(); var otherFoo = dependsOnFoo.GetFoo(); Assert.AreSame(foo, otherFoo); }
public void Dispose_ServiceWithPerRequestLifetime_IsDisposed() { var container = CreateContainer(); var disposableFoo = new DisposableFoo(); container.Register<IFoo>(factory => disposableFoo, new PerRequestLifeTime()); using (container.BeginScope()) { container.GetInstance<IFoo>(); } Assert.True(disposableFoo.IsDisposed); }
public void Raise_Test() { const int TestState = Int32.MinValue; using (var foo = new DisposableFoo()) { foo.Should().NotBeNull(); foo.Bar += (f, e) => e.State.Should().Be(TestState); foo.IsDisposed.Should().BeFalse(); foo.RaiseBar(TestState); } }
public void Dispose_ServiceWithPerRequestLifetime_IsDisposed() { var container = CreateContainer(); var disposableFoo = new DisposableFoo(); container.Register <IFoo>(factory => disposableFoo, new PerRequestLifeTime()); using (container.BeginScope()) { container.GetInstance <IFoo>(); } Assert.True(disposableFoo.IsDisposed); }
public void When_interceptor_throws_previous_dependencies_get_released() { DisposableFoo.ResetDisposedCount(); container.Register( Component.For <ThrowInCtorInterceptor>().LifeStyle.Transient, Component.For <DisposableFoo>().LifeStyle.Transient, Component.For <UsesDisposableFoo>().LifeStyle.Transient .Interceptors <ThrowInCtorInterceptor>() ); Assert.Throws <ComponentActivatorException>(() => container.Resolve <UsesDisposableFoo>()); Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Ending_scope_releases_component() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifestyleScoped()); using (Container.BeginScope()) { Container.Resolve <DisposableFoo>(); } Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Dispose_Finalizer_Test() { var foo = new DisposableFoo(); foo.Should().NotBeNull(); foo.IsDisposed.Should().BeFalse(); foo.Check(); // ReSharper disable once RedundantAssignment #pragma warning disable IDE0059 // Value assigned to symbol is never used foo = null; GC.WaitForPendingFinalizers(); #pragma warning restore IDE0059 // Value assigned to symbol is never used }
public void Releasing_component_depending_on_a_factory_releases_what_was_pulled_from_it() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Transient, Component.For <UsesDisposableFooDelegate>().LifeStyle.Transient); var dependsOnFoo = Container.Resolve <UsesDisposableFooDelegate>(); dependsOnFoo.GetFoo(); Assert.AreEqual(0, DisposableFoo.DisposedCount); Container.Release(dependsOnFoo); Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Dispose_Test() { DisposableFoo foo; using (foo = new DisposableFoo()) { foo.Should().NotBeNull(); foo.IsDisposed.Should().BeFalse(); foo.Check(); } foo.Should().NotBeNull(); foo.IsDisposed.Should().BeTrue(); }
public void Releasing_lazy_releases_requested_component() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Transient); var lazy = Container.Resolve <Lazy <DisposableFoo> >(); Assert.AreEqual(0, DisposableFoo.DisposedCount); var value = lazy.Value; Container.Release(lazy); Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Scoped_component_is_not_tracked_by_the_release_policy() { DisposableFoo foo; DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Scoped()); using (Container.BeginScope()) { foo = Container.Resolve <DisposableFoo>(); Assert.IsFalse(Kernel.ReleasePolicy.HasTrack(foo)); } }
public void Scoped_component_is_not_released_by_call_to_container_Release() { DisposableFoo foo; DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Scoped()); using (Container.BeginScope()) { foo = Container.Resolve <DisposableFoo>(); Container.Release(foo); Assert.AreEqual(0, DisposableFoo.DisposedCount); } }
public void Factory_does_not_reference_components_after_they_are_released() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Transient, Component.For <UsesDisposableFooDelegate>().LifeStyle.Transient); var dependsOnFoo = Container.Resolve <UsesDisposableFooDelegate>(); var tracker = ReferenceTracker.Track(() => dependsOnFoo.GetFoo()); Assert.AreEqual(0, DisposableFoo.DisposedCount); Container.Release(dependsOnFoo); Assert.AreEqual(1, DisposableFoo.DisposedCount); tracker.AssertNoLongerReferenced(); }
public void Scoped_component_is_bound_to_the_innermost_scope() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Scoped()); using (Container.BeginScope()) { using (Container.BeginScope()) { Container.Resolve <DisposableFoo>(); Assert.AreEqual(0, DisposableFoo.DisposedCount); } Assert.AreEqual(1, DisposableFoo.DisposedCount); } Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Release_doesnt_stop_tracking_component_singleton_until_container_is_disposed() { DisposableFoo.ResetDisposedCount(); container.Register(Singleton <DisposableFoo>()); var tracker = ReferenceTracker.Track(() => container.Resolve <DisposableFoo>()); tracker.AssertStillReferencedAndDo(foo => container.Release(foo)); tracker.AssertStillReferenced(); Assert.AreEqual(0, DisposableFoo.DisposedCount); container.Dispose(); tracker.AssertNoLongerReferenced(); Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Disposable_singleton_dependency_of_transient_open_generic_is_disposed() { DisposableFoo.ResetDisposedCount(); Container.Register( Component.For(typeof(GenericComponent <>)).LifeStyle.Transient, Component.For <DisposableFoo>().LifeStyle.Singleton ); var depender = Container.Resolve <GenericComponent <DisposableFoo> >(); var weak = new WeakReference(depender.Value); depender = null; Container.Dispose(); GC.Collect(); Assert.AreEqual(1, DisposableFoo.DisposedCount); Assert.IsFalse(weak.IsAlive); }
public void Check_Exception() { DisposableFoo foo; using (foo = new DisposableFoo()) { foo.Should().NotBeNull(); foo.IsDisposed.Should().BeFalse(); foo.Check(); } foo.Should().NotBeNull(); foo.IsDisposed.Should().BeTrue(); Action act = () => foo.Check(); act.Should().Throw <ObjectDisposedException>(); }
public void Raise_Exception() { var testState = Int32.MinValue; using (var foo = new DisposableFoo()) { foo.Should().NotBeNull(); foo.Bar += (f, e) => e.State.Should().Be(testState); foo.Baz += (f, e) => { }; foo.IsDisposed.Should().BeFalse(); Action throwBar = () => foo.ThrowBar(); throwBar.Should().Throw <ArgumentNullException>(); Action throwBaz = () => foo.ThrowBaz(); throwBaz.Should().Throw <ArgumentNullException>(); } }
public void Factory_does_not_referece_components_after_theyve_been_released() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <DisposableFoo>().LifeStyle.Transient, Component.For <UsesDisposableFooDelegate>().LifeStyle.Transient); var dependsOnFoo = Container.Resolve <UsesDisposableFooDelegate>(); var foo = dependsOnFoo.GetFoo(); Assert.AreEqual(0, DisposableFoo.DisposedCount); Container.Release(dependsOnFoo); Assert.AreEqual(1, DisposableFoo.DisposedCount); var weakFoo = new WeakReference(foo); foo = null; GC.Collect(); Assert.IsFalse(weakFoo.IsAlive); }
public void Disposable_singleton_dependency_of_transient_open_generic_is_disposed() { DisposableFoo.ResetDisposedCount(); Container.Register( Component.For(typeof(GenericComponent <>)).LifeStyle.Transient, Component.For <DisposableFoo>().LifeStyle.Singleton ); var tracker = ReferenceTracker .Track(() => { var depender = Container.Resolve <GenericComponent <DisposableFoo> >(); return(depender.Value); }); Container.Dispose(); Assert.AreEqual(1, DisposableFoo.DisposedCount); tracker.AssertNoLongerReferenced(); }
public void Release_doesnt_stop_tracking_component_singleton_until_container_is_disposed() { DisposableFoo.ResetDisposedCount(); container.Register(Singleton <DisposableFoo>()); var foo = container.Resolve <DisposableFoo>(); var fooWeak = new WeakReference(foo); container.Release(foo); foo = null; GC.Collect(); Assert.IsTrue(fooWeak.IsAlive); Assert.AreEqual(0, DisposableFoo.DisposedCount); container.Dispose(); GC.Collect(); Assert.IsFalse(fooWeak.IsAlive); Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public void Nested_container_and_scope_used_together_dont_cause_components_to_be_released_twice() { DisposableFoo.ResetDisposedCount(); Container.Register(Component.For <IWindsorContainer>().LifeStyle.Scoped() .UsingFactoryMethod(k => { var container = new WindsorContainer(); container.Register(Component.For <DisposableFoo>().LifestyleScoped()); k.AddChildKernel(container.Kernel); return(container); })); using (Container.BeginScope()) { var child = Container.Resolve <IWindsorContainer>(); child.Resolve <DisposableFoo>(); } Assert.AreEqual(1, DisposableFoo.DisposedCount); }
public UsesDisposableFoo(DisposableFoo foo) { this.foo = foo; }
public void Registered_Delegate_prefered_over_factory() { var foo = new DisposableFoo(); container.Register(Component.For<DisposableFoo>().LifeStyle.Transient, Component.For<Func<int, DisposableFoo>>().Instance(i => foo), Component.For<UsesDisposableFooDelegate>().LifeStyle.Transient); var dependsOnFoo = container.Resolve<UsesDisposableFooDelegate>(); var otherFoo = dependsOnFoo.GetFoo(); Assert.AreSame(foo, otherFoo); }
public UsesDisposableFoo(DisposableFoo foo) { this.foo = foo; }