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(),
}));
}