public void MatchingGroupsWithGroupImport()
{
var repository = new Mock <IPluginRepository>();
{
repository.Setup(r => r.Parts())
.Returns(s_Parts);
repository.Setup(r => r.Part(It.IsAny <TypeIdentity>()))
.Returns <TypeIdentity>(t => s_Parts.FirstOrDefault(p => p.Identity.Equals(t)));
repository.Setup(r => r.Groups())
.Returns(s_Groups);
repository.Setup(r => r.Group(It.IsAny <GroupRegistrationId>()))
.Returns <GroupRegistrationId>(id => s_Groups.FirstOrDefault(g => g.Id.Equals(id)));
}
var partImportEngine = new Mock <IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
.Returns(true);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
var groups = importEngine.MatchingGroups(s_Groups[0].GroupImports.First());
Assert.AreEqual(2, groups.Count());
Assert.AreEqual(s_Groups[1].Id, groups.First().Id);
Assert.AreEqual(s_Groups[2].Id, groups.Last().Id);
}
public void ExportMatchesSelectionCriteriaWithMatch()
{
var repository = new Mock <IPluginRepository>();
{
repository.Setup(r => r.Parts())
.Returns(s_Parts);
repository.Setup(r => r.Part(It.IsAny <TypeIdentity>()))
.Returns <TypeIdentity>(t => s_Parts.FirstOrDefault(p => p.Identity.Equals(t)));
repository.Setup(r => r.Groups())
.Returns(s_Groups);
repository.Setup(r => r.Group(It.IsAny <GroupRegistrationId>()))
.Returns <GroupRegistrationId>(id => s_Groups.FirstOrDefault(g => g.Id.Equals(id)));
}
var partImportEngine = new Mock <IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
.Returns(true);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
Assert.IsTrue(
importEngine.ExportPassesSelectionCriteria(
s_Groups.First().GroupExport,
new Dictionary <string, object>()));
}
public void GenerateConnectionForWithSingleConnection()
{
var repository = new Mock <IPluginRepository>();
var partImportEngine = new Mock <IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
.Returns <SerializableImportDefinition, SerializableExportDefinition>(
(import, export) => import.ContractName == export.ContractName);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
var connections = importEngine.GenerateConnectionFor(s_Groups[0], s_Groups[0].GroupImports.First(), s_Groups[2]);
Assert.AreEqual(1, connections.Count());
var connection = connections.First();
Assert.AreEqual(s_Groups[0].GroupImports.First().ImportsToMatch.First(), connection.Import);
Assert.AreEqual(1, connection.Exports.Count());
Assert.AreEqual(s_Groups[2].GroupExport.ProvidedExports.First(), connection.Exports.First());
}
public void Accepts()
{
var repository = new Mock<IPluginRepository>();
{
repository.Setup(r => r.Parts())
.Returns(s_Parts);
repository.Setup(r => r.Part(It.IsAny<TypeIdentity>()))
.Returns<TypeIdentity>(t => s_Parts.FirstOrDefault(p => p.Identity.Equals(t)));
repository.Setup(r => r.Groups())
.Returns(s_Groups);
repository.Setup(r => r.Group(It.IsAny<GroupRegistrationId>()))
.Returns<GroupRegistrationId>(id => s_Groups.FirstOrDefault(g => g.Id.Equals(id)));
}
var partImportEngine = new Mock<IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
.Returns(true);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
Assert.IsTrue(importEngine.Accepts(s_Groups[0].GroupImports.First(), s_Groups[2].GroupExport));
}
public void GenerateConnectionForWithMultipleConnections()
{
var group1 = CreateExportingGroup();
var group2 = CreateImportingGroup();
var repository = new Mock <IPluginRepository>();
var partImportEngine = new Mock <IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
.Returns <SerializableImportDefinition, SerializableExportDefinition>(
(import, export) => import.ContractName == export.ContractName);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
var connections = importEngine.GenerateConnectionFor(group2, group2.GroupImports.First(), group1);
Assert.AreEqual(2, connections.Count());
var connection = connections.ElementAt(0);
Assert.AreEqual(group2.GroupImports.First().ImportsToMatch.ElementAt(0), connection.Import);
Assert.AreEqual(1, connection.Exports.Count());
Assert.AreEqual(group1.GroupExport.ProvidedExports.ElementAt(0), connection.Exports.ElementAt(0));
connection = connections.ElementAt(1);
Assert.AreEqual(group2.GroupImports.First().ImportsToMatch.ElementAt(1), connection.Import);
Assert.AreEqual(2, connection.Exports.Count());
Assert.That(
connection.Exports,
Is.EquivalentTo(
new List <ExportRegistrationId>
{
group1.GroupExport.ProvidedExports.ElementAt(1),
group1.GroupExport.ProvidedExports.ElementAt(2),
}));
}
public void AcceptsWithUnmatchedPartImport()
{
var repository = new Mock <IPluginRepository>();
{
repository.Setup(r => r.Parts())
.Returns(s_Parts);
repository.Setup(r => r.Part(It.IsAny <TypeIdentity>()))
.Returns <TypeIdentity>(t => s_Parts.FirstOrDefault(p => p.Identity.Equals(t)));
repository.Setup(r => r.Groups())
.Returns(s_Groups);
repository.Setup(r => r.Group(It.IsAny <GroupRegistrationId>()))
.Returns <GroupRegistrationId>(id => s_Groups.FirstOrDefault(g => g.Id.Equals(id)));
}
var partImportEngine = new Mock <IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
.Returns(false);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
Assert.IsFalse(importEngine.Accepts(s_Groups[0].GroupImports.First(), s_Groups[1].GroupExport));
}
public void MatchingGroupsWithSelectionCriteria()
{
var repository = new Mock<IPluginRepository>();
{
repository.Setup(r => r.Parts())
.Returns(s_Parts);
repository.Setup(r => r.Part(It.IsAny<TypeIdentity>()))
.Returns<TypeIdentity>(t => s_Parts.FirstOrDefault(p => p.Identity.Equals(t)));
repository.Setup(r => r.Groups())
.Returns(s_Groups);
repository.Setup(r => r.Group(It.IsAny<GroupRegistrationId>()))
.Returns<GroupRegistrationId>(id => s_Groups.FirstOrDefault(g => g.Id.Equals(id)));
}
var partImportEngine = new Mock<IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
.Returns(true);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
var groups = importEngine.MatchingGroups(new Dictionary<string, object>());
Assert.AreEqual(3, groups.Count());
}
public void GenerateConnectionForWithSingleConnection()
{
var repository = new Mock<IPluginRepository>();
var partImportEngine = new Mock<IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
.Returns<SerializableImportDefinition, SerializableExportDefinition>(
(import, export) => import.ContractName == export.ContractName);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
var connections = importEngine.GenerateConnectionFor(s_Groups[0], s_Groups[0].GroupImports.First(), s_Groups[2]);
Assert.AreEqual(1, connections.Count());
var connection = connections.First();
Assert.AreEqual(s_Groups[0].GroupImports.First().ImportsToMatch.First(), connection.Import);
Assert.AreEqual(1, connection.Exports.Count());
Assert.AreEqual(s_Groups[2].GroupExport.ProvidedExports.First(), connection.Exports.First());
}
public void GenerateConnectionForWithMultipleConnections()
{
var group1 = CreateExportingGroup();
var group2 = CreateImportingGroup();
var repository = new Mock<IPluginRepository>();
var partImportEngine = new Mock<IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
.Returns<SerializableImportDefinition, SerializableExportDefinition>(
(import, export) => import.ContractName == export.ContractName);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
var connections = importEngine.GenerateConnectionFor(group2, group2.GroupImports.First(), group1);
Assert.AreEqual(2, connections.Count());
var connection = connections.ElementAt(0);
Assert.AreEqual(group2.GroupImports.First().ImportsToMatch.ElementAt(0), connection.Import);
Assert.AreEqual(1, connection.Exports.Count());
Assert.AreEqual(group1.GroupExport.ProvidedExports.ElementAt(0), connection.Exports.ElementAt(0));
connection = connections.ElementAt(1);
Assert.AreEqual(group2.GroupImports.First().ImportsToMatch.ElementAt(1), connection.Import);
Assert.AreEqual(2, connection.Exports.Count());
Assert.That(
connection.Exports,
Is.EquivalentTo(
new List<ExportRegistrationId>
{
group1.GroupExport.ProvidedExports.ElementAt(1),
group1.GroupExport.ProvidedExports.ElementAt(2),
}));
}
public void ExportMatchesSelectionCriteriaWithoutMatch()
{
var repository = new Mock<IPluginRepository>();
{
repository.Setup(r => r.Parts())
.Returns(s_Parts);
repository.Setup(r => r.Part(It.IsAny<TypeIdentity>()))
.Returns<TypeIdentity>(t => s_Parts.FirstOrDefault(p => p.Identity.Equals(t)));
repository.Setup(r => r.Groups())
.Returns(s_Groups);
repository.Setup(r => r.Group(It.IsAny<GroupRegistrationId>()))
.Returns<GroupRegistrationId>(id => s_Groups.FirstOrDefault(g => g.Id.Equals(id)));
}
var partImportEngine = new Mock<IConnectParts>();
{
partImportEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
.Returns(true);
}
var importEngine = new GroupImportEngine(repository.Object, partImportEngine.Object);
Assert.IsFalse(
importEngine.ExportPassesSelectionCriteria(
s_Groups.First().GroupExport,
new Dictionary<string, object> { { "a", new object() } }));
}
