public void ExplicitPluginFamilyDefinitionOverridesImplicitDefinition() { PluginGraph pluginGraph = DataMother.GetPluginGraph("ExplicitPluginFamilyOverridesImplicitPluginFamily.xml"); PluginFamily family = pluginGraph.FindFamily(typeof(GrandChild)); Assert.AreEqual("Fred", family.DefaultInstanceKey); }
public void should_get_the_greediest_constructor_if_there_is_more_than_one() { var selector = new ConstructorSelector(PluginGraph.CreateRoot()); var constructor = selector.Select(typeof(GreaterThanRule), new DependencyCollection()); constructor.GetParameters().Select(x => x.ParameterType) .ShouldHaveTheSameElementsAs(typeof(IWidget), typeof(Rule)); }
public void Process(Type type, PluginGraph graph) { if (CanBeCast(typeof(IController), type)) { string name = type.Name.Replace("Controller", "").ToLower(); graph.AddType(typeof(IController), type, name); } }
public RootPipelineGraph(PluginGraph pluginGraph) { _pluginGraph = pluginGraph; _transientCache = new NulloTransientCache(); _profiles = new Cache <string, IPipelineGraph>( name => new ComplexPipelineGraph(this, _pluginGraph.Profile(name), new NulloTransientCache())); }
private void addCloseGenericPolicyTo(PluginGraph graph) { var policy = new CloseGenericFamilyPolicy(graph); graph.AddFamilyPolicy(policy); graph.Profiles.Each(addCloseGenericPolicyTo); }
public void find_family_for_concrete_type_with_default() { PluginGraph graph = PluginGraph.Empty(); graph.Families[typeof(BigThingy)].GetDefaultInstance() .ShouldBeOfType <ConstructorInstance>() .PluggedType.ShouldEqual(typeof(BigThingy)); }
public IPipelineGraph ToNestedGraph() { var nestedPluginGraph = new PluginGraph(Profile + " - Nested"); var instances = new ComplexInstanceGraph(this, nestedPluginGraph, ContainerRole.Nested); return(new PipelineGraph(nestedPluginGraph, instances, this, _singletons, new NestedContainerTransientObjectCache())); }
public void transient_cache_of_nested_pipeline_graph_is_a_stateful_cache() { var plugins = PluginGraph.CreateRoot(); var pipeline = PipelineGraph.BuildRoot(plugins); pipeline.ToNestedGraph().Transients.ShouldBeOfType <ContainerSpecificObjectCache>(); }
public void transient_cache_by_default_is_a_nullo() { var plugins = new PluginGraph(); var pipeline = PipelineGraph.BuildRoot(plugins); pipeline.Transients.ShouldBeOfType <NulloTransientCache>(); }
public void transient_cache_of_nested_pipeline_graph_is_a_stateful_cache() { var plugins = new PluginGraph(); var pipeline = PipelineGraph.BuildRoot(plugins); pipeline.ToNestedGraph().Transients.ShouldBeOfType <LifecycleObjectCache>(); }
public void all_instances_when_the_family_already_exists() { var graph = new PluginGraph(); graph.Families.FillDefault(typeof(BigThingy)); graph.AllInstances(typeof(BigThingy)).Any().ShouldBeFalse(); }
public void SetUp() { graph = new PluginGraph(); pipeline = new PipelineGraph(graph); library = new InterceptorLibrary(); builder = new ObjectBuilder(pipeline, library); }
public void has_family_true_with_simple() { var graph = PluginGraph.Empty(); graph.AddFamily(new PluginFamily(typeof(IThingy))); graph.HasFamily(typeof(IThingy)).ShouldBeTrue(); }
public void all_instances_when_family_has_not_been_created() { var graph = new PluginGraph(); graph.AllInstances(typeof(BigThingy)).Any().ShouldBeFalse(); graph.Families.Has(typeof(BigThingy)).ShouldBeFalse(); }
public void AssertErrors_throws_StructureMapConfigurationException_if_there_is_an_error() { var graph = new PluginGraph(); graph.Log.RegisterError(400, new ApplicationException("Bad!")); graph.Log.AssertFailures(); }
private static ITransientTracking chooseTransientTracking(PluginGraph pluginGraph) { ITransientTracking transients = pluginGraph.TransientTracking == TransientTracking.DefaultNotTrackedAtRoot ? (ITransientTracking) new NulloTransientCache() : new TrackingTransientCache(); return(transients); }
public void CTOR_throws_StructureMapConfigurationException_if_there_is_an_error() { var graph = new PluginGraph(); graph.Log.RegisterError(400, new ApplicationException("Bad!")); new Container(graph); }
public void has_default_positive() { var graph = new PluginGraph(); graph.Families[typeof(IThingy)].SetDefault(new SmartInstance <BigThingy>()); graph.HasDefaultForPluginType(typeof(IThingy)); }
public void find_instance_negative_when_family_does_exist_but_instance_does_not() { var graph = new PluginGraph(); graph.Families[typeof(BigThingy)].AddInstance(new SmartInstance <BigThingy>().Named("red")); graph.FindInstance(typeof(BigThingy), "blue").ShouldBeNull(); }
public DoctorReport RunReport(string bootstrapperTypeName) { var report = new DoctorReport { Result = DoctorResult.Success }; IBootstrapper bootstrapper; try { var path = new TypePath(bootstrapperTypeName); Type bootstrapperType = path.FindType(); bootstrapper = (IBootstrapper)Activator.CreateInstance(bootstrapperType); } catch (Exception e) { report.Result = DoctorResult.BootstrapperCouldNotBeFound; report.ErrorMessages = e.ToString(); return(report); } try { bootstrapper.BootstrapStructureMap(); PluginGraph graph = ObjectFactory.PluginGraph; if (graph.Log.ErrorCount > 0) { report.ErrorMessages = graph.Log.BuildFailureMessage(); report.Result = DoctorResult.ConfigurationErrors; } else { writeConfigurationAndValidate(report, graph); } return(report); } catch (StructureMapConfigurationException ex) { report.ErrorMessages = ex.Message; report.Result = DoctorResult.ConfigurationErrors; return(report); } catch (Exception ex) { report.Result = DoctorResult.BootstrapperFailure; report.ErrorMessages = ex.ToString(); return(report); } }
public IPipelineGraph NewChild() { var childGraph = new PluginGraph(); var instances = new ComplexInstanceGraph(_root, childGraph, ContainerRole.ProfileOrChild); // RIGHT HERE, WE NEED TO USE A DIFFERENT SINGLETON CACHE return(new PipelineGraph(childGraph, instances, _root, _root.Singletons, _root.Transients)); }
/// <summary> /// Uses the configuration expressions of this Registry to create a PluginGraph /// object that could be used to initialize a Container. This method is /// mostly for internal usage, but might be helpful for diagnostics /// </summary> /// <returns></returns> public PluginGraph Build() { var graph = new PluginGraph(); ConfigurePluginGraph(graph); graph.Seal(); return(graph); }
public void get_the_first_constructor_marked_with_the_attribute_if_it_exists() { var selector = new ConstructorSelector(PluginGraph.CreateRoot()); var constructor = selector.Select(typeof(ComplexRule), new DependencyCollection()); constructor.GetParameters().Length .ShouldBe(7); }
public void all_instances_when_the_family_already_exists() { var graph = PluginGraph.CreateRoot(); // just forcing the family to be created graph.Families[typeof(BigThingy)].ShouldNotBeNull(); graph.AllInstances(typeof(BigThingy)).Any().ShouldBeFalse(); }
public static IPipelineGraph BuildRoot(PluginGraph pluginGraph) { ITransientTracking transients = pluginGraph.TransientTracking == TransientTracking.DefaultNotTrackedAtRoot ? (ITransientTracking) new NulloTransientCache() : new TrackingTransientCache(); return(new PipelineGraph(pluginGraph, new RootInstanceGraph(pluginGraph), null, pluginGraph.SingletonCache, transients)); }
public void find_instance_positive() { var graph = PluginGraph.CreateRoot(); var instance = new SmartInstance <BigThingy>().Named("red"); graph.Families[typeof(BigThingy)].AddInstance(instance); graph.FindInstance(typeof(BigThingy), "red").ShouldBeTheSameAs(instance); }
// ASP.NET expects registered services to be considered when selecting a ctor, SM doesn't by default. public ConstructorInfo Find(Type pluggedType, DependencyCollection dependencies, PluginGraph graph) => pluggedType.GetTypeInfo() .DeclaredConstructors .Where(ctor => ctor.IsConstructor && !ctor.IsPrivate) // IsConstructor is false for static constructors .Select(ctor => new { Constructor = ctor, Parameters = ctor.GetParameters() }) .Where(x => x.Parameters.All(param => graph.HasFamily(param.ParameterType) || dependencies.Any(dep => dep.Type == param.ParameterType))) .OrderByDescending(x => x.Parameters.Length) .Select(x => x.Constructor) .FirstOrDefault();
public void default_lifecycle_not_set_on_any_level() { var graph = PluginGraph.CreateRoot(); var pipeline = PipelineGraph.BuildRoot(graph).Profiles.For("Red"); pipeline.Instances.DefaultLifecycleFor(typeof(IGateway)) .ShouldBeNull(); }
public Profiles(PluginGraph pluginGraph, IPipelineGraph root) { _profiles = new Cache <string, IPipelineGraph>(name => { var profileGraph = pluginGraph.Profile(name); var instances = new ComplexInstanceGraph(root, profileGraph, ContainerRole.ProfileOrChild); return(new PipelineGraph(profileGraph, instances, root, root.Singletons, root.Transients)); }); }
public void value_is_instance_for_non_simple_resolves_to_lifecycle_source() { var instance = new FakeInstance(); instance.SetLifecycleTo(new SingletonLifecycle()); ConcreteType.SourceFor(new Policies(PluginGraph.CreateRoot()), ConcreteType.ConstructorArgument, "SomeProp", typeof(IGateway), instance) .ShouldBeTheSameAs(instance.DependencySource); }