static void Main(string[] args)
{
//Create a Workflow instance object
ActivityBuilder ab = new ActivityBuilder();
ab.Implementation = new Sequence()
{
Activities =
{
new WriteLine{Text="Message from Workflow"}
}
};
//Convert Workflow instance to xml string
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(
new XamlXmlWriter(sw,new XamlSchemaContext()));
XamlServices.Save(xw, ab);
Console.WriteLine(sb.ToString());
Console.WriteLine("Presione una letra para continuar...");
Console.ReadKey();
}
static string GetSerializedActivity(bool visualBasic)
{
var activityBuilder = new ActivityBuilder
{
Name = "Demo"
};
activityBuilder.Properties.Add(new DynamicActivityProperty { Name = "HttpClient", Type = typeof(InArgument<HttpClient>) });
activityBuilder.Implementation = new Sequence
{
Activities =
{
new WriteLine
{
Text = (visualBasic)
?
(InArgument<string>) new VisualBasicValue<string>("New HttpClient().GetAsync(\"http://google.com\").Result.Content.ReadAsStringAsync.Result")
:
(InArgument<string>) new CSharpValue<string>("new HttpClient().GetAsync(\"http://google.com\").Result.Content.ReadAsStringAsync.Result")
}
}
};
var stringBuilder = new StringBuilder();
var stringWriter = new StringWriter(stringBuilder);
var xamlWriter = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(stringWriter, new XamlSchemaContext()));
XamlServices.Save(xamlWriter, activityBuilder);
var serializedActivityBuilder = stringBuilder.ToString();
Console.WriteLine(serializedActivityBuilder);
return serializedActivityBuilder;
}
private void cmdSaveUpdateMap_Click(object sender, RoutedEventArgs e)
{
DeltaWF = LoadActivityBuilder(txtWorkflowSnapshot.Text);
updateMap = DynamicUpdateServices.CreateUpdateMap(DeltaWF);
SaveUpdateMap(updateMap, txtWorkflowSnapshot.Text);
}
public static void PrepareForUpdate(ActivityBuilder activityDefinitionToBeUpdated)
{
if (activityDefinitionToBeUpdated == null)
{
throw FxTrace.Exception.ArgumentNull("activityDefinitionToBeUpdated");
}
InternalPrepareForUpdate(activityDefinitionToBeUpdated, true);
}
public void SaveActivityBuilder(ActivityBuilder builder, string path)
{
var actualpath = System.IO.Path.GetDirectoryName(path) + "\\wfReadytoUpdate.xaml";
txtWorkflowSnapshot.Text = actualpath;
using (var writer = File.CreateText(actualpath))
{
var xmlWriter = new XamlXmlWriter(writer, new XamlSchemaContext());
using (var xamlWriter = ActivityXamlServices.CreateBuilderWriter(xmlWriter))
{
XamlServices.Save(xamlWriter, builder);
}
}
}
public static ActivityBuilder GetActivityBuilder(string templateName, FlowNode startNode, Dictionary<string, FlowNode> resultListNodes, int numofParallelBranches)
{
var body = new Flowchart() { DisplayName = templateName, StartNode = startNode };
GetWfNodes(resultListNodes, ref body);
body.Variables.Add(new Variable<int>("ParallelBranchesCount") { Default = numofParallelBranches });
var activityBuilder = new ActivityBuilder();
activityBuilder.Name = "WfXamlTemplate";
activityBuilder.Properties.Add(new DynamicActivityProperty { Name = "FlowDataParm", Type = typeof(InArgument<FlowData>) });
activityBuilder.Properties.Add(new DynamicActivityProperty { Name = "NextDeptType", Type = typeof(InArgument<string>) });
activityBuilder.Properties.Add(new DynamicActivityProperty { Name = "DealWay", Type = typeof(InArgument<string>) });
activityBuilder.Implementation = body;
return activityBuilder;
}
internal static void ConvertActivityBuilderToDynamicActivity(ActivityBuilder activityBuilder, DynamicActivity bodyPlaceholder)
{
bodyPlaceholder.Name = activityBuilder.Name;
bodyPlaceholder.Implementation = () => activityBuilder.Implementation;
if (activityBuilder.Implementation != null)
{
VisualBasic.SetSettings(bodyPlaceholder, VisualBasic.GetSettings(activityBuilder));
}
bodyPlaceholder.Attributes.Clear();
foreach (Attribute attribute in activityBuilder.Attributes)
{
bodyPlaceholder.Attributes.Add(attribute);
}
bodyPlaceholder.Properties.Clear();
foreach (DynamicActivityProperty property in activityBuilder.Properties)
{
bodyPlaceholder.Properties.Add(property);
}
}
public void WorkflowDesignerViewModel_DoWorkspaceSave_NotNewResourceModel_ShouldCallSave()
{
//------------Setup for test--------------------------
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = CreateFlowNode(Guid.NewGuid(), "CanSaveTest", true, typeof(TestActivity))
}
};
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
resourceRep.Setup(repository => repository.Save(It.IsAny<IResourceModel>())).Verifiable();
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(model => model.IsNewWorkflow).Returns(false);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 9");
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
resourceModel.SetupProperty(model => model.WorkflowXaml);
#endregion
//------------Assert Preconditions-------------------
Assert.IsNull(resourceModel.Object.WorkflowXaml);
//------------Execute Test---------------------------
viewModel.DoWorkspaceSave();
//------------Assert Results-------------------------
resourceRep.Verify(repository => repository.Save(It.IsAny<IResourceModel>()), Times.Never());
Assert.IsNull(resourceModel.Object.WorkflowXaml);
}
public void WorkflowDesignerViewModel_ExpandAllCommand_True_RequestExpandAll()
{
//----------------------- Setup -----------------------//
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = CreateFlowNode(Guid.NewGuid(), "CanSaveTest", true, typeof(TestActivity))
}
};
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(model => model.ResourceName).Returns("Some workflow 332");
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
viewModel.SetupRequestExapandAll();
#endregion
const bool ExpectedCanSave = true;
resourceModel.Setup(m => m.IsAuthorized(AuthorizationContext.Contribute)).Returns(ExpectedCanSave).Verifiable();
//----------------------- Execute -----------------------//
Assert.IsFalse(viewModel.RequestedExpandAll);
viewModel.ExpandAllCommand.Execute(true);
viewModel.Dispose();
//----------------------- Assert -----------------------//
Assert.IsTrue(viewModel.RequestedExpandAll);
}
public static DynamicUpdateMap CreateUpdateMap(ActivityBuilder updatedActivityDefinition)
{
return CreateUpdateMap(updatedActivityDefinition, null);
}
public void WorkflowDesignerViewModel_DebugSelectionChanged_NullDebugState_DoesNothing()
{
//----------------------- Setup -----------------------//
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = CreateFlowNode(Guid.NewGuid(), "SelectionChangedTest1", true, typeof(TestActivity))
}
};
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 7");
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
#endregion
//----------------------- Execute -----------------------//
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = null, SelectionType = ActivitySelectionType.Single });
var result = viewModel.BringIntoViewHitCount;
viewModel.Dispose();
//----------------------- Assert -----------------------//
Assert.AreEqual(0, result);
}
public void WorkflowDesignerViewModel_UnitTest_ViewModelModelChanged_ExpectFirstFocusDoesNotReflectEdit()
{
var ok = true;
var msg = string.Empty;
var t = new Thread(() =>
{
try
{
#region Setup viewModel
var workflow = new ActivityBuilder();
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.SetupAllProperties();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
StringBuilder xamlBuilder = new StringBuilder(StringResources.xmlServiceDefinition);
resourceModel.Object.WorkflowXaml = new StringBuilder("<a/>");
resourceModel.Object.ResourceName = "Test";
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
workflowHelper.Setup(h => h.SanitizeXaml(It.IsAny<StringBuilder>())).Returns(xamlBuilder);
workflowHelper.Setup(h => h.SerializeWorkflow(It.IsAny<ModelService>())).Returns(new StringBuilder("<x></x>"));
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object) { ServiceDefinition = xamlBuilder };
#endregion
#region setup Mock ModelItem
var properties = new Dictionary<string, Mock<ModelProperty>>();
var propertyCollection = new Mock<ModelPropertyCollection>();
var environmentRepository = SetupEnvironmentRepo(Guid.Empty); // Set the active environment
var testAct = DsfActivityFactory.CreateDsfActivity(resourceModel.Object, new DsfActivity(), true, environmentRepository, true);
var prop = new Mock<ModelProperty>();
prop.Setup(p => p.SetValue(It.IsAny<DsfActivity>())).Verifiable();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Action", prop);
propertyCollection.Protected().Setup<ModelProperty>("Find", "Action", true).Returns(prop.Object);
var source = new Mock<ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
source.Setup(s => s.ItemType).Returns(typeof(FlowStep));
#endregion
#region setup mock to change properties
//mock item adding - this is obsolete functionality but not refactored due to overhead
var args = new Mock<ModelChangedEventArgs>();
#pragma warning disable 618
args.Setup(a => a.ItemsAdded).Returns(new List<ModelItem> { source.Object });
#pragma warning restore 618
#endregion
//Execute
var workSurfaceKey = WorkSurfaceKeyFactory.CreateKey(resourceModel.Object);
OpeningWorkflowsHelper.AddWorkflowWaitingForFirstFocusLoss(workSurfaceKey);
resourceModel.Object.IsWorkflowSaved = true;
viewModel.TestWorkflowDesignerModelChanged();
viewModel.Dispose();
OpeningWorkflowsHelper.RemoveWorkflowWaitingForFirstFocusLoss(workSurfaceKey);
//Verify
Assert.IsTrue(resourceModel.Object.IsWorkflowSaved);
Assert.IsTrue(resourceModel.Object.ResourceName.IndexOf("*", StringComparison.Ordinal) < 0);
StringAssert.Contains("<x></x>", resourceModel.Object.WorkflowXaml.ToString());
Assert.AreEqual("<x></x>", resourceModel.Object.WorkflowXaml.ToString());
}
catch (Exception e)
{
ok = false;
msg = e.Message + " -> " + e.StackTrace;
}
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
Assert.IsTrue(ok, msg);
}
public static string GetXamlString(ActivityBuilder activityBuilder)
{
var stringBuilder = new StringBuilder();
var stringWriter = new StringWriter(stringBuilder);
var xamlSchemaContext = new XamlSchemaContext();
var xamXmlWriter = new XamlXmlWriter(stringWriter, xamlSchemaContext);
var xamlWriter = System.Activities.XamlIntegration.ActivityXamlServices.CreateBuilderWriter(xamXmlWriter);
XamlServices.Save(xamlWriter, activityBuilder);
return stringBuilder.ToString();
}
public void WorkflowDesigner_Initialize_WhenWorkflowXamlNullAndFetchFails_ExpectNewWorkflow()
{
var ok = true;
var msg = string.Empty;
var t = new Thread(() =>
{
try
{
#region Setup viewModel
var workflow = new ActivityBuilder();
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
ExecuteMessage exeMsg = null;
// ReSharper disable ExpressionIsAlwaysNull
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(exeMsg);
// ReSharper restore ExpressionIsAlwaysNull
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(r => r.ResourceName).Returns("Test");
StringBuilder xamlBuilder = new StringBuilder("abc");
var workflowHelper = new Mock<IWorkflowHelper>();
var ok2 = false;
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(() =>
{
ok2 = true;
return workflow;
});
workflowHelper.Setup(h => h.SanitizeXaml(It.IsAny<StringBuilder>())).Returns(xamlBuilder);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
#endregion
var environmentRepository = SetupEnvironmentRepo(Guid.Empty); // Set the active environment
#region setup Mock ModelItem
var properties = new Dictionary<string, Mock<ModelProperty>>();
var propertyCollection = new Mock<ModelPropertyCollection>();
var testAct = DsfActivityFactory.CreateDsfActivity(resourceModel.Object, new DsfActivity(), true, environmentRepository, true);
var prop = new Mock<ModelProperty>();
prop.Setup(p => p.SetValue(It.IsAny<DsfActivity>())).Verifiable();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Action", prop);
propertyCollection.Protected().Setup<ModelProperty>("Find", "Action", true).Returns(prop.Object);
var source = new Mock<ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
source.Setup(s => s.ItemType).Returns(typeof(FlowStep));
#endregion
#region setup mock to change properties
//mock item adding - this is obsolote functionality but not refactored due to overhead
var args = new Mock<ModelChangedEventArgs>();
#pragma warning disable 618
args.Setup(a => a.ItemsAdded).Returns(new List<ModelItem> { source.Object });
#pragma warning restore 618
#endregion
//Execute
viewModel.LoadXaml();
// verify CreateWorkflow called
Assert.IsTrue(ok2);
}
catch (Exception e)
{
ok = false;
msg = e.Message + " -> " + e.StackTrace;
}
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
Assert.IsTrue(ok, msg);
}
public void WorkflowDesignerViewModel_LinkName_HasDataListNoInputs_ShouldReturnUrlEmptyDataListPortion()
{
//------------Setup for test--------------------------
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = CreateFlowNode(Guid.NewGuid(), "CanSaveTest", true, typeof(TestActivity))
}
};
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
resourceRep.Setup(repository => repository.Save(It.IsAny<IResourceModel>())).Verifiable();
var resourceModel = new Mock<IContextualResourceModel>();
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
var mockConnection = new Mock<IEnvironmentConnection>();
mockConnection.Setup(connection => connection.IsConnected).Returns(true);
mockConnection.Setup(connection => connection.WebServerUri).Returns(new Uri("http://myMachineName:3142"));
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockConnection.Object);
resourceModel.Setup(m => m.Environment).Returns(mockEnvironmentModel.Object);
resourceModel.Setup(m => m.Environment.IsConnected).Returns(true);
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(m => m.Environment.Connection).Returns(mockConnection.Object);
resourceModel.Setup(model => model.IsNewWorkflow).Returns(true);
resourceModel.Setup(model => model.Category).Returns("myservice");
resourceModel.Setup(model => model.ResourceName).Returns("myservice");
resourceModel.Setup(model => model.DataList).Returns(StringResourcesTest.DebugInputWindow_NoInputs_XMLData);
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
workflowHelper.Setup(helper => helper.SerializeWorkflow(It.IsAny<ModelService>())).Returns(new StringBuilder("my workflow"));
var mockPopController = new Mock<IPopupController>();
mockPopController.Setup(controller => controller.ShowNoInputsSelectedWhenClickLink()).Verifiable();
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object, mockPopController.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
resourceModel.SetupProperty(model => model.WorkflowXaml);
#endregion
//------------Assert Preconditions-------------------
Assert.IsNull(resourceModel.Object.WorkflowXaml);
//------------Execute Test---------------------------
var workflowLink = viewModel.GetWorkflowLink();
var displayWorkflowLink = viewModel.DisplayWorkflowLink;
viewModel.OpenWorkflowLinkCommand.Execute("Do not perform action");
//------------Assert Results-------------------------
Assert.AreEqual("http://mymachinename:3142/secure/myservice.json?<DataList></DataList>&wid=00000000-0000-0000-0000-000000000000", workflowLink);
Assert.AreEqual("http://mymachinename:3142/secure/myservice.json?<DataList></DataList>", displayWorkflowLink);
mockPopController.Verify(controller => controller.ShowNoInputsSelectedWhenClickLink(), Times.Once());
}
public static DynamicUpdateMap CreateUpdateMap(ActivityBuilder updatedActivityDefinition, IEnumerable<Activity> disallowUpdateInsideActivities)
{
IList<ActivityBlockingUpdate> activitiesBlockingUpdate;
return CreateUpdateMap(updatedActivityDefinition, disallowUpdateInsideActivities, out activitiesBlockingUpdate);
}
private void cmdWorkflowUpdate_Click(object sender, RoutedEventArgs e)
{
OriginalWF = LoadActivityBuilder(txtWorkflowFile.Text); //Load original workflow to update
DynamicUpdateServices.PrepareForUpdate(OriginalWF); //Prepare the workflow for update
SaveActivityBuilder(OriginalWF, txtWorkflowFile.Text); //Save the prepared workflow
}
//从[xaml]字串得到[ActivityBuilder]对象
public static string xamlFromActivityBuilder(ActivityBuilder activityBuilder)
{
string xamlString = "";
StringBuilder stringBuilder = new StringBuilder();
System.IO.StringWriter stringWriter = new System.IO.StringWriter(stringBuilder);
System.Xaml.XamlSchemaContext xamlSchemaContext = new System.Xaml.XamlSchemaContext();
System.Xaml.XamlXmlWriter xamlXmlWriter = new System.Xaml.XamlXmlWriter(stringWriter, xamlSchemaContext);
System.Xaml.XamlWriter xamlWriter = System.Activities.XamlIntegration.ActivityXamlServices.CreateBuilderWriter(xamlXmlWriter);
System.Xaml.XamlServices.Save(xamlWriter, activityBuilder);
xamlString = stringBuilder.ToString();
return xamlString;
}
public static DynamicUpdateMap CreateUpdateMap(ActivityBuilder updatedActivityDefinition, IEnumerable<Activity> disallowUpdateInsideActivities, out IList<ActivityBlockingUpdate> activitiesBlockingUpdate)
{
if (updatedActivityDefinition == null)
{
throw FxTrace.Exception.ArgumentNull("updatedActivityDefinition");
}
ActivityBuilder originalActivityDefinition = DynamicUpdateInfo.GetOriginalActivityBuilder(updatedActivityDefinition);
if (originalActivityDefinition == null)
{
throw FxTrace.Exception.Argument("updatedActivityDefinition", SR.MustCallPrepareBeforeFinalize);
}
Activity originalBuiltRoot = GetDynamicActivity(originalActivityDefinition);
Activity updatedBuiltRoot = GetDynamicActivity(updatedActivityDefinition);
DynamicUpdateMap result = InternalTryCreateUpdateMap(updatedBuiltRoot, originalBuiltRoot, disallowUpdateInsideActivities, true, out activitiesBlockingUpdate);
// Remove the DynamicUpdateMapItems now that the update is finalized
// Calling CalculateMapItems is actually an unnecessary perf hit since it calls CacheMetadata
// again; but we do it so that Finalize is implemented purely in terms of other public APIs.
DynamicUpdateInfo.SetOriginalActivityBuilder(updatedActivityDefinition, null);
IDictionary<object, DynamicUpdateMapItem> mapItems = DynamicUpdateMap.CalculateImplementationMapItems(updatedBuiltRoot);
foreach (object matchObject in mapItems.Keys)
{
DynamicUpdateInfo.SetMapItem(matchObject, null);
}
return result;
}
static DynamicActivity GetDynamicActivity(ActivityBuilder activityDefinition)
{
DynamicActivity result = new DynamicActivity
{
Name = activityDefinition.Name
};
foreach (DynamicActivityProperty property in activityDefinition.Properties)
{
result.Properties.Add(property);
}
foreach (Attribute attrib in activityDefinition.Attributes)
{
result.Attributes.Add(attrib);
}
foreach (Constraint constraint in activityDefinition.Constraints)
{
result.Constraints.Add(constraint);
}
result.Implementation = () => activityDefinition.Implementation;
VisualBasicSettings vbsettings = VisualBasic.GetSettings(activityDefinition);
if (vbsettings != null)
{
VisualBasic.SetSettings(result, vbsettings);
}
IList<string> namespacesForImplementation = TextExpression.GetNamespacesForImplementation(activityDefinition);
if (namespacesForImplementation.Count > 0)
{
TextExpression.SetNamespacesForImplementation(result, namespacesForImplementation);
}
IList<AssemblyReference> referencesForImplementation = TextExpression.GetReferencesForImplementation(activityDefinition);
if (referencesForImplementation.Count > 0)
{
TextExpression.SetReferencesForImplementation(result, referencesForImplementation);
}
return result;
}
public void WorkflowDesignerViewModel_HandleUpdateResourceMessage_WhenMessageHasErrors_ResourceModelShouldHaveErrors()
{
//------------Setup for test--------------------------
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = CreateFlowNode(Guid.NewGuid(), "CanSaveTest", true, typeof(TestActivity))
}
};
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
resourceRep.Setup(repository => repository.Save(It.IsAny<IResourceModel>())).Verifiable();
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(model => model.IsNewWorkflow).Returns(false);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 11");
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
resourceModel.SetupGet(model => model.Errors);
resourceModel.Setup(model => model.Errors).Returns(new ObservableReadOnlyList<IErrorInfo>(new List<IErrorInfo> { new ErrorInfo() }));
resourceModel.Setup(model => model.AddError(It.IsAny<IErrorInfo>())).Verifiable();
var updateResourceMessage = new UpdateResourceMessage(resourceModel.Object);
//------------Execute Test---------------------------
viewModel.Handle(updateResourceMessage);
//------------Assert Results-------------------------
resourceModel.Verify(model => model.AddError(It.IsAny<IErrorInfo>()), Times.Once());
}
private static void SaveUpdatedDefinition(ActivityBuilder wf, string name)
{
string xamlPath = Path.Combine(definitionPath, name);
StreamWriter sw = File.CreateText(xamlPath);
XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(sw, new XamlSchemaContext()));
XamlServices.Save(xw, wf);
sw.Close();
}
public void CheckIfRemoteWorkflowAndSetPropertiesExpectedServiceUriToBeNull()
{
const string ServiceUri = "http://localhost:1234/";
var resourceEnvironmentID = Guid.NewGuid();
var envId = Guid.NewGuid();
var mockResourceModel = Dev2MockFactory.SetupResourceModelMock();
var mockWorkflowHelper = new Mock<IWorkflowHelper>();
var environmentRepository = SetupEnvironmentRepo(Guid.Empty); // Set the active environment
var testAct = DsfActivityFactory.CreateDsfActivity(mockResourceModel.Object, new DsfActivity(), true, environmentRepository, true);
var mockEnv = Dev2MockFactory.SetupEnvironmentModel(mockResourceModel, null);
mockEnv.Setup(c => c.ID).Returns(envId);
mockResourceModel.Setup(c => c.Environment).Returns(mockEnv.Object);
var testClass = new WorkflowDesignerViewModelMock(mockResourceModel.Object, mockWorkflowHelper.Object);
testClass.TestCheckIfRemoteWorkflowAndSetProperties(testAct, mockResourceModel.Object, mockEnv.Object);
Assert.IsTrue(testAct.ServiceUri == null);
Assert.IsTrue(testAct.ServiceServer == Guid.Empty);
var contextEnvironment = new Mock<IEnvironmentModel>();
contextEnvironment.Setup(e => e.ID).Returns(resourceEnvironmentID);
var activity = new DsfActivity();
var workflow = new ActivityBuilder { Implementation = activity };
#region Setup resourceModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(m => m.ResourceType).Returns(ResourceType.WorkflowService);
resourceModel.Setup(m => m.Environment.ID).Returns(resourceEnvironmentID);
resourceModel.Setup(m => m.Environment.Connection.WebServerUri).Returns(new Uri(ServiceUri));
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 1");
#endregion
#region Setup viewModel
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
// not necessary to invoke: viewModel.InitializeDesigner(new Dictionary<Type, Type>());
#endregion
viewModel.TestCheckIfRemoteWorkflowAndSetProperties(activity, resourceModel.Object, contextEnvironment.Object);
viewModel.Dispose();
Assert.IsNull(activity.ServiceUri);
Assert.AreEqual(Guid.Empty, activity.ServiceServer);
}
public static string removeViewState(ActivityBuilder activityBuilder)
{
string xamlString = "";
XmlWriterSettings writerSettings = new XmlWriterSettings { Indent = true };
StringBuilder stringBuilder = new StringBuilder();
XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, writerSettings);
XamlXmlWriter xamlXmlWriter = new XamlXmlWriter(xmlWriter, new XamlSchemaContext());
XamlWriter xamlWriter = ActivityXamlServices.CreateBuilderWriter(xamlXmlWriter);
viewStateXamlWriter wfViewStateControl = new viewStateXamlWriter(xamlWriter);
XamlServices.Save(wfViewStateControl, activityBuilder);
xamlString = stringBuilder.ToString();
return xamlString;
}
public void WorkflowDesignerViewModel_LinkName_SavedDebugData_ShouldReturnUrlWithDataListUsingSavedData()
{
//------------Setup for test--------------------------
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = CreateFlowNode(Guid.NewGuid(), "CanSaveTest", true, typeof(TestActivity))
}
};
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
resourceRep.Setup(repository => repository.Save(It.IsAny<IResourceModel>())).Verifiable();
var resourceModel = new Mock<IContextualResourceModel>();
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
var mockConnection = new Mock<IEnvironmentConnection>();
mockConnection.Setup(connection => connection.IsConnected).Returns(true);
mockConnection.Setup(connection => connection.WebServerUri).Returns(new Uri("http://myMachineName:3142"));
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockConnection.Object);
resourceModel.Setup(m => m.Environment).Returns(mockEnvironmentModel.Object);
resourceModel.Setup(m => m.Environment.IsConnected).Returns(true);
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(m => m.Environment.Connection).Returns(mockConnection.Object);
resourceModel.Setup(model => model.IsNewWorkflow).Returns(true);
resourceModel.Setup(model => model.Category).Returns("myservice");
resourceModel.Setup(model => model.ResourceName).Returns("myservice");
resourceModel.Setup(model => model.DataList).Returns(StringResourcesTest.DebugInputWindow_DataList);
var workflowInputDataViewModel = WorkflowInputDataViewModel.Create(resourceModel.Object);
workflowInputDataViewModel.LoadWorkflowInputs();
workflowInputDataViewModel.WorkflowInputs[0].Value = "1";
workflowInputDataViewModel.WorkflowInputs[1].Value = "2";
workflowInputDataViewModel.DoSaveActions();
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
workflowHelper.Setup(helper => helper.SerializeWorkflow(It.IsAny<ModelService>())).Returns(new StringBuilder("my workflow"));
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
resourceModel.SetupProperty(model => model.WorkflowXaml);
#endregion
//------------Assert Preconditions-------------------
Assert.IsNull(resourceModel.Object.WorkflowXaml);
//------------Execute Test---------------------------
var workflowLink = viewModel.GetWorkflowLink();
var displayWorkflowLink = viewModel.DisplayWorkflowLink;
//------------Assert Results-------------------------
Assert.AreEqual("http://mymachinename:3142/secure/myservice.json?scalar1=1&scalar2=2&wid=00000000-0000-0000-0000-000000000000", workflowLink);
Assert.AreEqual("http://mymachinename:3142/secure/myservice.json?scalar1=1&scalar2=2", displayWorkflowLink);
workflowInputDataViewModel.WorkflowInputs[0].Value = "";
workflowInputDataViewModel.WorkflowInputs[1].Value = "";
workflowInputDataViewModel.DoSaveActions();
}
private string buildXaml(PD_Process process, PD_Subject subject)
{
Flowchart flow = new Flowchart();
Variable flowGlobalTransition = new Variable<String> { Name = "GlobalTransition" };
Variable flowGlobalVariables = new Variable<DynamicValue> { Name = "GlobalVariables"};
string globVariablesInit = "";
if (subject.GlobalParameters.Count > 0)
{
globVariablesInit = "{";
foreach (string p in subject.GlobalParameters)
{
var par = _pdesignerDB.PD_Parameters.Find(subject.PD_Process_Id, p);
globVariablesInit = globVariablesInit + "\""+ p +"\":"+ par.Config +",";
}
globVariablesInit = globVariablesInit.Remove(globVariablesInit.Length - 1, 1);
globVariablesInit = globVariablesInit + "}";
}
Variable flowGlobalVariablesSchema = new Variable<string> { Name = "GlobalVariablesSchema", Default = globVariablesInit };
Dictionary<int, FlowStep> nodeList = new Dictionary<int, System.Activities.Statements.FlowStep>();
flow.Variables.Add(flowGlobalTransition);
flow.Variables.Add(flowGlobalVariables);
flow.Variables.Add(flowGlobalVariablesSchema);
foreach (var state in subject.States)
{
FlowStep f;
if (state.Type == PD_StateTypes.FunctionState)
{
var s = (PD_FunctionState)state;
string timeout = "";
try
{
var timeouttransition = subject.Transitions.First(result => result.Source == s.Id && result.Type == PD_TransitionTypes.TimeoutTransition);
timeout = ((PD_TimeoutTransition)timeouttransition).TimeSpan;
}
catch (Exception e)
{
}
var transitions = subject.Transitions.Where(result => result.Source == s.Id && result.Type == PD_TransitionTypes.RegularTransition);
List<string> titems = new List<string>();
transitions.ToList().ForEach(i => titems.Add(((PD_RegularTransition)i).Name));
f = new FlowStep() { Action = new FunctionStateT() { DisplayName = s.Name, OrderId = s.Id, name = s.Name, GlobalTransition = new OutArgument<string>(flowGlobalTransition), GlobalVariables = new InOutArgument<DynamicValue>(flowGlobalVariables), isEndState = s.EndState, readableParameters = collectionToString(s.ReadableParameters), editableParameters = collectionToString(s.EditableParameters), TimeOut = timeout, transitions = collectionToString(titems) } };
}
else if (state.Type == PD_StateTypes.SendState)
{
var s = (PD_SendState)state;
string timeout = "";
try
{
var timeouttransition = subject.Transitions.First(result => result.Source == s.Id && result.Type == PD_TransitionTypes.TimeoutTransition);
timeout = ((PD_TimeoutTransition)timeouttransition).TimeSpan;
}
catch (Exception e)
{
}
var message = process.Messages.First(result => result.Id == s.Message);
string to = process.Subjects.First(result => result.Id == message.To).Name;
f = new FlowStep() { Action = new SendStateT() { DisplayName = s.Name, OrderId = s.Id, name = s.Name, GlobalTransition = new OutArgument<string>(flowGlobalTransition), GlobalVariables = new InOutArgument<DynamicValue>(flowGlobalVariables), isEndState = s.EndState, readableParameters = collectionToString(s.ReadableParameters), editableParameters = collectionToString(s.EditableParameters), messageType = message.PD_MessageType.Name, parameters = collectionToString(message.PD_MessageType.Parameters), toSubject = to, TimeOut = timeout } };
}
else //(state.Type == PD_StateTypes.ReceiveState)
{
var s = (PD_ReceiveState)state;
string messages = "";
List<string> messagelist = new List<string>();
var receivetransitions = subject.Transitions.Where(result => result.Source == s.Id && result.Type == PD_TransitionTypes.ReceiveTransition);
foreach (var i in receivetransitions)
{
messagelist.Add(receiveTranstionToString(process, (PD_ReceiveTransition)i));
}
messages = collectionToString(messagelist);
string timeout = "";
try
{
var timeouttransition = subject.Transitions.First(result => result.Source == s.Id && result.Type == PD_TransitionTypes.TimeoutTransition);
timeout = ((PD_TimeoutTransition)timeouttransition).TimeSpan;
}
catch (Exception e)
{
}
f = new FlowStep() { Action = new ReceiveStateT() { DisplayName = s.Name, OrderId = s.Id, name = s.Name, GlobalTransition = new OutArgument<string>(flowGlobalTransition), GlobalVariables = new InOutArgument<DynamicValue>(flowGlobalVariables), isEndState = s.EndState, TimeOut = timeout, messages = messages } };
}
flow.Nodes.Add(f);
nodeList.Add(state.Id, f);
}
var initGP = new FlowStep() { Action = new InitializeGlobalParameters() { DisplayName = "init GP", DynamicVal = new InOutArgument<DynamicValue>(flowGlobalVariables), GlobalParameterSchema = new InArgument<string>(flowGlobalVariablesSchema) } };
initGP.Next = nodeList[subject.States.First(result => result.StartState == true).Id];
flow.StartNode = initGP;
// flow.StartNode = nodeList[subject.States.First(result => result.StartState == true).Id];
foreach (var state in subject.States)
{
List<PD_Transition> transitions = new List<PD_Transition>();
try
{
subject.Transitions.Where(result => result.Source == state.Id).ToList().ForEach(item => transitions.Add(item));
}
catch (Exception e) { }
if (transitions.Count > 0)
{
if (transitions.Count == 1)
{
var t = transitions[0];
nodeList[t.Source].Next = nodeList[t.Target];
}
else
{
FlowSwitch<String> newSwitch = new FlowSwitch<String> { Expression = flowGlobalTransition };
flow.Nodes.Add(newSwitch);
nodeList[state.Id].Next = newSwitch;
try
{
var timeouttransition = transitions.First(result => result.Type == PD_TransitionTypes.TimeoutTransition);
newSwitch.Cases.Add("TimeOut!", nodeList[timeouttransition.Target]);
transitions.Remove(timeouttransition);
}
catch (Exception e) { }
if (state.Type == PD_StateTypes.SendState)
{
newSwitch.Default = nodeList[transitions[0].Target];
}
else if (state.Type == PD_StateTypes.ReceiveState)
{
foreach (var t in transitions)
{
newSwitch.Cases.Add(receiveTranstionToString(process, (PD_ReceiveTransition)t), nodeList[t.Target]);
}
}
else
{
foreach (var t in transitions)
{
newSwitch.Cases.Add(((PD_RegularTransition)t).Name, nodeList[t.Target]);
}
}
}
}
}
ActivityBuilder builder = new ActivityBuilder();
builder.Name = "strICT.InFlowTest.WFProcesses." + process.Name + "." + subject.Name;
builder.Implementation = flow;
VisualBasic.SetSettings(builder, new VisualBasicSettings());
//StringBuilder sb = new StringBuilder();
StringWriterUtf8 stream = new StringWriterUtf8();
XamlWriter writer = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(stream, new XamlSchemaContext()));
XamlServices.Save(writer, builder);
string res = stream.GetStringBuilder().ToString();
res = res.Replace("<?xml version=\"1.0\" encoding=\"utf-8\"?>", "");
return res;
}
public void WorkflowDesignerViewModel_UnitTest_ViewModelModelChanged_ExpectMarksResourceIsWorkflowSavedFalse()
{
var ok = true;
var msg = string.Empty;
var t = new Thread(() =>
{
try
{
#region Setup viewModel
var workflow = new ActivityBuilder();
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(r => r.ResourceName).Returns("Test");
StringBuilder xamlBuilder = new StringBuilder(StringResources.xmlServiceDefinition);
resourceModel.Setup(res => res.WorkflowXaml).Returns(xamlBuilder);
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
workflowHelper.Setup(h => h.SanitizeXaml(It.IsAny<StringBuilder>())).Returns(xamlBuilder);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
//viewModel.InitializeDesigner(new Dictionary<Type, Type>());
#endregion
#region setup Mock ModelItem
var properties = new Dictionary<string, Mock<ModelProperty>>();
var propertyCollection = new Mock<ModelPropertyCollection>();
var environmentRepository = SetupEnvironmentRepo(Guid.Empty); // Set the active environment
var testAct = DsfActivityFactory.CreateDsfActivity(resourceModel.Object, new DsfActivity(), true, environmentRepository, true);
var prop = new Mock<ModelProperty>();
prop.Setup(p => p.SetValue(It.IsAny<DsfActivity>())).Verifiable();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Action", prop);
propertyCollection.Protected().Setup<ModelProperty>("Find", "Action", true).Returns(prop.Object);
var source = new Mock<ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
source.Setup(s => s.ItemType).Returns(typeof(FlowStep));
#endregion
#region setup mock to change properties
//mock item adding - this is obsolote functionality but not refactored due to overhead
var args = new Mock<ModelChangedEventArgs>();
#pragma warning disable 618
args.Setup(a => a.ItemsAdded).Returns(new List<ModelItem> { source.Object });
#pragma warning restore 618
#endregion
//Execute
viewModel.TestWorkflowDesignerModelChangedWithNullSender();
viewModel.Dispose();
//Verify
prop.Verify(p => p.SetValue(It.IsAny<DsfActivity>()), Times.Never());
Assert.IsFalse(resourceModel.Object.IsWorkflowSaved);
}
catch (Exception e)
{
ok = false;
msg = e.Message + " -> " + e.StackTrace;
}
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
Assert.IsTrue(ok, msg);
}
public static IEnumerable<DynamicActivityProperty> GetArgument(ActivityBuilder designerBuilder)
{
foreach (DynamicActivityProperty prop in designerBuilder.Properties)
{
if (typeof(Argument).IsAssignableFrom(prop.Type))
{
yield return prop;
}
}
}
static void Verify_DebugSelectionChanged(ActivitySelectionType selectionType, Type selectedActivityType, bool selectsModelItem = true)
{
//----------------------- Setup -----------------------//
var ID = Guid.NewGuid();
var states = new List<IDebugState> { new DebugState { DisplayName = "SelectionChangedTest1", ID = ID, WorkSurfaceMappingId = ID } };
ID = Guid.NewGuid();
if (selectionType == ActivitySelectionType.Add || selectionType == ActivitySelectionType.Remove)
{
states.Add(new DebugState { DisplayName = "SelectionChangedTest2", ID = ID, WorkSurfaceMappingId = ID });
}
#region Setup workflow
FlowNode prevNode = null;
var nodes = new List<FlowNode>();
foreach (var node in states.Select(state => CreateFlowNode(state.ID, state.DisplayName, selectsModelItem, selectedActivityType)))
{
if (prevNode != null)
{
var flowStep = prevNode as FlowStep;
if (flowStep != null)
{
flowStep.Next = node;
}
}
nodes.Add(node);
prevNode = node;
}
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = nodes[0]
}
};
#endregion
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 5");
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
#endregion
//----------------------- Execute -----------------------//
var i = 0;
foreach (var debugState in states)
{
if (selectionType == ActivitySelectionType.None || selectionType == ActivitySelectionType.Remove)
{
// Ensure we have something to clear/remove
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = debugState, SelectionType = ActivitySelectionType.Add });
// Only issue change event after all have been added
if (++i == states.Count)
{
var selectionBefore = viewModel.Designer.Context.Items.GetValue<Selection>();
Assert.AreEqual(states.Count, selectionBefore.SelectionCount);
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = debugState, SelectionType = selectionType });
}
}
else
{
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = debugState, SelectionType = selectionType });
}
}
//----------------------- Assert -----------------------//
var selection = viewModel.Designer.Context.Items.GetValue<Selection>();
switch (selectionType)
{
case ActivitySelectionType.None:
Assert.AreEqual(0, selection.SelectionCount);
Assert.AreEqual(1, viewModel.BringIntoViewHitCount); // 1 because we had to add something first!
Assert.AreEqual(0, viewModel.SelectedDebugModelItems.Count);
break;
case ActivitySelectionType.Single:
Assert.AreEqual(1, selection.SelectionCount);
Assert.AreEqual(1, viewModel.BringIntoViewHitCount);
Assert.AreEqual(1, viewModel.SelectedDebugModelItems.Count);
break;
case ActivitySelectionType.Add:
Assert.AreEqual(2, selection.SelectionCount);
Assert.AreEqual(2, viewModel.BringIntoViewHitCount);
Assert.AreEqual(2, viewModel.SelectedDebugModelItems.Count);
break;
case ActivitySelectionType.Remove:
Assert.AreEqual(2, selection.SelectionCount);
Assert.AreEqual(2, viewModel.BringIntoViewHitCount); // 2 because we had to add something first!
Assert.AreEqual(1, viewModel.SelectedDebugModelItems.Count);
break;
}
foreach (var modelItem in selection.SelectedObjects)
{
Assert.AreEqual(selectedActivityType, modelItem.ItemType);
if (selectsModelItem)
{
var actualID = selectedActivityType == typeof(FlowDecision)
? Guid.Parse(((TestDecisionActivity)modelItem.GetProperty("Condition")).UniqueID)
: ModelItemUtils.GetUniqueID(modelItem);
var actualState = states.FirstOrDefault(s => s.ID == actualID);
Assert.IsNotNull(actualState);
}
}
viewModel.Dispose();
}
private static void CreateUpdateMaps(ActivityBuilder wf, string name)
{
// Create the UpdateMap.
DynamicUpdateMap map = DynamicUpdateServices.CreateUpdateMap(wf);
// Serialize it to a file.
string path = Path.Combine(mapPath, name);
DataContractSerializer sz = new DataContractSerializer(typeof(DynamicUpdateMap));
using (FileStream fs = System.IO.File.Open(path, FileMode.Create))
{
sz.WriteObject(fs, map);
}
}
