public void ImportOnConstructorWithFunc() { var id = TypeIdentity.CreateDefinition(typeof(ImportOnConstructorWithFunc)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.AreEqual(1, plugin.Imports.Count()); var import = plugin.Imports.First() as ConstructorBasedImportDefinition; Assert.IsNotNull(import); Assert.AreEqual("ContractName", import.ContractName); Assert.AreEqual(id, import.DeclaringType); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(Func <IExportingInterface>)), import.RequiredTypeIdentity); Assert.AreEqual( ConstructorDefinition.CreateDefinition( typeof(ImportOnConstructorWithFunc).GetConstructor(new[] { typeof(Func <IExportingInterface>) })), import.Constructor); Assert.AreEqual( ParameterDefinition.CreateDefinition( typeof(ImportOnConstructorWithFunc).GetConstructor(new[] { typeof(Func <IExportingInterface>) }).GetParameters().First()), import.Parameter); }
private static SerializableImportDefinition CreatePropertyImport( ContractBasedImportDefinition import, Func <Type, TypeIdentity> identityGenerator) { var memberInfo = ReflectionModelServices.GetImportingMember(import); if (memberInfo.MemberType != MemberTypes.Property) { throw new ArgumentOutOfRangeException("import"); } // this is really ugly because we assume that the underlying methods for a property are named as: // get_PROPERTYNAME and set_PROPERTYNAME. In this case we assume that imports always // have a set method. var getMember = memberInfo.GetAccessors().First(m => m.Name.Contains("set_")); var name = getMember.Name.Substring("set_".Length); var property = getMember.DeclaringType.GetProperty(name); var requiredType = ExtractRequiredType(property.GetCustomAttributes(), property.PropertyType); if (requiredType == null) { return(null); } return(PropertyBasedImportDefinition.CreateDefinition( import.ContractName, TypeIdentity.CreateDefinition(requiredType), import.Cardinality, import.IsRecomposable, import.RequiredCreationPolicy, property, identityGenerator)); }
public void ConnectWithNonmatchingExport() { var plugins = CreatePluginTypes(); var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); } var importEngine = new Mock <IConnectParts>(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var firstInfo = builder.RegisterObject(typeof(ImportOnProperty)); var secondInfo = builder.RegisterObject(typeof(ActionOnMethod)); Assert.Throws <CannotMapExportToImportException>( () => builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First())); }
public void RegisterObject() { var plugins = CreatePluginTypes(); var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); } var importEngine = new Mock <IConnectParts>(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var info = builder.RegisterObject(typeof(ActionOnMethod)); Assert.IsFalse(info.RegisteredConditions.Any()); Assert.IsFalse(info.RegisteredImports.Any()); Assert.AreEqual(1, info.RegisteredExports.Count()); Assert.AreEqual("ActionExport", info.RegisteredExports.First().ContractName); Assert.AreEqual(1, info.RegisteredActions.Count()); }
public void ImportOnPropertyWithFunc() { var id = TypeIdentity.CreateDefinition(typeof(ImportOnPropertyWithFunc)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.AreEqual(1, plugin.Imports.Count()); var import = plugin.Imports.First() as PropertyBasedImportDefinition; Assert.IsNotNull(import); Assert.AreEqual("ContractName", import.ContractName); Assert.AreEqual(id, import.DeclaringType); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(Func <IExportingInterface>)), import.RequiredTypeIdentity); Assert.AreEqual( PropertyDefinition.CreateDefinition( typeof(ImportOnPropertyWithFunc).GetProperty("ImportingProperty")), import.Property); }
public void ExportOnMethod() { var id = TypeIdentity.CreateDefinition(typeof(ExportOnMethod)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.IsFalse(plugin.Imports.Any()); Assert.AreEqual(1, plugin.Exports.Count()); var export = plugin.Exports.First() as MethodBasedExportDefinition; Assert.IsNotNull(export); // for some unknown reason MEF adds () to the exported type on a method. No clue why what so ever....!!! Assert.AreEqual(typeof(IExportingInterface).FullName + "()", export.ContractName); Assert.AreEqual(id, export.DeclaringType); Assert.AreEqual( MethodDefinition.CreateDefinition( typeof(ExportOnMethod).GetMethod("ExportingMethod")), export.Method); }
public void ExportOnMethodWithType() { var id = TypeIdentity.CreateDefinition(typeof(ExportOnMethodWithType)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.IsFalse(plugin.Imports.Any()); Assert.AreEqual(1, plugin.Exports.Count()); var export = plugin.Exports.First() as MethodBasedExportDefinition; Assert.IsNotNull(export); Assert.AreEqual(typeof(IExportingInterface).FullName, export.ContractName); Assert.AreEqual(id, export.DeclaringType); Assert.AreEqual( MethodDefinition.CreateDefinition( typeof(ExportOnMethodWithType).GetMethod("ExportingMethod")), export.Method); }
public void ExportOnPropertyWithName() { var id = TypeIdentity.CreateDefinition(typeof(ExportOnPropertyWithName)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.IsFalse(plugin.Imports.Any()); Assert.AreEqual(1, plugin.Exports.Count()); var export = plugin.Exports.First() as PropertyBasedExportDefinition; Assert.IsNotNull(export); Assert.AreEqual("OnPropertyWithName", export.ContractName); Assert.AreEqual(id, export.DeclaringType); Assert.AreEqual( PropertyDefinition.CreateDefinition( typeof(ExportOnPropertyWithName).GetProperty("ExportingProperty")), export.Property); }
private static GroupDefinition CreateExportingGroup() { return(new GroupDefinition("a") { InternalConnections = Enumerable.Empty <PartImportToPartExportMap>(), Parts = new List <GroupPartDefinition> { new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(int)), 0, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(int), 0, "PartContract1"), TypeBasedExportDefinition.CreateDefinition("PartContract1", typeof(int)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(string)), 1, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(string), 1, "PartContract2"), TypeBasedExportDefinition.CreateDefinition("PartContract2", typeof(string)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(Version)), 2, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(string), 2, "PartContract2"), TypeBasedExportDefinition.CreateDefinition("PartContract2", typeof(string)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), }, GroupExport = GroupExportDefinition.CreateDefinition( "ContractName", new GroupRegistrationId("a"), new List <ExportRegistrationId> { new ExportRegistrationId(typeof(int), 0, "PartContract1"), new ExportRegistrationId(typeof(string), 1, "PartContract2"), new ExportRegistrationId(typeof(string), 2, "PartContract2"), }), }); }
public void DefineImportWithObjectImports() { var plugins = CreatePluginTypes(); GroupDefinition groupInfo = null; var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>())) .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g); } var importEngine = new Mock <IConnectParts>(); { importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>())) .Returns(true); } Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var firstInfo = builder.RegisterObject(typeof(ImportOnProperty)); var groupImportName = "groupImport"; builder.DefineImport(groupImportName, new List <ImportRegistrationId> { firstInfo.RegisteredImports.First() }); var groupName = "MyGroup"; builder.Register(groupName); Assert.IsNotNull(groupInfo); Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupImports.First().ContainingGroup); Assert.IsNull(groupInfo.GroupImports.First().ScheduleInsertPosition); Assert.That( groupInfo.GroupImports.First().ImportsToMatch, Is.EquivalentTo( new List <ImportRegistrationId> { firstInfo.RegisteredImports.First(), })); }
public void AddTypeWithStandaloneGenericInterfaceType() { var repository = new PluginRepository(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); var definition = TypeDefinition.CreateDefinition(typeof(IComparer <>), identityGenerator); repository.AddType(definition); Assert.IsTrue(repository.ContainsDefinitionForType(typeof(IComparer <>).AssemblyQualifiedName)); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(IComparer <>)))); Assert.AreSame(definition, repository.TypeByName(typeof(IComparer <>).AssemblyQualifiedName)); Assert.AreSame(definition, repository.TypeByIdentity(TypeIdentity.CreateDefinition(typeof(IComparer <>)))); }
/// <summary> /// Returns a function that creates <see cref="TypeIdentity"/> objects and stores the type reference in a <see cref="IPluginRepository"/>. /// </summary> /// <param name="typeStorage">The object that stores the type definitions.</param> /// <param name="currentlyBuilding"> /// The dictionary that keeps track of the types that are currently being constructed. This is necessary because of self-referencing generics, /// e.g. System.Boolean : IComparable{System.Boolean} etc. /// </param> /// <returns>The function that creates type identity objects.</returns> public static Func <Type, TypeIdentity> IdentityFactory(IPluginRepository typeStorage, IDictionary <Type, TypeIdentity> currentlyBuilding) { // Fake out the compiler because we need the function inside the function itself Func <Type, TypeIdentity> createTypeIdentity = null; createTypeIdentity = t => { // First make sure we're not already creating a definition for this type. If so then we just // return the identity because at some point we'll get the definition being added. // This is necessary because if we don't check this there is a good possibility that // we end-up in an infinite loop. e.g. trying to handle // System.Boolean means we have to process System.IComparable<System.Boolean> which means .... if (currentlyBuilding.ContainsKey(t)) { return(currentlyBuilding[t]); } // Create the type full name ourselves because generic type parameters don't have one (see // http://blogs.msdn.com/b/haibo_luo/archive/2006/02/17/534480.aspx). var name = t.AssemblyQualifiedName ?? string.Format(CultureInfo.InvariantCulture, "{0}.{1}, {2}", t.Namespace, t.Name, t.Assembly.FullName); if (!typeStorage.ContainsDefinitionForType(name)) { try { // Create a local version of the TypeIdentity and store that so that we can use that if we // come across this type before we're completely finished storing the definition of it var typeIdentity = TypeIdentity.CreateDefinition(t); currentlyBuilding.Add(t, typeIdentity); var typeDefinition = TypeDefinition.CreateDefinition(t, createTypeIdentity); typeStorage.AddType(typeDefinition); } finally { // Once we add the real definition then we can just remove the local copy // from the stack. currentlyBuilding.Remove(t); } } return(typeStorage.IdentityByName(name)); }; return(createTypeIdentity); }
public void RegisterObjectWithUnknownType() { var repository = new Mock <IPluginRepository>(); var importEngine = new Mock <IConnectParts>(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); Assert.Throws <UnknownPluginTypeException>(() => builder.RegisterObject(typeof(ExportOnPropertyWithName))); }
public void DefineSchedule() { var plugins = CreatePluginTypes(); GroupDefinition groupInfo = null; var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>())) .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g); } var importEngine = new Mock <IConnectParts>(); { importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>())) .Returns(true); } Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var actionInfo = builder.RegisterObject(typeof(ActionOnMethod)); var conditionInfo = builder.RegisterObject(typeof(ConditionOnProperty)); var registrator = builder.RegisterSchedule(); { var vertex = registrator.AddExecutingAction(actionInfo.RegisteredActions.First()); registrator.LinkFromStart(vertex, conditionInfo.RegisteredConditions.First()); registrator.LinkToEnd(vertex); registrator.Register(); } var groupName = "MyGroup"; builder.Register(groupName); Assert.AreEqual(actionInfo.RegisteredActions.First(), groupInfo.Schedule.Actions.First().Value); Assert.AreEqual(conditionInfo.RegisteredConditions.First(), groupInfo.Schedule.Conditions.First().Value); Assert.AreEqual(3, groupInfo.Schedule.Schedule.Vertices.Count()); }
public void ConnectOverridingCurrentConnection() { var plugins = CreatePluginTypes(); GroupDefinition groupInfo = null; var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>())) .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g); } var importEngine = new Mock <IConnectParts>(); { importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>())) .Returns(true); } Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var firstInfo = builder.RegisterObject(typeof(ImportOnProperty)); var secondInfo = builder.RegisterObject(typeof(ExportOnProperty)); builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First()); var thirdInfo = builder.RegisterObject(typeof(ExportOnProperty)); builder.Connect(firstInfo.RegisteredImports.First(), thirdInfo.RegisteredExports.First()); var groupName = "MyGroup"; builder.Register(groupName); Assert.IsNotNull(groupInfo); Assert.AreEqual(firstInfo.RegisteredImports.First(), groupInfo.InternalConnections.First().Import); Assert.AreEqual(1, groupInfo.InternalConnections.First().Exports.Count()); Assert.AreEqual(thirdInfo.RegisteredExports.First(), groupInfo.InternalConnections.First().Exports.First()); }
private static Func <Type, TypeIdentity> IdentityFactory(List <TypeDefinition> typeStorage, IDictionary <Type, TypeIdentity> currentlyBuilding) { // Fake out the compiler because we need the function inside the function itself Func <Type, TypeIdentity> createTypeIdentity = null; createTypeIdentity = t => { // First make sure we're not already creating a definition for this type. If so then we just // return the identity because at some point we'll get the definition being added. // This is necessary because if we don't check this there is a good possibility that // we end-up in an infinite loop. e.g. trying to handle // System.Boolean means we have to process System.IComparable<System.Boolean> which means .... if (currentlyBuilding.ContainsKey(t)) { return(currentlyBuilding[t]); } if (typeStorage.Find(typeDef => typeDef.Identity.Equals(t)) == null) { try { // Create a local version of the TypeIdentity and store that var typeIdentity = TypeIdentity.CreateDefinition(t); currentlyBuilding.Add(t, typeIdentity); var typeDefinition = TypeDefinition.CreateDefinition(t, createTypeIdentity); typeStorage.Add(typeDefinition); } finally { // Once we add the real definition then we can just remove the local copy // from the stack. currentlyBuilding.Remove(t); } } return(typeStorage.Find(typeDef => typeDef.Identity.Equals(t)).Identity); }; return(createTypeIdentity); }
private static SerializableImportDefinition CreateConstructorParameterImport( ContractBasedImportDefinition import, Func <Type, TypeIdentity> identityGenerator) { var parameterInfo = ReflectionModelServices.GetImportingParameter(import); var requiredType = ExtractRequiredType(parameterInfo.Value.GetCustomAttributes(), parameterInfo.Value.ParameterType); if (requiredType == null) { return(null); } return(ConstructorBasedImportDefinition.CreateDefinition( import.ContractName, TypeIdentity.CreateDefinition(requiredType), import.Cardinality, import.RequiredCreationPolicy, parameterInfo.Value, identityGenerator)); }
public void AddTypeWithParentTypeFirst() { var repository = new PluginRepository(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); var objectDefinition = TypeDefinition.CreateDefinition(typeof(object), identityGenerator); repository.AddType(objectDefinition); Assert.IsTrue(repository.ContainsDefinitionForType(typeof(object).AssemblyQualifiedName)); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(object)))); var stringDefinition = TypeDefinition.CreateDefinition(typeof(string), identityGenerator); repository.AddType(stringDefinition); Assert.IsTrue(repository.ContainsDefinitionForType(typeof(string).AssemblyQualifiedName)); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(string)))); Assert.IsTrue(repository.IsSubTypeOf(TypeIdentity.CreateDefinition(typeof(object)), TypeIdentity.CreateDefinition(typeof(string)))); }
public void RemovePluginsWithParentType() { var currentlyBuilding = new Dictionary <Type, TypeIdentity>(); var repository = new PluginRepository(); Func <Type, TypeIdentity> identityGenerator = TypeIdentityBuilder.IdentityFactory(repository, currentlyBuilding); PartDefinition parentDefinition = new PartDefinition { Identity = identityGenerator(typeof(MockExportingInterfaceImplementation)), }; var parentFileInfo = new PluginFileInfo("a", DateTimeOffset.Now); repository.AddPart(parentDefinition, parentFileInfo); PartDefinition childDefinition = new PartDefinition { Identity = identityGenerator(typeof(MockChildExportingInterfaceImplementation)), }; var childFileInfo = new PluginFileInfo("b", DateTimeOffset.Now); repository.AddPart(childDefinition, childFileInfo); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(MockExportingInterfaceImplementation)))); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(MockChildExportingInterfaceImplementation)))); Assert.IsTrue( repository.IsSubTypeOf( TypeIdentity.CreateDefinition(typeof(object)), TypeIdentity.CreateDefinition(typeof(MockChildExportingInterfaceImplementation)))); repository.RemovePlugins(new string[] { parentFileInfo.Path }); Assert.IsFalse(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(MockExportingInterfaceImplementation)))); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(MockChildExportingInterfaceImplementation)))); Assert.IsFalse( repository.IsSubTypeOf( TypeIdentity.CreateDefinition(typeof(object)), TypeIdentity.CreateDefinition(typeof(MockChildExportingInterfaceImplementation)))); }
public void ConditionOnProperty() { var id = TypeIdentity.CreateDefinition(typeof(ConditionOnProperty)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.AreEqual(1, plugin.Conditions.Count()); var condition = plugin.Conditions.First() as PropertyBasedScheduleConditionDefinition; Assert.IsNotNull(condition); Assert.AreEqual("OnProperty", condition.ContractName); Assert.AreEqual( PropertyDefinition.CreateDefinition( typeof(ConditionOnProperty).GetProperty("ConditionProperty")), condition.Property); }
public void ActionOnMethod() { var id = TypeIdentity.CreateDefinition(typeof(ActionOnMethod)); Assert.IsTrue(s_Types.Exists(s => s.Identity.Equals(id))); var plugins = s_Parts.Where(p => p.Identity.Equals(id)); Assert.IsTrue(plugins.Count() == 1); var plugin = plugins.First(); Assert.IsFalse(plugin.Imports.Any()); Assert.AreEqual(1, plugin.Actions.Count()); var action = plugin.Actions.First(); Assert.IsNotNull(action); Assert.AreEqual("ActionMethod", action.ContractName); Assert.AreEqual( MethodDefinition.CreateDefinition( typeof(ActionOnMethod).GetMethod("ActionMethod")), action.Method); }
public void AddTypeWithGenericParentLast() { var repository = new PluginRepository(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); var listDefinition = TypeDefinition.CreateDefinition(typeof(List <>), identityGenerator); repository.AddType(listDefinition); Assert.IsTrue(repository.ContainsDefinitionForType(typeof(List <>).AssemblyQualifiedName)); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(List <>)))); var enumerableDefinition = TypeDefinition.CreateDefinition(typeof(IEnumerable <>), identityGenerator); repository.AddType(enumerableDefinition); Assert.IsTrue(repository.ContainsDefinitionForType(typeof(IEnumerable <>).AssemblyQualifiedName)); Assert.IsTrue(repository.ContainsDefinitionForType(TypeIdentity.CreateDefinition(typeof(IEnumerable <>)))); Assert.IsTrue( repository.IsSubTypeOf( TypeIdentity.CreateDefinition(typeof(IEnumerable <>)), TypeIdentity.CreateDefinition(typeof(List <>)))); }
public void RegisterObjectWithMultipleSameType() { var plugins = CreatePluginTypes(); var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); } var importEngine = new Mock <IConnectParts>(); Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var firstInfo = builder.RegisterObject(typeof(ActionOnMethod)); var secondInfo = builder.RegisterObject(typeof(ActionOnMethod)); Assert.AreNotEqual(firstInfo.Id, secondInfo.Id); }
public void Connect() { int index = -1; var instanceIds = new List <PartInstanceId> { new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), }; var storage = new Mock <IStoreInstances>(); { storage.Setup( s => s.Construct( It.IsAny <GroupPartDefinition>(), It.IsAny <IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >())) .Callback <GroupPartDefinition, IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >( (d, i) => { if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(List <string>)))) { Assert.AreEqual(0, i.Count()); } if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(List <double>)))) { Assert.AreEqual(2, i.Count()); Assert.AreEqual(instanceIds[1], i.ElementAt(0).Item2); Assert.AreEqual(instanceIds[2], i.ElementAt(1).Item2); } }) .Returns <GroupPartDefinition, IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >( (d, i) => { index++; return(instanceIds[index]); }) .Verifiable(); storage.Setup( s => s.UpdateIfRequired( It.IsAny <PartInstanceId>(), It.IsAny <IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >())) .Callback <PartInstanceId, IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >( (i, l) => { if (i.Equals(instanceIds[5])) { Assert.AreEqual(1, l.Count()); Assert.AreEqual(instanceIds[0], l.ElementAt(0).Item2); } }) .Returns <PartInstanceId, IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >( (i, l) => { return(new List <InstanceUpdate> { new InstanceUpdate { Instance = i, Change = InstanceChange.Updated, } }); }) .Verifiable(); } var layer = CompositionLayer.CreateInstanceWithoutTimeline(storage.Object); var firstId = new GroupCompositionId(); var firstDefinition = CreateExportingDefinition(); layer.Add(firstId, firstDefinition); var secondId = new GroupCompositionId(); var secondDefinition = CreateImportingDefinition(); layer.Add(secondId, secondDefinition); Assert.IsFalse(layer.SatisfiedImports(secondId).Any()); Assert.That(layer.UnsatisfiedImports(secondId), Is.EquivalentTo(secondDefinition.GroupImports)); layer.Connect(new GroupConnection( secondId, firstId, secondDefinition.GroupImports.First(), new List <PartImportToPartExportMap> { new PartImportToPartExportMap( secondDefinition.GroupImports.First().ImportsToMatch.ElementAt(0), new List <ExportRegistrationId> { firstDefinition.GroupExport.ProvidedExports.ElementAt(0) }), new PartImportToPartExportMap( secondDefinition.GroupImports.First().ImportsToMatch.ElementAt(1), new List <ExportRegistrationId> { firstDefinition.GroupExport.ProvidedExports.ElementAt(1), firstDefinition.GroupExport.ProvidedExports.ElementAt(2), }), })); Assert.IsFalse(layer.UnsatisfiedImports(secondId).Any()); Assert.That( layer.SatisfiedImports(secondId), Is.EquivalentTo( new List <Tuple <GroupImportDefinition, GroupCompositionId> > { new Tuple <GroupImportDefinition, GroupCompositionId>(secondDefinition.GroupImports.First(), firstId) })); storage.Verify( s => s.Construct( It.IsAny <GroupPartDefinition>(), It.IsAny <IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >()), Times.Exactly(7)); }
public void AddMultipleInstanceWithSameDefinition() { var firstDefinition = CreateExportingDefinition(); int index = -1; var instanceIds = new List <PartInstanceId> { new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), new PartInstanceId(), }; var storage = new Mock <IStoreInstances>(); { storage.Setup( s => s.Construct( It.IsAny <GroupPartDefinition>(), It.IsAny <IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >())) .Callback <GroupPartDefinition, IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >( (d, i) => { if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(int)))) { Assert.IsFalse(i.Any()); return; } if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(string)))) { Assert.IsFalse(i.Any()); return; } if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(Version)))) { Assert.IsFalse(i.Any()); return; } if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(DateTime)))) { Assert.IsFalse(i.Any()); return; } if (d.Identity.Equals(TypeIdentity.CreateDefinition(typeof(List <int>)))) { Assert.AreEqual(1, i.Count()); Assert.AreEqual(instanceIds[index], i.First().Item2); return; } Assert.Fail(); }) .Returns <GroupPartDefinition, IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >( (d, i) => { index++; return(instanceIds[index]); }) .Verifiable(); } var layer = CompositionLayer.CreateInstanceWithoutTimeline(storage.Object); var firstId = new GroupCompositionId(); layer.Add(firstId, firstDefinition); var secondId = new GroupCompositionId(); var secondDefinition = CreateExportingDefinition(); layer.Add(secondId, secondDefinition); Assert.AreEqual(2, layer.Groups().Count()); Assert.AreSame(firstDefinition, layer.Group(firstId)); Assert.AreSame(firstDefinition, layer.Group(secondId)); storage.Verify( s => s.Construct( It.IsAny <GroupPartDefinition>(), It.IsAny <IEnumerable <Tuple <ImportRegistrationId, PartInstanceId, ExportRegistrationId> > >()), Times.Exactly(10)); }
private static GroupDefinition CreateExportingDefinition() { var groupName = "Export"; return(new GroupDefinition(groupName) { Parts = new List <GroupPartDefinition> { new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(int)), 0, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(int), 0, "PartContract1"), TypeBasedExportDefinition.CreateDefinition("PartContract1", typeof(int)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(string)), 1, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(string), 1, "PartContract2"), TypeBasedExportDefinition.CreateDefinition("PartContract2", typeof(string)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(Version)), 2, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(string), 2, "PartContract2"), TypeBasedExportDefinition.CreateDefinition("PartContract2", typeof(string)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(DateTime)), 2, new Dictionary <ExportRegistrationId, SerializableExportDefinition> { { new ExportRegistrationId(typeof(string), 3, "PartContract3"), TypeBasedExportDefinition.CreateDefinition("PartContract3", typeof(string)) } }, new Dictionary <ImportRegistrationId, SerializableImportDefinition>(), new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(List <int>)), 2, new Dictionary <ExportRegistrationId, SerializableExportDefinition>(), new Dictionary <ImportRegistrationId, SerializableImportDefinition> { { new ImportRegistrationId(typeof(string), 1, "PartContract3"), PropertyBasedImportDefinition.CreateDefinition( "PartContract3", TypeIdentity.CreateDefinition(typeof(string)), ImportCardinality.ExactlyOne, false, CreationPolicy.Any, typeof(ImportOnPropertyWithEnumerable).GetProperty("ImportingProperty")) } }, new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), }, InternalConnections = new List <PartImportToPartExportMap> { new PartImportToPartExportMap( new ImportRegistrationId(typeof(string), 1, "PartContract3"), new List <ExportRegistrationId> { new ExportRegistrationId(typeof(string), 3, "PartContract3") }), }, GroupExport = GroupExportDefinition.CreateDefinition( "ContractName", new GroupRegistrationId(groupName), new List <ExportRegistrationId> { new ExportRegistrationId(typeof(int), 0, "PartContract1"), new ExportRegistrationId(typeof(string), 1, "PartContract2"), new ExportRegistrationId(typeof(string), 2, "PartContract2"), }), }); }
private static GroupDefinition CreateImportingDefinition() { var groupName = "Import"; return(new GroupDefinition(groupName) { InternalConnections = Enumerable.Empty <PartImportToPartExportMap>(), Parts = new List <GroupPartDefinition> { new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(List <string>)), 0, new Dictionary <ExportRegistrationId, SerializableExportDefinition>(), new Dictionary <ImportRegistrationId, SerializableImportDefinition> { { new ImportRegistrationId(typeof(string), 0, "PartContract1"), PropertyBasedImportDefinition.CreateDefinition( "PartContract1", TypeIdentity.CreateDefinition(typeof(int)), ImportCardinality.ExactlyOne, false, CreationPolicy.Any, typeof(ImportOnPropertyWithType).GetProperty("ImportingProperty")) } }, new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), new GroupPartDefinition( TypeIdentity.CreateDefinition(typeof(List <double>)), 1, new Dictionary <ExportRegistrationId, SerializableExportDefinition>(), new Dictionary <ImportRegistrationId, SerializableImportDefinition> { { new ImportRegistrationId(typeof(string), 1, "PartContract2"), ConstructorBasedImportDefinition.CreateDefinition( "PartContract2", TypeIdentity.CreateDefinition(typeof(string)), ImportCardinality.ExactlyOne, CreationPolicy.Any, typeof(Version).GetConstructor( new[] { typeof(string) }).GetParameters().First()) } }, new Dictionary <ScheduleActionRegistrationId, ScheduleActionDefinition>(), new Dictionary <ScheduleConditionRegistrationId, ScheduleConditionDefinition>()), }, GroupImports = new List <GroupImportDefinition> { GroupImportDefinition.CreateDefinition( "ContractName", new GroupRegistrationId(groupName), null, new List <ImportRegistrationId> { new ImportRegistrationId(typeof(string), 0, "PartContract1"), new ImportRegistrationId(typeof(string), 1, "PartContract2"), }) }, }); }
private static IEnumerable <PartDefinition> CreatePluginTypes() { var plugins = new List <PartDefinition> { new PartDefinition { Identity = TypeIdentity.CreateDefinition(typeof(ActionOnMethod)), Exports = new List <SerializableExportDefinition> { TypeBasedExportDefinition.CreateDefinition("ActionExport", typeof(ActionOnMethod)) }, Imports = new List <SerializableImportDefinition>(), Actions = new List <ScheduleActionDefinition> { ScheduleActionDefinition.CreateDefinition( "ActionMethod", typeof(ActionOnMethod).GetMethod("ActionMethod")) }, Conditions = new List <ScheduleConditionDefinition>(), }, new PartDefinition { Identity = TypeIdentity.CreateDefinition(typeof(ConditionOnMethod)), Exports = new List <SerializableExportDefinition> { TypeBasedExportDefinition.CreateDefinition("ConditionOnMethodExport", typeof(ConditionOnMethod)) }, Imports = new List <SerializableImportDefinition>(), Actions = new List <ScheduleActionDefinition>(), Conditions = new List <ScheduleConditionDefinition> { MethodBasedScheduleConditionDefinition.CreateDefinition( "OnMethod", typeof(ConditionOnMethod).GetMethod("ConditionMethod")) }, }, new PartDefinition { Identity = TypeIdentity.CreateDefinition(typeof(ConditionOnProperty)), Exports = new List <SerializableExportDefinition> { TypeBasedExportDefinition.CreateDefinition("ConditionOnPropertyExport", typeof(ConditionOnProperty)) }, Imports = new List <SerializableImportDefinition>(), Actions = new List <ScheduleActionDefinition>(), Conditions = new List <ScheduleConditionDefinition> { PropertyBasedScheduleConditionDefinition.CreateDefinition( "OnProperty", typeof(ConditionOnProperty).GetProperty("ConditionProperty")) }, }, new PartDefinition { Identity = TypeIdentity.CreateDefinition(typeof(ExportOnProperty)), Exports = new List <SerializableExportDefinition> { PropertyBasedExportDefinition.CreateDefinition( typeof(IExportingInterface).FullName, typeof(ExportOnProperty).GetProperty("ExportingProperty")) }, Imports = new List <SerializableImportDefinition>(), Actions = new List <ScheduleActionDefinition>(), Conditions = new List <ScheduleConditionDefinition>(), }, new PartDefinition { Identity = TypeIdentity.CreateDefinition(typeof(ImportOnProperty)), Exports = new List <SerializableExportDefinition> { TypeBasedExportDefinition.CreateDefinition(typeof(ImportOnProperty).FullName, typeof(ImportOnProperty)) }, Imports = new List <SerializableImportDefinition> { PropertyBasedImportDefinition.CreateDefinition( typeof(IExportingInterface).FullName, TypeIdentity.CreateDefinition(typeof(IExportingInterface)), ImportCardinality.ExactlyOne, false, CreationPolicy.Shared, typeof(ImportOnProperty).GetProperty("ImportingProperty")) }, Actions = new List <ScheduleActionDefinition>(), Conditions = new List <ScheduleConditionDefinition>(), } }; return(plugins); }
public void DefineExport() { var plugins = CreatePluginTypes(); GroupDefinition groupInfo = null; var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>())) .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g); } var importEngine = new Mock <IConnectParts>(); { importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>())) .Returns(true); } Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var firstInfo = builder.RegisterObject(typeof(ImportOnProperty)); var secondInfo = builder.RegisterObject(typeof(ExportOnProperty)); var thirdInfo = builder.RegisterObject(typeof(ActionOnMethod)); var fourthInfo = builder.RegisterObject(typeof(ConditionOnProperty)); builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First()); var registrator = builder.RegisterSchedule(); { var vertex = registrator.AddExecutingAction(thirdInfo.RegisteredActions.First()); registrator.LinkFromStart(vertex, fourthInfo.RegisteredConditions.First()); registrator.LinkToEnd(vertex); registrator.Register(); } var groupExportName = "groupExport"; builder.DefineExport(groupExportName); var groupName = "MyGroup"; builder.Register(groupName); Assert.IsNotNull(groupInfo); Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupExport.ContainingGroup); Assert.AreEqual(groupExportName, groupInfo.GroupExport.ContractName); Assert.That( groupInfo.GroupExport.ProvidedExports, Is.EquivalentTo( new List <ExportRegistrationId> { firstInfo.RegisteredExports.First(), thirdInfo.RegisteredExports.First(), fourthInfo.RegisteredExports.First(), })); }