public void puzzleContainer_register_entry_using_instance_should_resolve_the_given_instance_as_singleton()
{
var container = new PuzzleContainer();
container.Register(EntryBuilder.For <Object>().UsingInstance(new Object()));
var expected = container.Resolve <Object>();
var actual = container.Resolve <Object>();
Assert.AreEqual(expected, actual);
}
public void puzzleContainer_register_entry_as_transient_should_resolve_instances_as_transient()
{
var container = new PuzzleContainer();
container.Register(EntryBuilder.For <Object>().WithLifestyle(Lifestyle.Transient));
var i1 = container.Resolve <Object>();
var i2 = container.Resolve <Object>();
Assert.AreNotEqual(i1, i2);
}
public void puzzleContainer_register_entries_using_valid_entry_should_resolve_the_given_entries()
{
var container = new PuzzleContainer();
IContainerEntry e1 = EntryBuilder.For <ArgumentException>();
IContainerEntry e2 = EntryBuilder.For <ArgumentNullException>();
container.Register(new[] { e1, e2 });
var obj1 = container.Resolve <ArgumentException>();
var obj2 = container.Resolve <ArgumentNullException>();
Assert.IsNotNull(obj1);
Assert.IsNotNull(obj2);
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_with_instances()
{
var entry = EntryBuilder.For <IFoo>()
.Forward <IBar>()
.UsingInstance(new TypeWithMultipleContracts());
var sut = new PuzzleContainer();
sut.Register(entry);
var iBar = sut.Resolve <IBar>();
var iFoo = sut.Resolve <IFoo>();
Assert.AreEqual(iBar, iFoo);
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_in_singleton_types()
{
var entry = EntryBuilder.For <IFoo>()
.Forward <IBar>()
.ImplementedBy <TypeWithMultipleContracts>();
var sut = new PuzzleContainer();
sut.Register(entry);
var iBar = sut.Resolve <IBar>();
var iFoo = sut.Resolve <IFoo>();
Assert.AreEqual(iBar, iFoo);
}
public void when_registering_POCO_message_handler_facility_should_correctly_subscribe_messages()
{
var container = new PuzzleContainer();
container.AddFacility <SubscribeToMessageFacility>();
container.Register(EntryBuilder.For <IMessageBroker>().UsingInstance(new MessageBroker(new NullDispatcher())));
container.Register(EntryBuilder.For <IHandleMessage <AMessage> >().ImplementedBy <AMessageHandler>());
var broker = container.Resolve <IMessageBroker>();
var handler = (AMessageHandler)container.Resolve <IHandleMessage <AMessage> >();
broker.Dispatch(this, new AMessage());
Assert.IsTrue(handler.Invoked);
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_with_factory_method()
{
var entry = EntryBuilder.For <IFoo>()
.Forward <IBar>()
.UsingFactory(() => new TypeWithMultipleContracts())
.WithLifestyle(Lifestyle.Singleton);
var sut = new PuzzleContainer();
sut.Register(entry);
var iBar = sut.Resolve <IBar>();
var iFoo = sut.Resolve <IFoo>();
Assert.AreEqual(iBar, iFoo);
}
public void puzzleContainer_register_entry_with_factory_as_singleton_should_call_factory_once()
{
var expected = 1;
var actual = 0;
var container = new PuzzleContainer();
container.Register
(
EntryBuilder.For <Object>()
.UsingFactory(() =>
{
actual++;
return(new Object());
})
);
container.Resolve <Object>();
container.Resolve <Object>();
Assert.AreEqual(expected, actual);
}
public void PuzzleContainer_resolve_using_type_with_static_type_initializer_should_not_fail()
{
var container = new PuzzleContainer();
container.Register(
EntryBuilder.For <TypeWithStaticCtor>()
);
var actual = container.Resolve <TypeWithStaticCtor>();
Assert.IsNotNull(actual);
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_in_transient_types()
{
var entry = EntryBuilder.For <IFoo>()
.Forward <IBar>()
.ImplementedBy <TypeWithMultipleContracts>()
.WithLifestyle(Lifestyle.Transient);
var sut = new PuzzleContainer();
sut.Register(entry);
var iBar = sut.Resolve <IBar>();
var iFoo = sut.Resolve <IFoo>();
Assert.IsNotNull(iBar);
Assert.IsNotNull(iFoo);
Assert.AreNotEqual(iBar, iFoo);
Assert.IsTrue(iBar.GetType().Is <TypeWithMultipleContracts>());
Assert.IsTrue(iFoo.GetType().Is <TypeWithMultipleContracts>());
}
public void puzzleContainer_register_entry_with_factory_as_transient_should_resolve_instances_as_transient()
{
var expected = 2;
var actual = 0;
var container = new PuzzleContainer();
container.Register
(
EntryBuilder.For <Object>()
.UsingFactory(() =>
{
actual++;
return(new Object());
})
.WithLifestyle(Lifestyle.Transient)
);
container.Resolve <Object>();
container.Resolve <Object>();
Assert.AreEqual(expected, actual);
}
public void PuzzleContainer_at_dispose_should_dispose_singleton_references()
{
var entry = EntryBuilder.For <IFoo>()
.ImplementedBy <DisposableFoo>()
.WithLifestyle(Lifestyle.Singleton);
var sut = new PuzzleContainer();
sut.Register(entry);
var iFoo = (DisposableFoo)sut.Resolve <IFoo>();
sut.Dispose();
Assert.IsTrue(iFoo.Disposed);
}
public void PuzzleContainer_Resolve_using_overridable_types_should_resolve_overrider_and_not_overridden()
{
var obj1 = new Object();
var obj2 = new Object();
var sut = new PuzzleContainer();
sut.Register(
EntryBuilder.For <Object>()
.UsingInstance(obj1)
.Overridable()
);
sut.Register(
EntryBuilder.For <Object>().UsingInstance(obj2)
);
var actual = sut.Resolve <Object>();
Assert.AreEqual(obj2, actual);
}
public void puzzleContainer_should_resolve_type_with_dependency_on_array_of_registered_types()
{
var obj1 = new Object();
var obj2 = new Object();
var sut = new PuzzleContainer();
sut.Register(
EntryBuilder.For <Object>().UsingInstance(obj1)
);
sut.Register(
EntryBuilder.For <Object>().UsingInstance(obj2)
);
sut.Register(
EntryBuilder.For <TypeWithArrayDependency>()
);
var actual = sut.Resolve <TypeWithArrayDependency>();
Assert.IsTrue(actual.IsResolved);
}
public void puzzleContainer_should_resolve_type_with_dependency_on_array_of_registered_types()
{
var obj1 = new Object();
var obj2 = new Object();
var sut = new PuzzleContainer();
sut.Register(
EntryBuilder.For<Object>().UsingInstance( obj1 )
);
sut.Register(
EntryBuilder.For<Object>().UsingInstance( obj2 )
);
sut.Register(
EntryBuilder.For<TypeWithArrayDependency>()
);
var actual = sut.Resolve<TypeWithArrayDependency>();
Assert.IsTrue( actual.IsResolved );
}
public void PuzzleContainer_resolve_using_type_with_static_type_initializer_should_not_fail()
{
var container = new PuzzleContainer();
container.Register(
EntryBuilder.For<TypeWithStaticCtor>()
);
var actual = container.Resolve<TypeWithStaticCtor>();
Assert.IsNotNull( actual );
}
public void puzzleContainer_resolve_using_non_registered_type_should_raise_ArgumentException()
{
var container = new PuzzleContainer();
container.Resolve<Object>();
}
public void puzzleContainer_register_entry_using_instance_should_resolve_the_given_instance_as_singleton()
{
var container = new PuzzleContainer();
container.Register( EntryBuilder.For<Object>().UsingInstance( new Object() ) );
var expected = container.Resolve<Object>();
var actual = container.Resolve<Object>();
Assert.AreEqual( expected, actual );
}
public void puzzleContainer_register_entry_with_factory_as_singleton_should_call_factory_once()
{
var expected = 1;
var actual = 0;
var container = new PuzzleContainer();
container.Register
(
EntryBuilder.For<Object>()
.UsingFactory( () =>
{
actual++;
return new Object();
} )
);
container.Resolve<Object>();
container.Resolve<Object>();
Assert.AreEqual( expected, actual );
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_with_factory_method()
{
var entry = EntryBuilder.For<IFoo>()
.Forward<IBar>()
.UsingFactory( () => new TypeWithMultipleContracts() )
.WithLifestyle( Lifestyle.Singleton );
var sut = new PuzzleContainer();
sut.Register( entry );
var iBar = sut.Resolve<IBar>();
var iFoo = sut.Resolve<IFoo>();
Assert.AreEqual( iBar, iFoo );
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_in_singleton_types()
{
var entry = EntryBuilder.For<IFoo>()
.Forward<IBar>()
.ImplementedBy<TypeWithMultipleContracts>();
var sut = new PuzzleContainer();
sut.Register( entry );
var iBar = sut.Resolve<IBar>();
var iFoo = sut.Resolve<IFoo>();
Assert.AreEqual( iBar, iFoo );
}
public void PuzzleContainer_Resolve_using_overridable_types_should_resolve_even_all_are_marked_as_overridable()
{
var obj1 = new Object();
var obj2 = new Object();
var sut = new PuzzleContainer();
sut.Register(
EntryBuilder.For<Object>()
.UsingInstance( obj1 )
.Overridable()
);
sut.Register(
EntryBuilder.For<Object>()
.UsingInstance( obj2 )
.Overridable()
);
var actual = sut.Resolve<Object>();
Assert.AreEqual( obj1, actual );
}
public void puzzleContainer_resolve_using_non_registered_type_should_raise_ArgumentException()
{
var container = new PuzzleContainer();
container.Resolve <Object>();
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_in_transient_types()
{
var entry = EntryBuilder.For<IFoo>()
.Forward<IBar>()
.ImplementedBy<TypeWithMultipleContracts>()
.WithLifestyle( Lifestyle.Transient );
var sut = new PuzzleContainer();
sut.Register( entry );
var iBar = sut.Resolve<IBar>();
var iFoo = sut.Resolve<IFoo>();
Assert.IsNotNull( iBar );
Assert.IsNotNull( iFoo );
Assert.AreNotEqual(iBar, iFoo);
Assert.IsTrue( iBar.GetType().Is<TypeWithMultipleContracts>() );
Assert.IsTrue( iFoo.GetType().Is<TypeWithMultipleContracts>() );
}
public void puzzleContainer_register_entries_using_valid_entry_should_resolve_the_given_entries()
{
var container = new PuzzleContainer();
IContainerEntry e1 = EntryBuilder.For<ArgumentException>();
IContainerEntry e2 = EntryBuilder.For<ArgumentNullException>();
container.Register( new[] { e1, e2 } );
var obj1 = container.Resolve<ArgumentException>();
var obj2 = container.Resolve<ArgumentNullException>();
Assert.IsNotNull( obj1 );
Assert.IsNotNull( obj2 );
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding_with_instances()
{
var entry = EntryBuilder.For<IFoo>()
.Forward<IBar>()
.UsingInstance( new TypeWithMultipleContracts() );
var sut = new PuzzleContainer();
sut.Register( entry );
var iBar = sut.Resolve<IBar>();
var iFoo = sut.Resolve<IFoo>();
Assert.AreEqual( iBar, iFoo );
}
public void puzzleContainer_register_entry_as_transient_should_resolve_instances_as_transient()
{
var container = new PuzzleContainer();
container.Register( EntryBuilder.For<Object>().WithLifestyle( Lifestyle.Transient ) );
var i1 = container.Resolve<Object>();
var i2 = container.Resolve<Object>();
Assert.AreNotEqual( i1, i2 );
}
public void PuzzleContainer_at_dispose_should_dispose_singleton_references()
{
var entry = EntryBuilder.For<IFoo>()
.ImplementedBy<DisposableFoo>()
.WithLifestyle(Lifestyle.Singleton);
var sut = new PuzzleContainer();
sut.Register(entry);
var iFoo = (DisposableFoo)sut.Resolve<IFoo>();
sut.Dispose();
Assert.IsTrue(iFoo.Disposed);
}
public void puzzleContainer_register_entry_with_factory_as_transient_should_resolve_instances_as_transient()
{
var expected = 2;
var actual = 0;
var container = new PuzzleContainer();
container.Register
(
EntryBuilder.For<Object>()
.UsingFactory( () =>
{
actual++;
return new Object();
} )
.WithLifestyle( Lifestyle.Transient )
);
container.Resolve<Object>();
container.Resolve<Object>();
Assert.AreEqual( expected, actual );
}