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 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 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> >(); }
internal static PocketContainer RegisterDefaultClockName(this PocketContainer container) => container.AddStrategy(t => { if (t == typeof(GetClockName)) { return(c => new GetClockName(e => CommandScheduler.Clock.DefaultClockName)); } return(null); });
internal static PocketContainer AddFallbackToDefaultClock(this PocketContainer container) { return(container.AddStrategy(t => { if (t == typeof(GetClockName)) { return c => new GetClockName(e => CommandScheduler.SqlCommandScheduler.DefaultClockName); } return null; })); }
/// <summary> /// Uses Its.Configuration to resolve unregistered types whose name ends with "Settings". /// </summary> /// <param name="container">The container.</param> /// <returns>The same container instance.</returns> public static PocketContainer UseItsConfigurationForSettings( this PocketContainer container) { return(container.AddStrategy(type => { if (!type.IsInterface && !type.IsAbstract && !type.IsGenericTypeDefinition && type.Name.EndsWith("Settings")) { return c => Settings.Get(type); } return null; })); }
public static PocketContainer UseImmediateCommandScheduling(this PocketContainer container) { return(container.AddStrategy(type => { if (type.IsInterface && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ICommandScheduler <>)) { var targetType = type.GetGenericArguments().First(); var schedulerType = typeof(CommandScheduler <>).MakeGenericType(targetType); return c => c.Resolve(schedulerType); } return null; })); }
public static PocketContainer IfOnlyOneImplementationUseIt( this PocketContainer container) { return(container.AddStrategy(type => { if (type.IsInterface || type.IsAbstract) { var implementations = Discover.ConcreteTypesDerivedFrom(type) .ToArray(); if (implementations.Count() == 1) { var implementation = implementations.Single(); return c => c.Resolve(implementation); } } return null; })); }
public void Explicitly_registered_instances_are_not_overwritten_by_overriding_the_default_construction_strategy() { var ints = Observable.Return(123); var container = new PocketContainer() .Register(c => ints); // when someone asks for an unregistered interface, generate a mock container.AddStrategy(type => c => { if (type.IsInterface) { dynamic mock = Activator.CreateInstance(typeof(Mock <>).MakeGenericType(type)); return(mock.Object); } return(null); }); container.Resolve <IObservable <string> >().Should().NotBeNull(); container.Resolve <IObservable <int> >().Should().BeSameAs(ints); }
public void When_a_strategy_has_resolved_an_unregistered_type_then_TryRegister_T_will_not_overwrite_it() { var container = new PocketContainer(); container.AddStrategy(type => { if (typeof(string) == type) { return(c => "one"); } return(null); }); // trigger the strategy container.Resolve <string>(); container.TryRegister(c => "two"); container.Resolve <string>().Should().Be("one"); }
public void A_strategy_can_be_used_to_register_a_singleton() { var container = new PocketContainer(); container.AddStrategy(type => { if (type == typeof(IList <string>)) { container.RegisterSingle <IList <string> >(c => new List <string>()); return(c => c.Resolve <IList <string> >()); } return(null); }); var list1 = container.Resolve <IList <string> >(); var list2 = container.Resolve <IList <string> >(); list1.Should().BeSameAs(list2); }
public void Default_construction_strategy_can_be_overridden_example_2_auto_mocking() { var container = new PocketContainer(); // when someone asks for an IEnumerable<T> give back a List<T> containing the registered value container.AddStrategy(type => { if (type.IsInterface) { return(c => { dynamic mock = Activator.CreateInstance(typeof(Mock <>).MakeGenericType(type)); return mock.Object; }); } return(null); }); var obj = container.Resolve <IObservable <string> >(); obj.Should().NotBeNull(); }
public static PocketContainer AddStoreStrategy(this PocketContainer container) { return(container.AddStrategy(type => { if (type.IsInterface && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IStore <>)) { var targetType = type.GetGenericArguments().First(); Type applierType; if (typeof(IEventSourced).IsAssignableFrom(targetType)) { applierType = typeof(IEventSourcedRepository <>).MakeGenericType(targetType); return c => c.Resolve(applierType); } } return null; })); }
public void Resolve_doesnt_result_in_cumulative_registrations() { var container = new PocketContainer(); container.AddStrategy(t => { if (t == typeof(int)) { var counter = 0; return(c => ++ counter); } return(null); }); var one = container.Resolve <int>(); var two = container.Resolve <int>(); Console.WriteLine(new { one, two }); Action resolveEnumerable = () => container.Resolve <IEnumerable <int> >(); resolveEnumerable.ShouldThrow <ArgumentException>(); }
public void Explicitly_registered_instances_are_not_overwritten_by_overriding_the_default_construction_strategy() { var ints = Enumerable.Range(1, 123); var container = new PocketContainer() .Register(c => ints); // when someone asks for an unregistered IEnumerable, return a list container.AddStrategy(type => c => { if (type.GetTypeInfo().IsInterface) { return(Activator.CreateInstance(typeof(List <>) .MakeGenericType( type.GetTypeInfo() .GenericTypeArguments .Single()))); } return(null); }); container.Resolve <IEnumerable <string> >().Should().NotBeNull(); container.Resolve <IEnumerable <int> >().Should().BeSameAs(ints); }
public void When_an_added_strategy_returns_null_then_it_falls_back_to_the_default() { var container = new PocketContainer() .Register(c => "still here"); // when someone asks for an IEnumerable<T> give back a List<T> containing the registered value container.AddStrategy(type => { if (type.GetTypeInfo().IsInterface) { return(c => { dynamic mock = Activator.CreateInstance(typeof(List <>).MakeGenericType(type)); return mock.Object; }); } return(null); }); var obj = container.Resolve <HasOneParamCtor <string> >(); obj.Should().NotBeNull(); obj.Value1.Should().Be("still here"); }
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); }