public void When_the_same_type_is_registered_multiple_times_then_the_last_register_wins() { var container = new PocketContainer(); container.Register(c => 1); container.Register(c => 2); container.Resolve <int>().Should().Be(2); }
public void Multiple_registrations_of_T_can_be_resolved_as_an_IEnumerable_of_T() { var container = new PocketContainer() .AccumulateRegistrations(); container.Register(c => "one"); container.Register(c => "two"); container.Resolve <IEnumerable <string> >() .Should() .BeEquivalentTo("one", "two"); }
public void Can_resolve_Func_of_unregistered_concrete_type_by_choosing_the_most_verbose_ctor_and_resolving_recursively() { var container = new PocketContainer(); container.Register(c => "hello"); container.Register(c => new HasOneParamCtor <string>("there")); var result = container.Resolve <Func <HasTwoParamCtor <string, HasOneParamCtor <string> > > >(); result().Should().NotBeNull(); result().Value1.Should().Be("hello"); result().Value2.Value1.Should().Be("there"); }
public void Can_resolve_type_not_known_at_compile_time() { var container = new PocketContainer(); container.Register(c => "hello"); container.Register(c => new HasOneParamCtor <int>(42)); var result = container.Resolve(typeof(HasTwoParamCtor <string, HasOneParamCtor <int> >)) as HasTwoParamCtor <string, HasOneParamCtor <int> >; result.Should().NotBeNull(); result.Value1.Should().Be("hello"); result.Value2.Value1.Should().Be(42); }
public void When_a_registration_made_using_Register_already_exists_then_TryRegister_T_does_not_overwrite_it() { var container = new PocketContainer(); container.Register(c => "one"); container.TryRegister(c => "two"); container.Resolve <string>().Should().Be("one"); }
public void Can_resolve_a_registered_delegate_type() { var container = new PocketContainer(); var f = new SomeDelegateType(Can_resolve_a_registered_delegate_type); container.Register(c => f); container.Resolve <SomeDelegateType>().Should().Be(f); }
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 ConfigureApplication(IAppBuilder app) { var config = new HttpConfiguration(); var pocket = new PocketContainer(); config.ResolveDependenciesUsing(pocket); pocket.Register(c => thisServersNode); config.MapHttpAttributeRoutes(); app.UseWebApi(config); }
public void Lazy_is_implicitly_registered_when_registering_a_type() { var container = new PocketContainer(); container.Register(c => "oh hai"); var obj = container.Resolve <HasOneParamCtor <Lazy <string> > >(); obj.Value1.Value.Should().Be("oh hai"); }
public void Lazy_is_resolvable_for_unregistered_types() { var container = new PocketContainer(); container.Register(c => 123); var obj = container.Resolve <HasOneParamCtor <Lazy <int> > >(); obj.Value1.Value.Should().Be(123); }
public void Can_resolve_Func_of_unregistered_concrete_type_with_dependencies_when_it_has_only_a_default_ctor() { var container = new PocketContainer(); var result = container .Register(c => "hello") .Resolve <Func <HasOneParamCtor <string> > >(); result().Value1.Should().Be("hello"); }
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 TestApi() { HttpConfiguration = new HttpConfiguration { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always }.ResolveDependenciesUsing(Container); HttpConfiguration.MapRoutesFor <T>(); Container.Register <IEventSourcedRepository <T> >(c => new SqlEventSourcedRepository <T>()); }
public void When_nonframework_dependency_constructor_throws_then_exception_is_thrown() { var container = new PocketContainer(); container.Register <IMyDependency>(c => new DependencyThatThrowOnConstruction()); var sut = new PocketContainerDependencyResolver(container); Action resolveFrameworkDependency = () => sut.GetService(typeof(IMyDependency)); resolveFrameworkDependency.ShouldThrow <HttpParseException>("because GetService is resolving our own interface"); }
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 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 .Register(c => new List <string>()) .Clone() .RegisterGeneric(typeof(IEnumerable <>), to: typeof(List <>)); clone.Resolve <IEnumerable <string> >(); original.Count().Should().Be(clone.Count() - 1); }
public TestTargetRegistry Add(string environment, string application, Uri baseAddress, Action <TestDependencyRegistry> testDependencies = null) { if (environment == null) { throw new ArgumentNullException("environment"); } if (application == null) { throw new ArgumentNullException("application"); } if (baseAddress == null) { throw new ArgumentNullException("baseAddress"); } if (!baseAddress.IsAbsoluteUri) { throw new ArgumentException("Base address must be an absolute URI."); } var testTarget = new TestTarget { Application = application, Environment = environment, BaseAddress = baseAddress }; var container = new PocketContainer() .Register(c => new HttpClient()) .Register(c => testTarget); if (testDependencies != null) { testDependencies(new TestDependencyRegistry((t, func) => container.Register(t, c => func()))); } container.AfterResolve <HttpClient>((c, client) => { if (client.BaseAddress == null) { client.BaseAddress = testTarget.BaseAddress; } return(client); }); testTarget.ResolveDependency = container.Resolve; targets.Add(environment + ":" + application, testTarget); return(this); }
public void Lazy_registrations_in_the_override_do_not_modify_the_parent() { var primary = new PocketContainer(); var @override = primary.CreateOverrideContainer(); primary.Register(c => "from primary"); @override.Resolve <HasDefaultCtor>(); primary.Count(reg => reg.Key == typeof(HasDefaultCtor)).Should().Be(0); }
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 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 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 When_nonframework_dependency_constructor_cannot_be_satisfied_then_exception_is_thrown() { var container = new PocketContainer(); container.Register <IMyDependency>(c => c.Resolve <UnsastisfiableDependency>()); var sut = new PocketContainerDependencyResolver(container); Action resolveFrameworkDependency = () => sut.GetService(typeof(IMyDependency)); resolveFrameworkDependency.ShouldThrow <ArgumentException>("because GetService is resolving our own interface") .And .Message .Should() .Contain("+IAmUnregistered"); }
public InMemorySchedulingAndHandlingTests(ITestOutputHelper output) : base(output) { virtualClock = VirtualClock.Start(); container .Register(c => virtualClock) .RegisterSingle(c => new InMemoryCommandBus <string>(virtualClock)) .RegisterGeneric( variantsOf: typeof(ICommandReceiver <>), to: typeof(InMemoryCommandBus <>), singletons: true) .RegisterGeneric( variantsOf: typeof(ICommandScheduler <>), to: typeof(InMemoryCommandBus <>), singletons: true); disposables.Add(virtualClock); }
public void Configuration_can_specify_a_dependency_resolver_which_is_then_used_when_resolving_handlers() { var container = new PocketContainer(); container.Register(c => "hello"); var configuration = new Configuration() .UseSqlEventStore() .UseDependency(resolve: resolve => (IEventBus)resolve(typeof(EventBusWithDependencies))) .UseDependency <IEnumerable <string> >(_ => new[] { "hello" }); var bus = configuration.EventBus; bus.Should().BeOfType <EventBusWithDependencies>(); var busWithDependencies = bus as EventBusWithDependencies; busWithDependencies.StringValues.Single().Should().Be("hello"); }
public ICommandSchedulerDispatcher InitializeScheduler( IObserver <ICommandSchedulerActivity> subject, PocketContainer container, Func <IEvent, string> getClockName) { var binder = container.Resolve <SqlCommandSchedulerBinder <TAggregate> >(); var scheduler = binder.Scheduler; scheduler.GetClockName = getClockName; scheduler.Activity = subject; var schedulerType = typeof(ICommandScheduler <TAggregate>); if (container.All(t => t.Key != schedulerType)) { container.Register(schedulerType, c => scheduler); } return(binder); }
public void Registering_is_invoked_when_registering_using_Register() { var receivedDelegates = new List <Delegate>(); var container = new PocketContainer(); container.Registering += (type, f) => { receivedDelegates.Add(f); return(f); }; container.Register(typeof(string), c => "hello"); container.Resolve <string>(); receivedDelegates .Should() .HaveCount(1); receivedDelegates .Single() .Should() .BeOfType <Func <PocketContainer, string> >(); }
public void Lazy_registrations_in_the_override_do_not_modify_the_parent() { var primary = new PocketContainer(); var @override = primary.CreateOverrideContainer(); primary.Register(c => "from primary"); @override.Resolve<HasDefaultCtor>(); primary.Count(reg => reg.Key == typeof (HasDefaultCtor)).Should().Be(0); }
public void When_nonframework_dependency_constructor_throws_then_exception_is_thrown() { var container = new PocketContainer(); container.Register<IMyDependency>(c => new DependencyThatThrowOnConstruction()); var sut = new PocketContainerDependencyResolver(container); Action resolveFrameworkDependency = () => sut.GetService(typeof (IMyDependency)); resolveFrameworkDependency.ShouldThrow<HttpParseException>("because GetService is resolving our own interface"); }
public void When_nonframework_dependency_constructor_cannot_be_satisfied_then_exception_is_thrown() { var container = new PocketContainer(); container.Register<IMyDependency>(c => c.Resolve<UnsastisfiableDependency>()); var sut = new PocketContainerDependencyResolver(container); Action resolveFrameworkDependency = () => sut.GetService(typeof (IMyDependency)); resolveFrameworkDependency.ShouldThrow<ArgumentException>("because GetService is resolving our own interface") .And .Message .Should() .Contain("+IAmUnregistered"); }
public TestTargetRegistry Add( string environment, string application, Uri baseAddress, Action <TestDependencyRegistry> testDependencies = null) { if (baseAddress == null) { throw new ArgumentNullException(nameof(baseAddress)); } if (!baseAddress.IsAbsoluteUri) { throw new ArgumentException("Base address must be an absolute URI."); } if (string.IsNullOrWhiteSpace(environment)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(environment)); } if (string.IsNullOrWhiteSpace(application)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(application)); } var container = new PocketContainer() .Register(c => new HttpClient()) .RegisterSingle(c => new TestTarget(c.Resolve) { Application = application, Environment = environment, BaseAddress = baseAddress }); if (services != null) { // fall back to application's IServiceProvider container.AddStrategy(type => { if (typeof(IPeakyTest).IsAssignableFrom(type)) { return(null); } return(c => services.GetRequiredService(type)); }); } testDependencies?.Invoke(new TestDependencyRegistry((t, func) => container.Register(t, c => func()))); container.AfterCreating <HttpClient>(client => { if (client.BaseAddress == null) { client.BaseAddress = baseAddress; } return(client); }); targets.Add($"{environment}:{application}", new Lazy <TestTarget>(() => container.Resolve <TestTarget>())); return(this); }