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