public void ConflictTreeNode_Equals_ChildrenSequenceEqual_ChildCountDifference_ExpectFalse()
{
//----------------------Arrange------------------------
var activityId = Guid.NewGuid().ToString();
var mockDev2Activity = new Mock <IDev2Activity>();
mockDev2Activity.Setup(dev2Activity => dev2Activity.UniqueID).Returns(activityId);
var childActivityId = Guid.NewGuid().ToString();
var mockChildDev2Activity = new Mock <IDev2Activity>();
mockChildDev2Activity.Setup(dev2Activity => dev2Activity.UniqueID).Returns(childActivityId);
var mockConflictTreeNode = new Mock <IConflictTreeNode>();
var mockConflictTreeNode1 = new Mock <IConflictTreeNode>();
var point = new Point();
var child = new ConflictTreeNode(mockChildDev2Activity.Object, point)
{
UniqueId = "testUniqueId"
};
var child2 = new ConflictTreeNode(mockChildDev2Activity.Object, point)
{
UniqueId = "testUniqueId"
};
var child1 = new ConflictTreeNode(mockChildDev2Activity.Object, point)
{
UniqueId = "testUniqueId"
};
mockConflictTreeNode.Setup(o => o.UniqueId).Returns("TestUniqueId");
mockConflictTreeNode1.Setup(o => o.UniqueId).Returns("TestUniqueId");
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point);
conflictTreeNode.AddChild(child, "test");
conflictTreeNode.AddChild(child2, "test");
var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity.Object, point);
conflictTreeNode1.AddChild(child1, "test");
//----------------------Act----------------------------
var treeNode = conflictTreeNode.Equals(conflictTreeNode1);
//----------------------Assert-------------------------
Assert.IsFalse(treeNode);
}
public void ConflictTreeNode_Equals_Is_ConflictTreeNode_ExpectTrue()
{
//----------------------Arrange------------------------
var mockDev2Activity = new Mock <IDev2Activity>();
var point = new Point();
var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity.Object, point);
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point);
//----------------------Act----------------------------
var treeNode = conflictTreeNode.Equals(conflictTreeNode1);
//----------------------Assert-------------------------
Assert.IsTrue(treeNode);
}
public void ConflictTreeNode_ObjectEquals_IsNot_ConflictTreeNode_ExpectFalse()
{
//----------------------Arrange------------------------
var mockDev2Activity = new Mock <IDev2Activity>();
var point = new Point();
var obj = new object();
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point);
//----------------------Act----------------------------
var treeNode = conflictTreeNode.Equals(obj);
//----------------------Assert-------------------------
Assert.IsFalse(treeNode);
}
void GetToolConflictItems(ConflictTreeNode current, ConflictTreeNode diff, bool diffFoundInCurrent, bool currFoundInDifferent)
{
if (!diffFoundInCurrent && !currFoundInDifferent)
{
//This is a guard clause
// NOTE: if we want to allow a tool that was deleted to not conflict with a tool that was added
// this is where it would be implemented
}
else
{
if (!diffFoundInCurrent)
{
currentToolConflictItem = ToolConflictItem.EmptyConflictItem();
}
if (!currFoundInDifferent)
{
diffToolConflictItem = ToolConflictItem.EmptyConflictItem();
}
}
if (currentToolConflictItem == null)
{
if (current == null)
{
currentToolConflictItem = ToolConflictItem.EmptyConflictItem();
}
else
{
currentToolConflictItem = new ToolConflictItem(_list, ConflictRowList.Column.Current);
_modelFactoryCurrent.CreateModelItem(currentToolConflictItem, current);
}
indexCurr++;
}
if (diffToolConflictItem == null)
{
if (diff == null)
{
diffToolConflictItem = ToolConflictItem.EmptyConflictItem();
}
else
{
diffToolConflictItem = new ToolConflictItem(_list, ConflictRowList.Column.Different);
_modelFactoryDifferent.CreateModelItem(diffToolConflictItem, diff);
}
indexDiff++;
}
}
public List <ToolConflictRow> CreateList(ConflictRowList list, ConflictTreeNode[] currentTree, ConflictTreeNode[] diffTree)
{
var _currentTree = currentTree;
var _diffTree = diffTree;
_list = list;
var toolConflictRowList = new List <ToolConflictRow>();
indexDiff = 0;
indexCurr = 0;
for (int i = 0; i <= MAX_WORKFLOW_ITEMS; i++)
{
if (i == MAX_WORKFLOW_ITEMS)
{
Dev2Logger.Error("ConflictRowListBuilder.CreateList: createlist expected to advance", GlobalConstants.WarewolfError);
throw new Exception("createlist expected to advance");
}
ConflictTreeNode current = null;
ConflictTreeNode diff = null;
current = GetConflictTreeNode(true, indexCurr, indexDiff, _currentTree);
diff = GetConflictTreeNode(false, indexCurr, indexDiff, _diffTree);
if (current == null && diff == null)
{
break;
}
currentToolConflictItem = null;
diffToolConflictItem = null;
bool diffFoundInCurrent = _currentTree.Contains(diff);
bool currFoundInDifferent = _diffTree.Contains(current);
if (diffFoundInCurrent && currFoundInDifferent)
{
diff = _diffTree.FirstOrDefault(o => o.UniqueId == current.UniqueId);
current = _currentTree.FirstOrDefault(o => o.UniqueId == current.UniqueId);
}
GetToolConflictItems(current, diff, diffFoundInCurrent, currFoundInDifferent);
var toolConflictRow = BuildToolConflictRow(list, current, diff);
toolConflictRow.IsMergeVisible = toolConflictRow.HasConflict;
toolConflictRowList.Add(toolConflictRow);
}
return(toolConflictRowList);
}
private ToolConflictRow BuildToolConflictRow(ConflictRowList list, ConflictTreeNode current, ConflictTreeNode diff)
{
var currentConnectorConflictTreeNode = currentToolConflictItem is ToolConflictItem.Empty ? null : current;
var diffConnectorConflictTreeNode = diffToolConflictItem is ToolConflictItem.Empty ? null : diff;
var connectors = GetConnectorConflictRows(list, currentToolConflictItem, diffToolConflictItem, currentConnectorConflictTreeNode, diffConnectorConflictTreeNode);
var diffToolConflictItem_override = diffToolConflictItem;
if (currentToolConflictItem.Activity != null && diffToolConflictItem.Activity != null && currentToolConflictItem.Activity.Equals(diffToolConflictItem.Activity))
{
diffToolConflictItem_override = currentToolConflictItem.Clone();
}
var toolConflictRow = ToolConflictRow.CreateConflictRow(currentToolConflictItem, diffToolConflictItem_override, connectors);
return(toolConflictRow);
}
List <ConflictTreeNode> BuildNodeItems(WorkflowDesigner wd, ModelService modelService, Flowchart flowchartDiff)
{
var idsLocations = GetIdLocations(wd, modelService);
var nodes = new List <ConflictTreeNode>();
var startNode = ModelItemUtils.CreateModelItem(flowchartDiff.StartNode);
if (startNode != null)
{
var start = _activityParser.Parse(new List <IDev2Activity>(), startNode);
var shapeLocation = GetShapeLocation(wd, startNode);
var startConflictNode = new ConflictTreeNode(start, shapeLocation);
nodes.Add(startConflictNode);
BuildItems(idsLocations, nodes, start, startConflictNode, flowchartDiff);
}
return(nodes);
}
public void ConflictTreeNode_GetHashCode_Children_IsNull_ExpectIsNotNull()
{
//----------------------Arrange------------------------
var mockDev2Activity = new Mock <IDev2Activity>();
var point = new Point();
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point)
{
UniqueId = "testUniqueId"
};
//----------------------Act----------------------------
var hashCode = conflictTreeNode.GetHashCode();
//----------------------Assert-------------------------
Assert.IsNotNull(hashCode);
}
public void ConflictTreeNode_SetProperty_Location_and_IsInConflict_ExpectSetValue()
{
//----------------------Arrange------------------------
var mockDev2Activity = new Mock <IDev2Activity>();
var point = new Point();
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point)
{
IsInConflict = true
};
//----------------------Act----------------------------
//----------------------Assert-------------------------
Assert.AreEqual(point, conflictTreeNode.Location);
Assert.IsTrue(conflictTreeNode.IsInConflict);
}
public void ConflictTreeNode_Equals_IsNot_ConflictTreeNode_ExpectFalse()
{
//----------------------Arrange------------------------
var mockDev2Activity = new Mock <IDev2Activity>();
var mockDev2Activity1 = new Mock <IDev2Activity>();
var point = new System.Windows.Point();
var point1 = new System.Windows.Point();
var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity1.Object, point1);
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point);
//----------------------Act----------------------------
var treeNode = conflictTreeNode.Equals(conflictTreeNode1);
//----------------------Assert-------------------------
Assert.IsFalse(treeNode);
}
private static ConflictTreeNode GetConflictTreeNode(bool IsCurrent, int indexCurr, int indexDiff, ConflictTreeNode[] nodes)
{
ConflictTreeNode node = null;
if (IsCurrent)
{
if (indexCurr < nodes.Length)
{
node = nodes[indexCurr];
}
}
else
{
if (indexDiff < nodes.Length)
{
node = nodes[indexDiff];
}
}
return(node);
}
public void ConflictTreeNode_Equals_Is_ConflictTreeNode_ExpectTrue1()
{
//----------------------Arrange------------------------
var mockDev2Activity = new Mock <IDev2Activity>();
var mockConflictTreeNode = new Mock <IConflictTreeNode>();
var point = new Point();
var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity.Object, point);
conflictTreeNode1.AddChild(mockConflictTreeNode.Object, "test1");
var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point);
conflictTreeNode.AddChild(mockConflictTreeNode.Object, "test");
//----------------------Act----------------------------
var treeNode = conflictTreeNode.Equals(conflictTreeNode1);
//----------------------Assert-------------------------
Assert.IsFalse(treeNode);
}
public ConflictRowList(IConflictModelFactory modelFactoryCurrent, IConflictModelFactory modelFactoryDifferent, List <ConflictTreeNode> currentTree, List <ConflictTreeNode> diffTree)
{
var _currentTree = currentTree.ToArray();
var _diffTree = diffTree.ToArray();
var createConflictRowList = new ConflictRowListBuilder(modelFactoryCurrent, modelFactoryDifferent);
_toolConflictRowList = createConflictRowList.CreateList(this, _currentTree, _diffTree);
ConflictTreeNode currentNode = null;
ConflictTreeNode diffNode = null;
if (_currentTree.Length > 0)
{
currentNode = _currentTree[0];
}
if (_diffTree.Length > 0)
{
diffNode = _diffTree[0];
}
CreateStartRow(currentNode, diffNode);
BindInboundConnections();
Ready = true;
}
private void CreateStartRow(ConflictTreeNode current, ConflictTreeNode diff)
{
if (_cacheStartToolRow != null)
{
return;
}
ImageSource mergeIcon = null;
if (Application.Current != null)
{
// TODO: replace Application.Current.TryFindResource with a mockable resource loader
mergeIcon = Application.Current.TryFindResource("System-StartNode") as ImageSource;
}
var currentConflictItem = ToolConflictItem.NewStartConflictItem(this, Column.Current, mergeIcon);
var differentConflictItem = ToolConflictItem.NewStartConflictItem(this, Column.Current, mergeIcon);
var startRow = ToolConflictRow.CreateStartRow(currentConflictItem, differentConflictItem);
startRow.Connectors = CreateStartNodeConnectors(currentConflictItem, differentConflictItem, current, diff);
_cacheStartToolRow = startRow;
}
private List <IConnectorConflictRow> GetConnectorConflictRows(ConflictRowList list, IToolConflictItem currentConflictItem, IToolConflictItem diffConflictItem, ConflictTreeNode current, ConflictTreeNode diff)
{
var rows = new List <IConnectorConflictRow>();
int index = 0;
var armConnectorsCurrent = new List <(string Description, string Key, string SourceUniqueId, string DestinationUniqueId)>();
var armConnectorsDiff = new List <(string Description, string Key, string SourceUniqueId, string DestinationUniqueId)>();
SetConnectorConflict(current, diff, out armConnectorsCurrent, out armConnectorsDiff, out int maxCount);
for (; index < maxCount; index++)
{
row = new ConnectorConflictRow();
row.CurrentArmConnector = new ConnectorConflictItem.Empty(row.UniqueId);
if (armConnectorsCurrent != null && index < armConnectorsCurrent.Count)
{
SetCurrentConnectorConflict(armConnectorsCurrent[index], list, currentConflictItem);
}
row.DifferentArmConnector = new ConnectorConflictItem.Empty(row.UniqueId);
if (armConnectorsDiff != null && index < armConnectorsDiff.Count)
{
SetDiffConnectorConflict(armConnectorsDiff[index], list, diffConflictItem);
}
var sameSourceAndDestination = row.CurrentArmConnector.SourceUniqueId != row.DifferentArmConnector.SourceUniqueId || row.CurrentArmConnector.DestinationUniqueId != row.DifferentArmConnector.DestinationUniqueId;
row.HasConflict = sameSourceAndDestination;
rows.Add(row);
}
return(rows);
}
IList <IConnectorConflictRow> CreateStartNodeConnectors(IToolConflictItem currentConflictItem, IToolConflictItem differentConflictItem, ConflictTreeNode current, ConflictTreeNode diff)
{
const string key = "Start";
var emptyGuid = Guid.Empty;
var row = new ConnectorConflictRow
{
Key = key,
ContainsStart = true
};
if (current == null)
{
row.CurrentArmConnector = new ConnectorConflictItem.Empty(emptyGuid);
}
else
{
var connector = new ConnectorConflictItem(this, Column.Current, row.UniqueId, "Start -> " + current.Activity.GetDisplayName(), emptyGuid, Guid.Parse(current.UniqueId), key);
row.CurrentArmConnector = connector;
currentConflictItem.OutboundConnectors.Add(connector);
}
if (diff == null)
{
row.DifferentArmConnector = new ConnectorConflictItem.Empty(emptyGuid);
}
else
{
var connector = new ConnectorConflictItem(this, Column.Different, row.UniqueId, "Start -> " + diff.Activity.GetDisplayName(), emptyGuid, Guid.Parse(diff.UniqueId), key);
row.DifferentArmConnector = connector;
differentConflictItem.OutboundConnectors.Add(connector);
}
return(new List <IConnectorConflictRow> {
row
});
}
