private NodeModel NewNode(double x, double y)
{
var node = new NodeModel(new Point(x, y));
node.AddPort(PortAlignment.BOTTOM);
node.AddPort(PortAlignment.TOP);
node.AddPort(PortAlignment.LEFT);
node.AddPort(PortAlignment.RIGHT);
return(node);
}
public void AddPort_Should_Throw_WhenIdIsOccupied()
{
var node = new NodeModel(Substitute.For <INodeType>());
var port1 = PortModel.Create <string>("Id", PortDirection.Input);
var port2 = PortModel.Create <string>("Id", PortDirection.Input);
node.AddPort(port1);
Assert.That(() => node.AddPort(port2), Throws.ArgumentException);
}
private NodeModel NewNode(double x, double y)
{
var node = new NodeModel(new Point(x, y));
node.AddPort(PortAlignment.Bottom);
node.AddPort(PortAlignment.Top);
node.AddPort(PortAlignment.Left);
node.AddPort(PortAlignment.Right);
return(node);
}
public void CanConnect_Should_ReturnFalse_WhenSameNode()
{
var graph = new GraphModel(GraphTypeWithConnections);
var node1 = new NodeModel(Substitute.For <INodeType>());
var port1 = PortModel.Create <string>("1", PortDirection.Output);
var port2 = PortModel.Create <string>("2", PortDirection.Input);
node1.AddPort(port1);
node1.AddPort(port2);
graph.AddNode(node1);
Assert.That(graph.CanConnect(port1, port2), Is.False);
}
protected override void OnInitialized()
{
base.OnInitialized();
diagram.RegisterModelComponent <BotAnswerNode, BotAnswerWidget>();
var node = new NodeModel(new Point(20, 20));
node.AddPort(PortAlignment.Top);
node.AddPort(PortAlignment.Right);
node.AddPort(PortAlignment.Bottom);
node.AddPort(PortAlignment.Left);
diagram.Nodes.Add(new[] { node, NewNode(100, 100), NewNode(300, 300) });
}
protected override void OnInitialized()
{
base.OnInitialized();
diagramManager.RegisterModelComponent <BotAnswerNode, BotAnswerWidget>();
diagramManager.AddNode(NewNode(100, 100));
diagramManager.AddNode(NewNode(300, 300));
var node = new NodeModel(new Point(20, 20));
node.AddPort(PortAlignment.TOP);
node.AddPort(PortAlignment.RIGHT);
node.AddPort(PortAlignment.BOTTOM);
node.AddPort(PortAlignment.LEFT);
diagramManager.AddNode(node);
}
public static void AddNodePorts(this NodeModel node, bool top = true, bool bottom = true, bool left = true,
bool right = true)
{
if (top)
{
node.AddPort(PortAlignment.Top);
}
if (bottom)
{
node.AddPort();
}
if (left)
{
node.AddPort(PortAlignment.Left);
}
if (right)
{
node.AddPort(PortAlignment.Right);
}
}
public void Disconnect_Should_Batch_WithConnect()
{
var graph = new GraphModel(Substitute.For <IGraphType>());
var node1 = new NodeModel(Substitute.For <INodeType>());
var node2 = new NodeModel(Substitute.For <INodeType>());
var port1 = PortModel.Create <string>("Out1", PortDirection.Output);
var port2 = PortModel.Create <string>("Out2", PortDirection.Output);
var port3 = PortModel.Create <string>("In1", PortDirection.Input);
var port4 = PortModel.Create <string>("In2", PortDirection.Input);
node1.AddPort(port1);
node1.AddPort(port2);
node2.AddPort(port3);
node2.AddPort(port4);
graph.AddNode(node1);
graph.AddNode(node2);
var connection1 = graph.Connect(port1, port3);
var connection2 = graph.Connect(port2, port4);
IReadOnlyList <ConnectionModel> removedConnections = null;
graph.GraphChanged += (an, rn, ac, rc) => { removedConnections = rc; };
using (graph.BeginChangeSet())
{
graph.Disconnect(connection1);
graph.Disconnect(connection2);
var connection3 = graph.Connect(port1, port3);
Assert.That(removedConnections, Is.Null);
Assert.That(connection3, Is.SameAs(connection1));
}
Assert.That(removedConnections, Is.Not.Null);
Assert.That(removedConnections, Is.EquivalentTo(new[] { connection2 }));
}
public void RemoveNode_Should_Remove_Connections()
{
var graph = new GraphModel(GraphTypeWithConnections);
var node1 = new NodeModel(Substitute.For <INodeType>());
var node2 = new NodeModel(Substitute.For <INodeType>());
var node3 = new NodeModel(Substitute.For <INodeType>());
graph.AddNode(node1);
graph.AddNode(node2);
graph.AddNode(node3);
var port1 = PortModel.Create <string>("Out", PortDirection.Output);
var port2 = PortModel.Create <string>("In", PortDirection.Input);
var port3 = PortModel.Create <string>("Out", PortDirection.Output);
var port4 = PortModel.Create <string>("In", PortDirection.Input);
node1.AddPort(port1);
node2.AddPort(port2);
node2.AddPort(port3);
node3.AddPort(port4);
var connection1 = graph.Connect(port1, port2);
var connection2 = graph.Connect(port3, port4);
IReadOnlyList <ConnectionModel> removedConnections = null;
graph.GraphChanged += (an, rn, ac, rc) => removedConnections = rc;
graph.RemoveNode(node2);
Assert.That(graph.Connections, Does.Not.Contains(connection1));
Assert.That(graph.Connections, Does.Not.Contains(connection2));
Assert.That(removedConnections, Is.EquivalentTo(new[] { connection1, connection2 }));
}
public void AddPort_Should_Succeed()
{
var node = new NodeModel(Substitute.For <INodeType>());
var port = PortModel.Create <string>("Id", PortDirection.Input);
NodeModel.NodePortsChangedArgs args = default;
node.PortsChanged += e => { args = e; };
node.AddPort(port);
Assert.That(node.Ports, Does.Contain(port));
Assert.That(port.Node, Is.EqualTo(node));
Assert.That(args.Node, Is.EqualTo(node));
Assert.That(args.Port, Is.EqualTo(port));
Assert.That(args.IsAdded, Is.True);
}
public void CanConnect_Should_ReturnFalse_WhenPortsNotInGraph()
{
var graph = new GraphModel(GraphTypeWithConnections);
var nodeType = Substitute.For <INodeType>();
var node1 = new NodeModel(nodeType);
var node2 = new NodeModel(nodeType);
var port1 = PortModel.Create <string>("Out", PortDirection.Output);
var port2 = PortModel.Create <string>("In", PortDirection.Input);
Assert.That(graph.CanConnect(port1, port2), Is.False);
node1.AddPort(port1);
node2.AddPort(port2);
Assert.That(graph.CanConnect(port1, port2), Is.False);
}
protected override void OnInitialized()
{
base.OnInitialized();
for (int r = 0; r < 10; r++)
{
for (int c = 0; c < 10; c += 2)
{
var node1 = new NodeModel(new Point(10 + c * 10 + c * 120, 10 + r * 100));
var node2 = new NodeModel(new Point(10 + (c + 1) * 130, 10 + r * 100));
var sourcePort = node1.AddPort(PortAlignment.Right);
var targetPort = node2.AddPort(PortAlignment.Left);
diagram.Nodes.Add(new[] { node1, node2 });
diagram.Links.Add(new LinkModel(sourcePort, targetPort));
}
}
}
public void Connect_Should_Throw_WhenCanNotConnect()
{
var graph = new GraphModel(GraphTypeWithConnections);
var nodeType = Substitute.For <INodeType>();
var node1 = new NodeModel(nodeType);
var node2 = new NodeModel(nodeType);
var port1 = PortModel.Create <string>("Out", PortDirection.Input);
var port2 = PortModel.Create <string>("In", PortDirection.Input);
node1.AddPort(port1);
node2.AddPort(port2);
graph.AddNode(node1);
graph.AddNode(node2);
Assert.That(() => graph.Connect(port1, port2), Throws.InvalidOperationException);
}
public void Connect_Should_Remove_OtherConnections()
{
var graph = new GraphModel(GraphTypeWithConnections);
var nodeType = Substitute.For <INodeType>();
var node1 = new NodeModel(nodeType);
var node2 = new NodeModel(nodeType);
var node3 = new NodeModel(nodeType);
var node4 = new NodeModel(nodeType);
var port1 = PortModel.Create <string>("Out", PortDirection.Output, PortCapacity.Single);
var port2 = PortModel.Create <string>("In", PortDirection.Input, PortCapacity.Single);
var port3 = PortModel.Create <string>("Out", PortDirection.Output, PortCapacity.Single);
var port4 = PortModel.Create <string>("In", PortDirection.Input, PortCapacity.Single);
node1.AddPort(port1);
node2.AddPort(port2);
node3.AddPort(port3);
node4.AddPort(port4);
graph.AddNode(node1);
graph.AddNode(node2);
graph.AddNode(node3);
graph.AddNode(node4);
var connection1 = graph.Connect(port1, port2);
IReadOnlyList <ConnectionModel> removedConnections = null;
graph.GraphChanged += (an, rn, ac, rc) => { removedConnections = rc; };
// ports may accept only one connection, that's why connection1 will be removed
var connection2 = graph.Connect(port3, port2);
Assert.That(graph.Connections, Does.Not.Contains(connection1));
Assert.That(removedConnections, Is.EquivalentTo(new[] { connection1 }));
// here, connection2 will be removed
var connection3 = graph.Connect(port3, port4);
Assert.That(graph.Connections, Does.Not.Contains(connection2));
Assert.That(removedConnections, Is.EquivalentTo(new[] { connection2 }));
}
protected override void OnInitialized()
{
base.OnInitialized();
for (int r = 0; r < 10; r++)
{
for (int c = 0; c < 10; c += 2)
{
var node1 = new NodeModel(new Point(10 + c * 10 + c * 120, 10 + r * 100));
var node2 = new NodeModel(new Point(10 + (c + 1) * 130, 10 + r * 100));
var sourcePort = node1.AddPort(PortAlignment.RIGHT);
var targetPort = node2.AddPort(PortAlignment.LEFT);
diagramManager.AddNodes(node1, node2);
diagramManager.AddLink(sourcePort, targetPort);
}
}
}
protected override void OnInitialized()
{
base.OnInitialized();
for (int r = 0; r < 8; r++)
{
for (int c = 0; c < 8; c += 2)
{
var node1 = new NodeModel(new Point(350 + c * 80 + c * 120, 150 + r * 120));
var node2 = new NodeModel(new Point(350 + (c + 1) * 200, 150 + r * 120));
var sourcePort = node1.AddPort(PortAlignment.Right);
var targetPort = node2.AddPort(PortAlignment.Left);
diagramManager.AddNodes(node1, node2);
diagramManager.AddLink(sourcePort, targetPort);
}
}
}
public void Connect_Should_Succeed()
{
var graph = new GraphModel(GraphTypeWithConnections);
var nodeType = Substitute.For <INodeType>();
var node1 = new NodeModel(nodeType);
var node2 = new NodeModel(nodeType);
var port1 = PortModel.Create <string>("Out", PortDirection.Output);
var port2 = PortModel.Create <string>("In", PortDirection.Input);
node1.AddPort(port1);
node2.AddPort(port2);
graph.AddNode(node1);
graph.AddNode(node2);
IReadOnlyList <ConnectionModel> list = null;
graph.GraphChanged += (an, rn, ac, rc) => { list = ac; };
var connection = graph.Connect(port1, port2);
Assert.That(connection, Is.Not.Null);
Assert.That(graph.Connections, Does.Contain(connection));
Assert.That(port1.Connections, Has.Count.EqualTo(1));
Assert.That(port2.Connections, Has.Count.EqualTo(1));
Assert.That(port1.Connections, Is.EquivalentTo(port2.Connections));
Assert.That(connection.From, Is.EqualTo(port1));
Assert.That(connection.To, Is.EqualTo(port2));
Assert.That(list, Is.Not.Null);
Assert.That(list.Count, Is.EqualTo(1));
Assert.That(list, Does.Contain(connection));
}
public void AddPort_Should_Throw_WhenNullPort()
{
var node = new NodeModel(Substitute.For <INodeType>());
Assert.That(() => node.AddPort(null), Throws.ArgumentNullException);
}
