public void Container_registrations_can_be_iterated()
{
var container = new PocketContainer();
container.Count().Should().BeGreaterThan(1);
container.Select(r => r.Key).Should().Contain(typeof(PocketContainer));
}
public void AfterResolve_is_invoked_after_a_strategy_registration_is_resolved_using_Resolve_T()
{
Type typeArg = null;
object instanceArg = null;
var container = new PocketContainer()
.AddStrategy(type =>
{
if (type == typeof(string))
{
return(c => "hello");
}
return(null);
});
container.AfterResolve += (type, instance) =>
{
typeArg = type;
instanceArg = instance;
return(instance);
};
container.Resolve <string>();
typeArg.Should().Be(typeof(string));
instanceArg.Should().Be("hello");
}
public static PocketContainer DefaultToJsonSnapshots(this PocketContainer container)
{
return(container.AddStrategy(type =>
{
if (type.IsInterface &&
type.IsGenericType)
{
if (type.GetGenericTypeDefinition() == typeof(ICreateSnapshot <>))
{
var snapshotCreatorType = typeof(JsonSnapshotter <>)
.MakeGenericType(type.GetGenericArguments().Single());
return c => c.Resolve(snapshotCreatorType);
}
if (type.GetGenericTypeDefinition() == typeof(IApplySnapshot <>))
{
var snapshotCreatorType = typeof(JsonSnapshotter <>)
.MakeGenericType(type.GetGenericArguments().Single());
return c => c.Resolve(snapshotCreatorType);
}
}
return null;
}));
}
public async Task AfterCreating_is_threadsafe()
{
var container = new PocketContainer()
.Register <IList <string> >(c => new List <string>());
var barrier = new Barrier(2);
var task1 = Task.Run(() =>
{
barrier.SignalAndWait();
container.AfterCreating <IList <string> >(list =>
{
list.Add("one");
});
});
var task2 = Task.Run(() =>
{
barrier.SignalAndWait();
container.AfterCreating <IList <string> >(list =>
{
list.Add("two");
});
});
await Task.WhenAll(task1, task2);
container.Resolve <IList <string> >()
.Should()
.Contain("one")
.And
.Contain("two");
}
public void AfterCreating_type_matching_is_precise()
{
var container = new PocketContainer()
.Register <IList <string> >(c => new List <string>())
.Register <List <string> >(c => new List <string>())
.AfterCreating <List <string> >(l =>
{
l.Add("List");
})
.AfterCreating <IList <string> >(l =>
{
l.Add("IList");
});
var ilist = container.Resolve <IList <string> >();
var list = container.Resolve <List <string> >();
ilist.Should()
.HaveCount(1)
.And
.OnlyContain(item => item == "IList");
list.Should()
.HaveCount(1)
.And
.OnlyContain(item => item == "List");
}
public void Top_level_types_resolved_from_the_dependency_resolver()
{
var resolver = new FakeDependencyResolver(t => "hola!");
var container = new PocketContainer().IncludeDependencyResolver(resolver);
container.Resolve<string>().Should().Be("hola!");
}
public void Top_level_types_resolved_from_the_dependency_resolver()
{
var resolver = new FakeDependencyResolver(t => "hola!");
var container = new PocketContainer().IncludeDependencyResolver(resolver);
container.Resolve <string>().Should().Be("hola!");
}
public void UseDependencies_can_be_used_to_set_dependencies_using_an_application_owned_container()
{
var applicationsContainer = new PocketContainer()
.Register <IPaymentService>(_ => new CreditCardPaymentGateway(chargeLimit: 1));
Configuration.Current
.UseDependencies(type =>
{
if (applicationsContainer.Any(reg => reg.Key == type))
{
return(() => applicationsContainer.Resolve(type));
}
return(null);
});
var order = new Order(new CreateOrder(Any.FullName()))
.Apply(new AddItem
{
Price = 5m,
ProductName = Any.Word()
})
.Apply(new Ship())
.Apply(new ChargeAccount
{
AccountNumber = Any.PositiveInt().ToString()
});
order.Events()
.Last()
.Should()
.BeOfType <Order.PaymentConfirmed>();
}
internal static void TrySubscribeDiscoveredHandler <T>(
Configuration configuration,
Type commandType,
PocketContainer c,
ICommandReceiver <T> receiver)
{
foreach (var handlerDescription in
configuration.CommandHandlerDescriptions
.Where(t => t.HandledCommandType == commandType))
{
var handler = c.Resolve(handlerDescription.HandlerInterface) as ICommandHandler <T>;
if (configuration.Properties.TracingEnabled)
{
handler = handler.Trace();
}
var subscription = receiver.Subscribe(handler);
configuration.RegisterForDisposal(subscription);
Logger <Configuration> .Log.Trace(
"Subscribing discovered command handler: {handler} to handle commands of type {commandType}",
handlerDescription.ConcreteHandlerType,
handlerDescription.HandledCommandType);
}
}
public void Registering_is_invoked_when_lazy_registration_occurs()
{
var receivedDelegates = new List <Delegate>();
var container = new PocketContainer();
container.Registering += (type, f) =>
{
receivedDelegates.Add(f);
return(f);
};
container.AddStrategy(type =>
{
if (type == typeof(string))
{
return(c => "hello");
}
return(null);
});
container.Resolve <string>();
receivedDelegates
.Should()
.HaveCount(1);
receivedDelegates
.Single()
.Should()
.BeOfType <Func <PocketContainer, object> >();
}
public void Can_resolve_via_a_registered_untyped_factory_function()
{
var s = Guid.NewGuid().ToString();
var container = new PocketContainer().Register(typeof(string), c => s);
container.Resolve <string>().Should().Be(s);
}
public void Default_construction_strategy_can_be_overridden_example_1_implicit_IEnumerable_support()
{
var container = new PocketContainer()
.Register(c => "good day!")
.Register(c => 456);
// when someone asks for an IEnumerable<T> give back a List<T> containing the registered value
container.AddStrategy(type =>
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
return(c =>
{
var singleInstanceType = type.GetGenericArguments().Single();
var listType = typeof(List <>).MakeGenericType(singleInstanceType);
var list = Activator.CreateInstance(listType);
var resolved = c.Resolve(singleInstanceType);
((dynamic)list).Add((dynamic)resolved);
return list;
});
}
return(null);
});
var strings = container.Resolve <IEnumerable <string> >();
var ints = container.Resolve <IEnumerable <int> >();
Console.WriteLine(strings);
Console.WriteLine(ints);
ints.Single().Should().Be(456);
strings.Single().Should().Be("good day!");
}
public void Multiple_AfterResolve_functions_can_be_applied()
{
var container = new PocketContainer()
.Register(c =>
{
var hashSet = new HashSet <string> {
"initial"
};
return(hashSet);
})
.AfterResolve <HashSet <string> >((c, hashSet) =>
{
hashSet.Add("one");
return(hashSet);
})
.AfterResolve <HashSet <string> >((c, hashSet) =>
{
hashSet.Add("two");
return(hashSet);
});
var set = container.Resolve <HashSet <string> >();
set.Should().BeEquivalentTo(new object[] { "initial", "one", "two" });
}
public void Strategies_can_be_chained()
{
var container = new PocketContainer()
.AddStrategy(t =>
{
if (t == typeof(IEnumerable <int>))
{
return(c => new[] { 1, 2, 3 });
}
return(null);
})
.AddStrategy(t =>
{
if (t == typeof(IEnumerable <string>))
{
return(c => new[] { "1", "2", "3" });
}
return(null);
});
container.Resolve <IEnumerable <int> >()
.Should()
.BeEquivalentTo(new[] { 1, 2, 3 });
container.Resolve <IEnumerable <string> >()
.Should()
.BeEquivalentTo("1", "2", "3");
}
public void Registrations_on_the_clone_override_original_when_a_type_is_registered_in_both()
{
var original = new PocketContainer()
.Register(c => "from original");
var clone = original.Clone().Register(c => "from clone");
clone.Resolve <string>().Should().Be("from clone");
}
public void Top_level_instances_are_resolved_from_the_clone_when_it_has_a_registration()
{
var original = new PocketContainer();
var clone = original.Clone().Register(c => "from clone");
clone.Resolve <string>().Should().Be("from clone");
}
public void PocketContainer_is_implicitly_registered_to_itself()
{
var container = new PocketContainer();
var resolvedContainer = container.Resolve <PocketContainer>();
Assert.AreSame(container, resolvedContainer);
}
public void When_no_registration_exists_then_TryRegister_T_registers()
{
var container = new PocketContainer();
container.TryRegister(c => "one");
container.Resolve <string>().Should().Be("one");
}
public PocketContainerDependencyResolver(PocketContainer container)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
this.container = container;
}
public void Optional_nullable_struct_parameters_with_no_default_value_are_filled_correctly()
{
var container = new PocketContainer();
var o = container.Resolve <TakesOptionalParamWithNoDefaultValue <int?> >();
o.OptionalValue.Should().Be(0);
}
public void When_a_type_cannot_be_resolved_via_GetRequiredService_it_throws()
{
var container = new PocketContainer() as ISupportRequiredService;
Action resolve = () => container.GetRequiredService(typeof(string));
resolve.ShouldThrow <ArgumentException>();
}
public void Optional_parameters_for_non_primitive_types_are_passed_null_when_not_registered()
{
var container = new PocketContainer();
var o = container.Resolve <TakesOptionalParamWithDefaultValueSpecifiedAsDefault <IAmAnInterface> >();
o.OptionalValue.Should().BeNull();
}
public void Optional_string_parameters_with_default_value_are_filled_correctly()
{
var container = new PocketContainer();
var o = container.Resolve <TakesOptionalStringParamWithDefaultValue>();
o.OptionalValue.Should().Be(TakesOptionalStringParamWithDefaultValue.DefaultValue);
}
public void ResolveOptional_returns_null_when_dependency_is_unresolvable()
{
var container = new PocketContainer();
var value = container.ResolveOptional(typeof(HasOneParamCtor <IAmAnInterface>));
value.Should().BeNull();
}
public void Registrations_on_the_override_override_primary_when_a_type_is_registered_in_both()
{
var primary = new PocketContainer()
.Register(c => "from primary");
var @override = primary.CreateOverrideContainer().Register(c => "from override");
@override.Resolve <string>().Should().Be("from override");
}
public void ResolveOptional_returns_default_when_struct_is_unregistered()
{
var container = new PocketContainer();
var value = container.ResolveOptional(typeof(int));
value.Should().Be(0);
}
public void ResolveOptional_returns_null_when_delegate_type_is_unregistered()
{
var container = new PocketContainer();
var value = container.ResolveOptional(typeof(SomeDelegateType));
value.Should().BeNull();
}
public void ResolveOptional_returns_null_when_interface_is_unregistered()
{
var container = new PocketContainer();
var value = container.ResolveOptional(typeof(IAmAnInterface));
value.Should().BeNull();
}
public void Can_resolve_Func_of_unregistered_concrete_type_when_it_has_only_a_default_ctor()
{
var container = new PocketContainer();
var result = container.Resolve <Func <HasDefaultCtor> >();
result().Should().NotBeNull();
}
public void PocketContainer_is_implicitly_registered_to_itself()
{
var container = new PocketContainer();
var resolvedContainer = container.Resolve <PocketContainer>();
container.Should().BeSameAs(resolvedContainer);
}
public void When_multiple_implementations_are_found_then_an_error_is_thrown_on_Resolve()
{
var container = new PocketContainer()
.IfOnlyOneImplementationUseIt();
Action resolve = () => container.Resolve<IEnumerable>();
resolve.ShouldThrow<ArgumentException>();
}
public void Optional_string_parameters_with_no_default_value_are_filled_correctly()
{
var container = new PocketContainer();
var o = container.Resolve <TakesOptionalParamWithDefaultValueSpecifiedAsDefault <string> >();
o.OptionalValue.Should().BeNull();
}
public void Registrations_on_the_clone_override_original_when_a_type_is_registered_in_both()
{
var original = new PocketContainer()
.Register(c => "from original");
var clone = original.Clone().Register(c => "from clone");
clone.Resolve<string>().Should().Be("from clone");
}
public void When_an_unregistered_abstract_class_is_requested_then_a_mock_is_returned()
{
var container = new PocketContainer()
.AutoMockInterfacesAndAbstractClasses();
var obj = container.Resolve<PocketContainerSingleImplementationStrategyTests.AbstractlyImplements_IHaveOnlyOneImplementation>();
obj.Should().NotBeNull();
}
public void When_a_concrete_type_is_requested_then_it_is_Resolved()
{
var container = new PocketContainer()
.IfOnlyOneImplementationUseIt();
container.Resolve<Implements_IHaveOnlyOneImplementation>()
.Should()
.NotBeNull();
}
public void When_a_non_open_generic_type_is_registered_as_the_variantsOf_argument_then_it_throws()
{
var container = new PocketContainer();
Action registerWrongType = () =>
container.RegisterGeneric(typeof (string), typeof (List<>));
registerWrongType.ShouldThrow<ArgumentException>().And.Message.Should().Contain("'variantsOf'");
}
public void Instances_are_resolved_from_the_override_when_it_has_a_registration()
{
var primary = new PocketContainer();
var @override = primary.CreateOverrideContainer()
.Register(c => "from override");
@override.Resolve<string>().Should().Be("from override");
}
public void When_a_single_concrete_type_implementing_an_interface_is_found_then_it_is_Resolved()
{
var container = new PocketContainer()
.IfOnlyOneImplementationUseIt();
container.Resolve<IHaveOnlyOneImplementation>()
.Should()
.NotBeNull();
}
public void Types_with_names_ending_in_Settings_are_resolved_from_Settings_Get()
{
var container = new PocketContainer()
.UseItsConfigurationForSettings();
var settings = container.Resolve<PocketContainerStrategyTestSettings>();
settings.Value.Should().Be("hello");
}
public void When_an_unregistered_interface_is_requested_then_a_mock_is_returned()
{
var container = new PocketContainer()
.AutoMockInterfacesAndAbstractClasses();
var strings = container.Resolve<IEnumerable<string>>();
strings.Should().NotBeNull();
}
public void Empty_constructor_is_chosen_over_one_containing_a_string()
{
var container = new PocketContainer().AvoidConstructorsWithPrimitiveTypes();
var obj = container
.Resolve<HasDefaultAndOneParamCtor<string>>();
obj.Should().NotBeNull();
obj.Value.Should().BeNull();
}
public void A_strategy_on_the_clone_is_not_added_to_the_original()
{
var original = new PocketContainer();
original.Clone().AutoMockInterfacesAndAbstractClasses();
Action resolveFromOriginal = () =>
original.Resolve<IEnumerable<string>>();
resolveFromOriginal.ShouldThrow<ArgumentException>();
}
public void An_open_generic_interface_can_be_registered_to_an_open_generic_type_and_resolved_correctly()
{
var container = new PocketContainer();
container
.Register<List<string>>(c => new List<string>())
.RegisterGeneric(variantsOf: typeof (IEnumerable<>), to: typeof (List<>));
container.Resolve<IEnumerable<string>>().Should().BeOfType<List<string>>();
}
public void Dependencies_are_resolved_from_the_override_when_it_has_a_registration()
{
var primary = new PocketContainer();
var @override = primary.CreateOverrideContainer().Register(c => "from override");
@override.Resolve<HasOneParamCtor<string>>()
.Value1
.Should()
.Be("from override");
}
public void Dependencies_are_resolved_from_the_clone_when_it_has_a_registration()
{
var original = new PocketContainer();
var clone = original.Clone().Register(c => "from clone");
clone.Resolve<HasOneParamCtor<string>>()
.Value1
.Should()
.Be("from clone");
}
public void Second_level_dependencies_are_resolved_from_the_dependency_resolver()
{
var innerContainer = new PocketContainer()
.Register(c => "bonjour!");
var resolver = new FakeDependencyResolver(innerContainer.Resolve);
var container = new PocketContainer().IncludeDependencyResolver(resolver);
var obj = container.Resolve<HasOneParamCtor<string>>();
obj.Should().NotBeNull();
obj.Value1.Should().Be("bonjour!");
}
public void A_constructor_with_a_primitive_is_chosen_if_no_other_is_available()
{
var container = new PocketContainer()
.AvoidConstructorsWithPrimitiveTypes()
.Register(c => "howdy");
var obj = container
.Resolve<HasTwoParamCtor<string, HasDefaultCtor>>();
obj.Should().NotBeNull();
obj.Value1.Should().Be("howdy");
}
public void When_framework_dependency_constructor_throws_then_exception_is_thrown()
{
var container = new PocketContainer();
container.Register<IContentNegotiator>(c => new DependencyThatThrowOnConstruction());
var sut = new PocketContainerDependencyResolver(container);
Action resolveFrameworkDependency =
() => sut.GetService(typeof (IContentNegotiator));
resolveFrameworkDependency.ShouldThrow<HttpParseException>(
"because framework service implementation constructor threw an exception");
}
public void Dependencies_are_resolved_from_the_primary_container_when_registered_after_the_override_was_created()
{
var primary = new PocketContainer();
var @override = primary.CreateOverrideContainer();
primary.Register(c => "from primary");
@override.Resolve<HasOneParamCtor<string>>()
.Value1
.Should()
.Be("from primary");
}
public void AfterResolve_can_be_used_to_modify_the_output_of_a_default_registration()
{
var container = new PocketContainer()
.AfterResolve<HasDefaultCtor<int>>((c, obj) =>
{
obj.Value ++;
return obj;
});
var resolved = container.Resolve<HasDefaultCtor<int>>();
resolved.Value.Should().Be(1);
}
public void Dependencies_of_a_registration_from_the_primary_can_be_resolved_from_the_override()
{
var primary = new PocketContainer()
.Register<IAmAnInterface>(c => c.Resolve<HasOneParamCtor<string>>());
var @override = primary.CreateOverrideContainer()
.Register(c => "from override");
var obj = @override.Resolve<HasTwoParamCtor<string, IAmAnInterface>>();
obj.Value1.Should().Be("from override");
obj.Value2.Should().BeOfType<HasOneParamCtor<string>>();
((HasOneParamCtor<string>) obj.Value2).Value1.Should().Be("from override");
}
public void Dependencies_of_a_registration_from_the_original_can_be_resolved_from_the_clone()
{
var original = new PocketContainer()
.Register<IAmAnInterface>(c => c.Resolve<HasOneParamCtor<string>>());
var clone = original.Clone()
.Register(c => "from clone");
var obj = clone.Resolve<HasTwoParamCtor<string, IAmAnInterface>>();
obj.Value1.Should().Be("from clone");
obj.Value2.Should().BeOfType<HasOneParamCtor<string>>();
((HasOneParamCtor<string>) obj.Value2).Value1.Should().Be("from clone");
}
public void When_framework_dependency_constructor_cannot_be_satisfied_then_exception_is_swallowed()
{
var container = new PocketContainer();
container.Register<IContentNegotiator>(c => c.Resolve<UnsastisfiableDependency>());
var sut = new PocketContainerDependencyResolver(container);
Action resolveFrameworkDependency =
() => sut.GetService(typeof (IContentNegotiator));
Action resolveFrameworkDependencies =
() => sut.GetServices(typeof (IContentNegotiator)).ToArray();
resolveFrameworkDependency.ShouldNotThrow("because we're resolving a framework service");
resolveFrameworkDependencies.ShouldNotThrow("because we're resolving a framework service");
}
public void AfterResolve_can_be_called_before_Register_but_still_applies()
{
var container = new PocketContainer()
.AfterResolve<HashSet<string>>((c, hashSet) =>
{
hashSet.Add("next");
return hashSet;
})
.Register(c =>
{
var hashSet = new HashSet<string> { "initial" };
return hashSet;
});
var set = container.Resolve<HashSet<string>>();
set.Should().Contain("initial");
set.Should().Contain("next");
}
public void AfterResolve_can_be_used_to_get_an_existing_registration_and_modify_its_output_before_returning_it()
{
var container = new PocketContainer()
.Register(c =>
{
var hashSet = new HashSet<string> { "initial" };
return hashSet;
})
.AfterResolve<HashSet<string>>((c, hashSet) =>
{
hashSet.Add("next");
return hashSet;
});
var set = container.Resolve<HashSet<string>>();
set.Should().Contain("initial");
set.Should().Contain("next");
}
public void Top_level_instances_are_resolved_from_the_original_container_when_the_clone_has_no_registration()
{
var original = new PocketContainer()
.Register(c => "from original");
var clone = original.Clone();
clone.Resolve<string>()
.Should()
.Be("from original");
}
public void Strategies_are_cloned()
{
var original = new PocketContainer().AutoMockInterfacesAndAbstractClasses();
var clone = original.Clone();
clone.Resolve<IEnumerable<string>>()
.Should()
.NotBeNull();
}
public void Multiple_AfterResolve_functions_can_be_applied()
{
var container = new PocketContainer()
.Register(c =>
{
var hashSet = new HashSet<string> { "initial" };
return hashSet;
})
.AfterResolve<HashSet<string>>((c, hashSet) =>
{
hashSet.Add("one");
return hashSet;
})
.AfterResolve<HashSet<string>>((c, hashSet) =>
{
hashSet.Add("two");
return hashSet;
});
var set = container.Resolve<HashSet<string>>();
set.Should().BeEquivalentTo(new object[] { "initial", "one", "two" });
}
public void When_used_with_Register_then_AfterResolve_is_only_called_once_per_resolve()
{
var container = new PocketContainer()
.Register(c => new HasDefaultCtor<int>())
.AfterResolve<HasDefaultCtor<int>>((c, obj) =>
{
obj.Value ++;
return obj;
});
container.Resolve<HasDefaultCtor<int>>();
container.Resolve<HasDefaultCtor<int>>();
container.Resolve<HasDefaultCtor<int>>();
var resolved = container.Resolve<HasDefaultCtor<int>>();
resolved.Value.Should().Be(3);
}
public void When_a_strategy_on_the_clone_results_in_a_new_registration_then_the_original_contanier_is_not_affected()
{
var original = new PocketContainer();
var clone = original.Clone().AutoMockInterfacesAndAbstractClasses();
clone.Resolve<IEnumerable<string>>();
original.Count().Should().Be(clone.Count() - 1);
}
