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_register_entry_should_report_entry_as_registered()
{
var container = new PuzzleContainer();
container.Register(EntryBuilder.For <Object>());
var actual = container.IsRegistered <Object>();
Assert.IsTrue(actual);
}
public void puzzleContainer_register_entry_using_instance_should_resolve_the_given_instance_using_getService_as_singleton()
{
var container = new PuzzleContainer();
container.Register(EntryBuilder.For <Object>().UsingInstance(new Object()));
var expected = container.GetService(typeof(Object));
var actual = container.GetService(typeof(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_resolveAll_non_generic_should_behave_as_expected()
{
var obj1 = new Object();
var obj2 = new Object();
var container = new PuzzleContainer();
container.Register(
EntryBuilder.For <Object>().UsingInstance(obj1)
);
container.Register(
EntryBuilder.For <Object>().UsingInstance(obj2)
);
IEnumerable <Object> actual = container.ResolveAll(typeof(Object));
Assert.IsTrue(actual.Contains(obj1));
Assert.IsTrue(actual.Contains(obj2));
}
public void puzzleContainer_register_entry_using_instance_should_resolve_the_given_instance()
{
var expected = new Object();
var container = new PuzzleContainer();
container.Register(EntryBuilder.For <Object>().UsingInstance(expected));
var actual = 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_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_register_should_raise_componentRegistered_event_with_a_reference_to_the_registered_entry()
{
IContainerEntry expected = EntryBuilder.For <Object>();
IContainerEntry actual = null;
var container = new PuzzleContainer();
container.ComponentRegistered += (s, e) => actual = e.Entry;
container.Register(expected);
Assert.AreEqual(expected, actual);
}
public void puzzleContainer_register_should_raise_componentRegistered_event()
{
var expected = 1;
var actual = 0;
var container = new PuzzleContainer();
container.ComponentRegistered += (s, e) => actual++;
container.Register(EntryBuilder.For <Object>());
Assert.AreEqual(expected, 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_entryBuilder_should_support_contract_forwarding()
{
var entry = EntryBuilder.For <IFoo>()
.Forward <IBar>()
.ImplementedBy <TypeWithMultipleContracts>();
var sut = new PuzzleContainer();
sut.Register(entry);
var actual = sut.IsRegistered <IBar>();
Assert.IsTrue(actual);
}
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_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_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_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_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_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_register_should_raise_componentRegistered_event()
{
var expected = 1;
var actual = 0;
var container = new PuzzleContainer();
container.ComponentRegistered += ( s, e ) => actual++;
container.Register( EntryBuilder.For<Object>() );
Assert.AreEqual( expected, actual );
}
public void puzzleContainer_register_entry_using_instance_should_resolve_the_given_instance_using_getService_as_singleton()
{
var container = new PuzzleContainer();
container.Register( EntryBuilder.For<Object>().UsingInstance( new Object() ) );
var expected = container.GetService( typeof( Object ) );
var actual = container.GetService( typeof( Object ) );
Assert.AreEqual( expected, actual );
}
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_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_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_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_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_register_entries_using_null_reference_should_raise_ArgumentNullException()
{
var container = new PuzzleContainer();
container.Register( ( IEnumerable<IContainerEntry> )null );
}
public void puzzleContainer_register_entry_using_valid_entry_should_not_fail()
{
var container = new PuzzleContainer();
container.Register(EntryBuilder.For <string>());
}
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_entries_using_null_reference_should_raise_ArgumentNullException()
{
var container = new PuzzleContainer();
container.Register((IEnumerable <IContainerEntry>)null);
}
public void puzzleContainer_register_should_raise_componentRegistered_event_with_a_reference_to_the_registered_entry()
{
IContainerEntry expected = EntryBuilder.For<Object>();
IContainerEntry actual = null;
var container = new PuzzleContainer();
container.ComponentRegistered += ( s, e ) => actual = e.Entry;
container.Register( expected );
Assert.AreEqual( expected, actual );
}
public void puzzleContainer_resolveAll_non_generic_should_behave_as_expected()
{
var obj1 = new Object();
var obj2 = new Object();
var container = new PuzzleContainer();
container.Register(
EntryBuilder.For<Object>().UsingInstance( obj1 )
);
container.Register(
EntryBuilder.For<Object>().UsingInstance( obj2 )
);
IEnumerable<Object> actual = container.ResolveAll( typeof( Object ) );
Assert.IsTrue( actual.Contains( obj1 ) );
Assert.IsTrue( actual.Contains( obj2 ) );
}
public void puzzleContainer_register_entry_using_instance_should_resolve_the_given_instance()
{
var expected = new Object();
var container = new PuzzleContainer();
container.Register( EntryBuilder.For<Object>().UsingInstance( expected ) );
var actual = container.Resolve<Object>();
Assert.AreEqual( expected, 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_register_entry_should_report_entry_as_registered()
{
var container = new PuzzleContainer();
container.Register( EntryBuilder.For<Object>() );
var actual = container.IsRegistered<Object>();
Assert.IsTrue( actual );
}
public void PuzzleContainer_entryBuilder_should_support_contract_forwarding()
{
var entry = EntryBuilder.For<IFoo>()
.Forward<IBar>()
.ImplementedBy<TypeWithMultipleContracts>();
var sut = new PuzzleContainer();
sut.Register( entry );
var actual = sut.IsRegistered<IBar>();
Assert.IsTrue( 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_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_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_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_register_entry_using_valid_entry_should_not_fail()
{
var container = new PuzzleContainer();
container.Register( EntryBuilder.For<String>() );
}
public void PuzzleContainer_entryBuilder_should_fail_if_implementation_does_not_support_one_of_the_contracts()
{
//TODO: Not yet implemented
var entry = EntryBuilder.For<IFoo>()
.Forward<IAmNotUsed>()
.UsingInstance( new TypeWithMultipleContracts() );
var sut = new PuzzleContainer();
sut.Register( entry );
}