public void CleanWorkbenchClearsUndoStack()
{
var dynamoModel = ViewModel.Model;
Assert.IsNotNull(dynamoModel.CurrentWorkspace);
var workspace = dynamoModel.CurrentWorkspace;
Assert.AreEqual(false, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
Assert.AreEqual(0, workspace.Nodes.Count); // An empty workspace
var createNodeCommand = new DynamoModel.CreateNodeCommand(
Guid.NewGuid(), "Add", 0, 0, false, false);
// Create a new node in the empty workspace.
ViewModel.ExecuteCommand(createNodeCommand);
Assert.AreEqual(1, workspace.Nodes.Count);
Assert.AreEqual(true, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
dynamoModel.CleanWorkbench(); // Clearing current workspace.
// Undo stack should be cleared.
Assert.AreEqual(false, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
}
public void CleanWorkbenchClearsUndoStack()
{
var dynamoModel = ViewModel.Model;
Assert.IsNotNull(dynamoModel.CurrentWorkspace);
var workspace = dynamoModel.CurrentWorkspace;
Assert.AreEqual(false, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
Assert.AreEqual(0, workspace.Nodes.Count); // An empty workspace
var addNode = new DSFunction(dynamoModel.LibraryServices.GetFunctionDescriptor("+"));
var createNodeCommand = new DynamoModel.CreateNodeCommand(
addNode, 0, 0, false, false);
// Create a new node in the empty workspace.
ViewModel.ExecuteCommand(createNodeCommand);
Assert.AreEqual(1, workspace.Nodes.Count);
Assert.AreEqual(true, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
dynamoModel.CurrentWorkspace.Clear(); // Clearing current workspace.
// Undo stack should be cleared.
Assert.AreEqual(false, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
}
public void NewWorkspaceFunctionDefinitionTest()
{
// Create code block node and define DS function "test"
var model = GetModel();
var code = "def test(x:int = 1){return = x;}test();";
var cbn = new CodeBlockNodeModel(code, 0, 0, model.LibraryServices, new ElementResolver());
var command = new DynamoModel.CreateNodeCommand(cbn, 0, 0, true, false);
model.ExecuteCommand(command);
AssertPreviewValue(cbn.GUID.ToString(), 1);
// Create empty new workspace
ViewModel.NewHomeWorkspaceCommand.Execute(null);
// Create code block node and invoke test function
code = "test();";
cbn = new CodeBlockNodeModel(code, 0, 0, model.LibraryServices, new ElementResolver());
command = new DynamoModel.CreateNodeCommand(cbn, 0, 0, true, false);
model.ExecuteCommand(command);
// Assert that function "test" is not defined any longer
// by asserting null for code block node invoking it.
AssertPreviewValue(cbn.GUID.ToString(), null);
}
public void CanSavePinState()
{
var model = CurrentDynamoModel;
var cbn = new CodeBlockNodeModel(model.LibraryServices);
var command = new DynamoModel.CreateNodeCommand(cbn, 0, 0, true, false);
CurrentDynamoModel.ExecuteCommand(command);
UpdateCodeBlockNodeContent(cbn, "42");
cbn.PreviewPinned = true;
DynamoSelection.Instance.Selection.Add(cbn);
var ids = DynamoSelection.Instance.Selection.OfType <NodeModel>().Select(x => x.GUID).ToList();
model.ExecuteCommand(new DynamoModel.AddPresetCommand("state1", "3", ids));
UpdateCodeBlockNodeContent(cbn, "146");
DynamoSelection.Instance.Selection.Remove(cbn);
model.CurrentWorkspace.ApplyPreset(model.CurrentWorkspace.Presets.Where(
x => x.Name == "state1").First());
RunCurrentModel();
Assert.IsTrue(cbn.PreviewPinned);
}
/// <summary>
/// Call this method to create a new node in Dynamo canvas.
/// </summary>
/// <param name="nodeName">Node creation name</param>
public void CreateNode(string nodeName)
{
dynamoWindow.Dispatcher.BeginInvoke(new Action(() =>
{
//Create the node of given item name
var cmd = new DynamoModel.CreateNodeCommand(Guid.NewGuid().ToString(), nodeName, -1, -1, true, false);
commandExecutive.ExecuteCommand(cmd, Guid.NewGuid().ToString(), ViewExtension.ExtensionName);
}));
}
//Creates a NodeModel to use for testing
private CodeBlockNodeModel CreateCodeBlockNode()
{
var cbn = new CodeBlockNodeModel(CurrentDynamoModel.LibraryServices);
var command = new DynamoModel.CreateNodeCommand(cbn, 0, 0, true, false);
CurrentDynamoModel.ExecuteCommand(command);
Assert.IsNotNull(cbn);
return(cbn);
}
public void CreateCustomSelectionNode(NodeModel node)
{
if (dynamoViewModel == null)
{
return;
}
var command = new DynamoModel.CreateNodeCommand(node, 0, 0, true, false);
dynamoViewModel.ExecuteCommand(command);
}
public void CreateSelectionNode()
{
if (dynamoViewModel == null)
{
return;
}
var command = new DynamoModel.CreateNodeCommand(new[] { Guid.NewGuid() }, "Fusion.SelectEntity", 0, 0, true, false);
dynamoViewModel.ExecuteCommand(command);
}
public void CannotAddGroupToOtherGroupIfTheGroupAlreadyBelongsToAGroup()
{
// Arrange
var group1Name = "Group1";
var group2Name = "Group2";
OpenModel(@"core\annotationViewModelTests\groupsTestFile.dyn");
var group1ViewModel = ViewModel.CurrentSpaceViewModel.Annotations.FirstOrDefault(x => x.AnnotationText == group1Name);
var group2ViewModel = ViewModel.CurrentSpaceViewModel.Annotations.FirstOrDefault(x => x.AnnotationText == group2Name);
var group1ContentBefore = group1ViewModel.Nodes.ToList();
// Act
// Add group2 to group1
var modelGuids = new List <Guid>
{
group1ViewModel.AnnotationModel.GUID,
group2ViewModel.AnnotationModel.GUID
};
ViewModel.ExecuteCommand(
new DynamoModel.SelectModelCommand(modelGuids, Keyboard.Modifiers.AsDynamoType()));
group1ViewModel.AddGroupToGroupCommand.Execute(null);
//Create 3rd group
var dummyNode = new DummyNode();
var command = new DynamoModel.CreateNodeCommand(dummyNode, 0, 0, true, false);
ViewModel.Model.ExecuteCommand(command);
ViewModel.ExecuteCommand(
new DynamoModel.SelectModelCommand(dummyNode.GUID, Keyboard.Modifiers.AsDynamoType()));
ViewModel.AddAnnotationCommand.Execute(null);
var group3ViewModel = ViewModel.CurrentSpaceViewModel.Annotations
.FirstOrDefault(x => x.AnnotationText != group2Name && x.AnnotationText != group1Name);
// now select group1 and group 3 and assert that
// group3 cannot execute AddGroupToGroupCommand
ViewModel.ExecuteCommand(
new DynamoModel.SelectModelCommand(
new List <Guid>
{
group3ViewModel.AnnotationModel.GUID,
group1ViewModel.AnnotationModel.GUID
},
Keyboard.Modifiers.AsDynamoType()));
// Assert
Assert.IsFalse(group3ViewModel.AddGroupToGroupCommand.CanExecute(null));
}
public override int Mutate(NodeModel node)
{
Random rand = new Random(1);
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
Guid guidNumber = Guid.NewGuid();
double coordinatesX = node.X * rand.NextDouble();
double coordinatesY = node.Y * rand.NextDouble();
DynamoModel.CreateNodeCommand createNodeNumber1 = null;
//new DynamoModel.AddNodeCommand(guidNumber, "Number", coordinatesX,
// coordinatesY, false, true);
DynamoViewModel.ExecuteCommand(createNodeNumber1);
DynamoModel.MakeConnectionCommand connToStart1 =
new DynamoModel.MakeConnectionCommand(guidNumber, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToStart2 =
new DynamoModel.MakeConnectionCommand(node.GUID, 0, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoModel.MakeConnectionCommand connToAmount1 =
new DynamoModel.MakeConnectionCommand(guidNumber, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToAmount2 =
new DynamoModel.MakeConnectionCommand(node.GUID, 1, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoModel.MakeConnectionCommand connToStep1 =
new DynamoModel.MakeConnectionCommand(guidNumber, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToStep2 =
new DynamoModel.MakeConnectionCommand(node.GUID, 2, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoViewModel.ExecuteCommand(connToStart1); //"Number" with "Number Sequence" on Start
DynamoViewModel.ExecuteCommand(connToStart2); //"Number" with "Number Sequence" on Start
DynamoViewModel.ExecuteCommand(connToAmount1); //"Number" with "Number Sequence" on Amount
DynamoViewModel.ExecuteCommand(connToAmount2); //"Number" with "Number Sequence" on Amount
DynamoViewModel.ExecuteCommand(connToStep1); //"Number" with "Number Sequence" on Step
DynamoViewModel.ExecuteCommand(connToStep2); //"Number" with "Number Sequence" on Step
}));
return 4;
}
public override int Mutate(NodeModel node)
{
Random rand = new Random(1);
int countOfInPorts = 0;
var nodeConnectors = node.AllConnectors.ToList();
foreach (ConnectorModel connector in nodeConnectors)
{
if (connector.Start.Owner.GUID != node.GUID)
{
Guid guidNumber = Guid.NewGuid();
double coordinatesX = node.X * rand.NextDouble();
double coordinatesYNumber1 = node.Y * rand.NextDouble();
countOfInPorts++;
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
//make node
DynamoModel.CreateNodeCommand createNodeNumber1 = null;
//new DynamoModel.AddNodeCommand(guidNumber, "Number",
// coordinatesX, coordinatesYNumber1, false, true);
//create node
DynamoViewModel.ExecuteCommand(createNodeNumber1);
int outPortIndex = connector.Start.Index;
int inPortIndex = connector.End.Index;
//make connection
DynamoModel.MakeConnectionCommand connToStart1 =
new DynamoModel.MakeConnectionCommand(guidNumber, outPortIndex,
PortType.Output, DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToStart2 =
new DynamoModel.MakeConnectionCommand(node.GUID, inPortIndex,
PortType.Input, DynamoModel.MakeConnectionCommand.Mode.End);
//create connections
DynamoViewModel.ExecuteCommand(connToStart1);
DynamoViewModel.ExecuteCommand(connToStart2);
}));
}
}
return(countOfInPorts * 2);
}
public override int Mutate(NodeModel node)
{
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
Guid guidNumber = Guid.NewGuid();
double coordinatesX = 120;
double coordinatesY = 180;
DynamoModel.CreateNodeCommand createNodeCmd1 =
new DynamoModel.CreateNodeCommand(guidNumber, "Number", coordinatesX,
coordinatesY, false, true);
DynamoViewModel.ExecuteCommand(createNodeCmd1);
DynamoModel.MakeConnectionCommand connToStart1 =
new DynamoModel.MakeConnectionCommand(guidNumber, 0, PortType.OUTPUT,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToStart2 =
new DynamoModel.MakeConnectionCommand(node.GUID, 0, PortType.INPUT,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoModel.MakeConnectionCommand connToAmount1 =
new DynamoModel.MakeConnectionCommand(guidNumber, 0, PortType.OUTPUT,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToAmount2 =
new DynamoModel.MakeConnectionCommand(node.GUID, 1, PortType.INPUT,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoModel.MakeConnectionCommand connToStep1 =
new DynamoModel.MakeConnectionCommand(guidNumber, 0, PortType.OUTPUT,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToStep2 =
new DynamoModel.MakeConnectionCommand(node.GUID, 2, PortType.INPUT,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoViewModel.ExecuteCommand(connToStart1); //"Number" with "Number Range" on Start
DynamoViewModel.ExecuteCommand(connToStart2); //"Number" with "Number Range" on Start
DynamoViewModel.ExecuteCommand(connToAmount1); //"Number" with "Number Range" on End
DynamoViewModel.ExecuteCommand(connToAmount2); //"Number" with "Number Range" on End
DynamoViewModel.ExecuteCommand(connToStep1); //"Number" with "Number Range" on Step
DynamoViewModel.ExecuteCommand(connToStep2); //"Number" with "Number Range" on Step
}));
return(4);
}
public void GetNodeFromCommandTest()
{
//Arrange
Guid newNodeGuid = Guid.NewGuid();
var command = new DynamoModel.CreateNodeCommand(newNodeGuid.ToString(), "NodeName1", 0, 0, true, true);
var command2 = new DynamoModel.CreateNodeCommand(newNodeGuid.ToString(), "CoreNodeModels.Watch", 0, 0, true, true);
//This will execute the proxy section code in the GetNodeFromCommand() method
var commandProxy = new DynamoModel.CreateProxyNodeCommand(newNodeGuid.ToString(), "CoreNodeModels.Watch", 0, 0, true, true, "ProxyCommand1", 0, 0);
//Assert
//Calling the ExecuteCommand internally executes the GetNodeFromCommand() method
Assert.Throws <Exception>(() => CurrentDynamoModel.ExecuteCommand(command));
CurrentDynamoModel.ExecuteCommand(command2);
Assert.Throws <Exception>(() => CurrentDynamoModel.ExecuteCommand(commandProxy));
}
public void KeepTransitionBetweenWarningTypes()
{
var cbn = new CodeBlockNodeModel(CurrentDynamoModel.LibraryServices);
var command = new DynamoModel.CreateNodeCommand(cbn, 0, 0, true, false);
CurrentDynamoModel.ExecuteCommand(command);
Assert.IsNotNull(cbn);
cbn.Warning("TestPermanent0", true);
Assert.AreEqual(ElementState.PersistentWarning, cbn.State);
Assert.AreEqual(string.Join("", new List <string>()
{
"TestPermanent0"
}), cbn.ToolTipText);
cbn.Warning("TestTransient0", false);
Assert.AreEqual(ElementState.Warning, cbn.State);
Assert.AreEqual(string.Join("", new List <string>()
{
"TestPermanent0", "\nTestTransient0"
}), cbn.ToolTipText);
cbn.Warning("TestPermanent1", true);
Assert.AreEqual(ElementState.PersistentWarning, cbn.State);
Assert.AreEqual(string.Join("", new List <string>()
{
"TestPermanent0", "TestPermanent1"
}), cbn.ToolTipText);
cbn.Warning("TestTransient1", false);
Assert.AreEqual(ElementState.Warning, cbn.State);
Assert.AreEqual(string.Join("", new List <string>()
{
"TestPermanent0", "TestPermanent1", "\nTestTransient1"
}), cbn.ToolTipText);
cbn.ClearErrorsAndWarnings();
Assert.AreEqual(ElementState.Active, cbn.State);
Assert.AreEqual("", cbn.ToolTipText);
}
/// <summary>
/// Call this method to create a new node in Dynamo canvas.
/// </summary>
/// <param name="nodeName">Node creation name</param>
public void CreateNode(string nodeName)
{
dynamoWindow.Dispatcher.BeginInvoke(new Action(() =>
{
//if the node we're trying to create is a customNode, lets disable the eventObserver.
// this will stop the libraryController from refreshing the libraryView on custom node creation.
var resultGuid = Guid.Empty;
if (Guid.TryParse(nodeName, out resultGuid))
{
this.disableObserver = true;
}
//Create the node of given item name
var cmd = new DynamoModel.CreateNodeCommand(Guid.NewGuid().ToString(), nodeName, -1, -1, true, false);
commandExecutive.ExecuteCommand(cmd, Guid.NewGuid().ToString(), ViewExtension.ExtensionName);
LogEventsToInstrumentation(CreateNodeInstrumentationString, nodeName);
this.disableObserver = false;
}));
}
public void GetNodeFromCommand_DuplicatedGuidsTest()
{
//Arrange
//This guid belongs to a CoreNodeModels.CreateList node inside the .dyn file
Guid existingNodeGuid = new Guid("81c94fd0-35a0-4680-8535-00aff41192d3");
string openPath = Path.Combine(TestDirectory, @"core\DetailedPreviewMargin_Test.dyn");
RunModel(openPath);
//When a CreateNodeCommand is executed internally calls the GetNodeFromCommand() method
var command = new DynamoModel.CreateNodeCommand(existingNodeGuid.ToString(), "List.Create", 0, 0, true, true);
//Act
CurrentDynamoModel.ExecuteCommand(command);
//Assert
//Validating that the NodeCommand was successfully created.
Assert.IsNotNull(command);
Assert.AreEqual(command.Name, "List.Create");
Assert.AreEqual(command.ModelGuid.ToString(), existingNodeGuid.ToString());
}
public override bool RunTest(NodeModel node, EngineController engine, StreamWriter writer)
{
bool pass = false;
var types = LoadAllTypesFromDynamoAssemblies();
foreach (Type type in types)
{
string nodeName = GetName(type);
var firstNodeConnectors = node.AllConnectors.ToList();
double coordinatesX = node.X;
double coordinatesY = node.Y;
if (!string.IsNullOrEmpty(nodeName))
{
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
var newNode = type.GetDefaultConstructor <NodeModel>()();
DynamoModel.CreateNodeCommand createCommand =
new DynamoModel.CreateNodeCommand(
newNode, coordinatesX, coordinatesY, false, false);
DynamoViewModel.ExecuteCommand(createCommand);
}));
var valueMap = new Dictionary <Guid, String>();
foreach (ConnectorModel connector in firstNodeConnectors)
{
Guid guid = connector.Start.Owner.GUID;
Object data = connector.Start.Owner.GetValue(0, engine).Data;
String val = data != null?data.ToString() : "null";
valueMap.Add(guid, val);
writer.WriteLine(guid + " :: " + val);
writer.Flush();
}
int numberOfUndosNeeded = Mutate(node);
Thread.Sleep(100);
writer.WriteLine("### - Beginning undo");
for (int iUndo = 0; iUndo < numberOfUndosNeeded; iUndo++)
{
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
DynamoModel.UndoRedoCommand undoCommand =
new DynamoModel.UndoRedoCommand(DynamoModel.UndoRedoCommand.Operation.Undo);
DynamoViewModel.ExecuteCommand(undoCommand);
}));
}
Thread.Sleep(100);
writer.WriteLine("### - undo complete");
writer.Flush();
ExecuteAndWait();
writer.WriteLine("### - Beginning test of CustomNode");
if (node.OutPorts.Count > 0)
{
try
{
NodeModel nodeAfterUndo =
DynamoViewModel.Model.CurrentWorkspace.Nodes.FirstOrDefault(
(t) => (t.GUID == node.GUID));
if (nodeAfterUndo != null)
{
var firstNodeConnectorsAfterUndo = nodeAfterUndo.AllConnectors.ToList();
foreach (ConnectorModel connector in firstNodeConnectors)
{
Guid guid = connector.Start.Owner.GUID;
Object data = connector.Start.Owner.GetValue(0, engine).Data;
String val = data != null?data.ToString() : "null";
if (valueMap[guid] != val)
{
writer.WriteLine("!!!!!!!!!!! - test of CustomNode is failed");
writer.WriteLine(node.GUID);
writer.WriteLine("Was: " + val);
writer.WriteLine("Should have been: " + valueMap[guid]);
writer.Flush();
return(pass);
}
}
}
}
catch (Exception)
{
writer.WriteLine("!!!!!!!!!!! - test of CustomNode is failed");
writer.Flush();
return(pass);
}
}
writer.WriteLine("### - test of CustomNode complete");
writer.Flush();
}
}
return(pass = true);
}
public override int Mutate(NodeModel node)
{
int workspaceIndex = DynamoViewModel.CurrentWorkspaceIndex;
Random rand = new Random(1);
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
DynamoModel.SwitchTabCommand switchCmd =
new DynamoModel.SwitchTabCommand(workspaceIndex);
DynamoViewModel.ExecuteCommand(switchCmd);
Thread.Sleep(100);
}));
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
DynamoModel.SwitchTabCommand switchCmd =
new DynamoModel.SwitchTabCommand(workspaceIndex);
DynamoViewModel.ExecuteCommand(switchCmd);
Thread.Sleep(100);
}));
var workspaces = DynamoModel.Workspaces;
var outputsInCustomNode = workspaces.FirstOrDefault((t) =>
{
return(t.Name == ((Function)node).Definition.WorkspaceModel.Name);
}).Nodes.Where(t => t.GetType() == typeof(Output)).ToList();
Guid numberGuid = Guid.NewGuid();
double coordinatesX = rand.NextDouble() * node.X;
double coordinatesY = rand.NextDouble() * node.Y;
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
DynamoModel.CreateNodeCommand createCommand =
new DynamoModel.CreateNodeCommand(numberGuid, "Number",
coordinatesX, coordinatesY, false, false);
DynamoViewModel.ExecuteCommand(createCommand);
}));
foreach (NodeModel output in outputsInCustomNode)
{
DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
{
DynamoModel.MakeConnectionCommand connToAnother1 =
new DynamoModel.MakeConnectionCommand(numberGuid, 0, PortType.OUTPUT,
DynamoModel.MakeConnectionCommand.Mode.Begin);
DynamoModel.MakeConnectionCommand connToAnother2 =
new DynamoModel.MakeConnectionCommand(output.GUID, 0, PortType.INPUT,
DynamoModel.MakeConnectionCommand.Mode.End);
DynamoViewModel.ExecuteCommand(connToAnother1);
DynamoViewModel.ExecuteCommand(connToAnother2);
}));
}
int numberOfUndosNeeded = outputsInCustomNode.Count * 2 + 1;
return(numberOfUndosNeeded);
}
