// ReSharper disable UnusedParameter.Global
protected static IDictionary <string, object> RunActivity(ActivityImplementationBase activity, IDictionary <string, object> inputs, bool expectedToComplete = true)
// ReSharper restore UnusedParameter.Global
{
Assert.IsFalse(activity is WorkflowImplementation, "Dont use RunActivity to run a workflow, use WorkflowRunner.Instance.");
var invoker = new WorkflowInvoker();
// invoker.RunStateFactory = new TestRunStateFactory();
var workflowRun = ActivityTestHelper.CreateWfRunForActivity(activity);
workflowRun.Name = "Dummy Run" + DateTime.Now;
var convertedInputs = new ActivityInputs(activity.ActivityInstance.GetInputArguments(), inputs);
var factory = new TestRunStateFactory();
// var runState = Factory.Current.Resolve<IRunStateFactory>().CreateRunState(new WorkflowMetadata(), workflowRun);
var runState = factory.CreateRunState(new WorkflowMetadata(), workflowRun);
runState.CurrentActivity = activity.ActivityInstance;
bool hasCompleted = activity.Execute(runState, convertedInputs);
if (expectedToComplete && !hasCompleted)
{
Assert.Fail("Unfinished activity");
}
return(runState.GetResult(activity.ActivityInstance.GetOutputArguments()));
}
public void SendMailWithConfigAction(Action <Workflow, WfActivity> configurationAction, IEmailSender emailSender)
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var emailAction = new SendEmailActivity( );
var emailActionAs = emailAction.Cast <WfActivity>( );
var wf = new Workflow
{
Name = "Wf"
};
wf.AddDefaultExitPoint( );
wf.ContainedActivities.Add(emailActionAs);
wf.FirstActivity = emailActionAs;
configurationAction(wf, emailActionAs);
ActivityTestHelper.AddTermination(wf, emailActionAs);
wf.Save( );
ToDelete.Add(wf.Id);
using (var scope = Factory.Current.BeginLifetimeScope(builder =>
{
builder.RegisterInstance <IEmailSender>(emailSender);
}))
using (Factory.SetCurrentScope(scope))
{
var wfRun = TestBase.RunWorkflow(wf);
Assert.That(wfRun.WorkflowRunStatus_Enum, Is.EqualTo(WorkflowRunState_Enumeration.WorkflowRunCompleted));
}
}
}
public void SendMailUsingRecipientList()
{
string subject = "Subject " + Guid.NewGuid().ToString();
string body = "Body " + Guid.NewGuid().ToString();
var emailSenderMock = new Mock <IEmailSender>();
emailSenderMock
.Setup(m => m.SendMessages(It.IsAny <IReadOnlyCollection <MailMessage> >()))
.Callback <IReadOnlyCollection <MailMessage> >(x =>
{
var emails = x.ToList();
Assert.True(emails.Count == 1);
Assert.True(emails[0].Subject == subject);
Assert.True(emails[0].Body == body);
Assert.True(emails[0].To.Count > 1);
Assert.True(emails[0].CC.Count == 0);
Assert.True(emails[0].Bcc.Count == 0);
Assert.True(emails[0].Attachments.Count == 0);
});
Action <Workflow, WfActivity> configurationCallback = (wf, emailActionAs) =>
{
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Email To", new EntityRef("core:sendEmailActivityRecipientsList"));
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Send As", new EntityRef("core:sendEmailActivityGroupDistribution"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Recipients List", "all(Employee_Test)", false);
ActivityTestHelper.SetActivityArgumentToResource(wf, emailActionAs, "TO Address Field", Entity.Get <Resource>("oldshared:workEmail"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Subject", $"'{subject}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Body", $"'{body}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "No Reply", "true", false);
};
SendMailWithConfigAction(configurationCallback, emailSenderMock.Object);
}
public void ResourceVarWithEntityExpressionTest( )
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
Workflow workflow = CreateLoggingWorkflow("The workflow is {{TestResourceArg}}");
var resArg = new ResourceArgument
{
Name = "TestResourceArg"
};
ActivityTestHelper.AddVariableToWorkflow(workflow, resArg.Cast <ActivityArgument>());
workflow.AddEntityExpressionToVariable("TestResourceArg", workflow);
workflow.Save();
ToDelete.Add(workflow.Id);
var run = (RunWorkflow(workflow));
Assert.IsTrue(run.WorkflowRunStatus_Enum == WorkflowRunState_Enumeration.WorkflowRunCompleted, "Run Completed");
}
}
public void SendMailUsingAddressesWithBadAddress()
{
string subject = "Subject " + Guid.NewGuid().ToString();
string body = "Body " + Guid.NewGuid().ToString();
var emailSenderMock = new Mock <IEmailSender>();
emailSenderMock
.Setup(m => m.SendMessages(It.IsAny <IReadOnlyCollection <MailMessage> >()))
.Callback <IReadOnlyCollection <MailMessage> >(x =>
{
var emails = x.ToList();
Assert.True(emails.Count == 1);
Assert.True(emails[0].Subject == subject);
Assert.True(emails[0].Body == body);
Assert.True(emails[0].To.Count == 2);
Assert.True(ContainsAddress(emails[0].To, "*****@*****.**"));
Assert.True(ContainsAddress(emails[0].To, "*****@*****.**"));
Assert.True(emails[0].CC.Count == 0);
Assert.True(emails[0].Bcc.Count == 0);
Assert.True(emails[0].Attachments.Count == 0);
});
Action <Workflow, WfActivity> configurationCallback = (wf, emailActionAs) =>
{
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Email To", new EntityRef("core:sendEmailActivityRecipientsAddress"));
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Send As", new EntityRef("core:sendEmailActivityGroupDistribution"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "To Addresses", "'[email protected]; NotAnEmailAddress.com; [email protected]'");
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Subject", $"'{subject}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Body", $"'{body}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "No Reply", "true", false);
};
SendMailWithConfigAction(configurationCallback, emailSenderMock.Object);
}
public static Workflow AddOutput <T>(this Workflow wf, string name, EntityType conformsToType = null) where T : IEntity, new()
{
var myVarAs = CreateActivityArg <T>(wf, name, null, conformsToType);
ActivityTestHelper.AddOutputToWorkflow(wf, myVarAs);
return(wf);
}
public void Test_AddExpressionParameter_unique_names_are_generated( )
{
var wf = Entity.Create <Workflow>( );
var log = Entity.Create <WfActivity>( );
wf.ContainedActivities.Add(log);
var messageArg = Entity.Get <ActivityArgument>("inLogActivityMessage");
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
ActivityTestHelper.CreateArgumentInstance(wf, log, messageArg);
Assert.AreEqual(12, wf.ExpressionParameters.Count( ), "Ensure all the parameters were added.");
Assert.AreEqual(
wf.ExpressionParameters.Count( ),
wf.ExpressionParameters.Select(p => p.Name).Distinct( ).Count( ),
"Ensure every parameter has a unique name");
}
public void TestLoopOverNoResultsInExpression()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var wf = new Workflow();
wf.AddDefaultExitPoint();
var forEach1 = new ForEachResource
{
Name = "foreach1" + DateTime.Now
};
var forEach1As = forEach1.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, forEach1As, "List", "all([Workflow Run State]) where Name='Wibble wobble bob'"); // there shouldn't be any
wf.FirstActivity = forEach1As;
wf.ContainedActivities.Add(forEach1As);
var loopExitPoint = Entity.Get <ExitPoint>(ForeachImplementation.LoopExitPointAlias);
ActivityTestHelper.AddTransition(wf, forEach1As, forEach1As, loopExitPoint);
ActivityTestHelper.AddTermination(wf, forEach1As);
wf.Save();
ToDelete.Add(wf.Id);
var run = (RunWorkflow(wf));
IDictionary <string, object> outputs = run.GetOutput();
}
}
public static Workflow AddEntityExpressionToVariable(this Workflow wf, string argumentName, EntityRef entityRef)
{
var destination = wf.Variables.First(v => v.Name == argumentName);
ActivityTestHelper.AddEntityExpression(wf, wf.As <WfActivity>(), destination, entityRef);
return(wf);
}
public static Workflow AddVariable <T>(this Workflow wf, string name, string expression = null, EntityType conformsToType = null) where T : IEntity, new()
{
var myVarAs = CreateActivityArg <T>(wf, name, expression, conformsToType);
ActivityTestHelper.AddVariableToWorkflow(wf, myVarAs);
return(wf);
}
public void ProxyCallingItself_bug_17649()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
// Inner Workflow
var wf = new Workflow
{
Name = "ProxyCallingItself_bug_17649 " + DateTime.Now
};
var isInnerArg = new BoolArgument()
{
Name = "Is Inner"
}.As <ActivityArgument>();
wf.InputArguments.Add(isInnerArg);
wf.AddDefaultExitPoint();
var decision = new DecisionActivity()
{
Name = "Is Inner"
};
var decisionAs = decision.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, decisionAs, "DecisionArgument", "[Is Inner]", false);
wf.FirstActivity = decisionAs;
wf.ContainedActivities.Add(decisionAs);
WorkflowProxy innerProxy = ActivityTestHelper.CreateWorkflowProxy(wf);
var innerProxyAs = innerProxy.As <WfActivity>();
wf.ContainedActivities.Add(innerProxyAs);
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
ActivityTestHelper.AddExpressionToActivityArgument(wf, innerProxyAs, "Is Inner", "true", false);
ActivityTestHelper.AddTransition(wf, decisionAs, innerProxyAs, "No");
ActivityTestHelper.AddTermination(wf, innerProxyAs);
ActivityTestHelper.AddTermination(wf, decisionAs, "Yes");
wf.Save();
ToDelete.Add(wf.Id);
wf.Validate();
var input = new Dictionary <string, object>()
{
{ "Is Inner", true }
};
var run = (RunWorkflow(wf, input));
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum, "Finished without errors");
}
}
public void SendMailWithAttachments()
{
string subject = "Subject " + Guid.NewGuid().ToString();
string body = "Body " + Guid.NewGuid().ToString();
string tempHash = null;
var buff = Encoding.UTF8.GetBytes("Email Attachment File " + CryptoHelper.GetRandomPrintableString(10));
using (MemoryStream stream = new MemoryStream(buff))
{
tempHash = Factory.DocumentFileRepository.Put(stream);
}
var file = Entity.Create <Document>();
file.Name = "Email Attachment Test File";
file.Description = "Send Email Attachment Test";
file.FileDataHash = tempHash;
file.Size = buff.Length;
file.FileExtension = "txt";
file.Save();
var emailSenderMock = new Mock <IEmailSender>();
emailSenderMock
.Setup(m => m.SendMessages(It.IsAny <IReadOnlyCollection <MailMessage> >()))
.Callback <IReadOnlyCollection <MailMessage> >(x =>
{
var emails = x.ToList();
Assert.True(emails.Count == 1);
Assert.True(emails[0].To.Count == 2);
Assert.True(ContainsAddress(emails[0].To, "*****@*****.**"));
Assert.True(ContainsAddress(emails[0].To, "*****@*****.**"));
Assert.True(emails[0].CC.Count == 0);
Assert.True(emails[0].Bcc.Count == 0);
Assert.True(emails[0].Attachments.Count == 1);
Assert.True(emails[0].Attachments[0].ContentStream.Length == buff.Length);
});
Action <Workflow, WfActivity> configurationCallback = (wf, emailActionAs) =>
{
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Email To", new EntityRef("core:sendEmailActivityRecipientsAddress"));
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Send As", new EntityRef("core:sendEmailActivityGroupDistribution"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "To Addresses", "'[email protected]; [email protected]'");
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Subject", $"'{subject}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Body", $"'{body}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "No Reply", "true", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Attachments", file.Cast <Resource>().ToEnumerable());
};
SendMailWithConfigAction(configurationCallback, emailSenderMock.Object);
file.Delete();
}
public static Workflow AddExpressionToWorkflowVariable(this Workflow wf, string argumentName, string expressionString, bool isTemplate = false)
{
var destination = wf.Variables.FirstOrDefault(v => v.Name == argumentName);
if (destination == null)
{
throw new ArgumentException(String.Format("No matching variable name for workflow. Workflow='{0}' Argument='{1}'", wf.Name ?? "<unnamed>", argumentName ?? "<unnamed>"));
}
ActivityTestHelper.AddExpressionToArgument(wf, wf.Cast <WfActivity>(), destination, expressionString, isTemplate);
return(wf);
}
public void TestLoopOverNoResultsFromGetRelationship()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var myType = new EntityType {
Name = "MyType"
};
myType.Save();
ToDelete.Add(myType.Id);
var wf = new Workflow {
Name = "TestLoopOverNoResultsFromGetRelationship"
};
wf.AddDefaultExitPoint();
var getResources = new GetResourcesActivity {
Name = "GetResources"
};
var getResourcesAs = getResources.As <WfActivity>();
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, getResourcesAs, "Object", myType); // this type has no instances
wf.FirstActivity = getResourcesAs;
wf.ContainedActivities.Add(getResourcesAs);
var forEach1 = new ForEachResource
{
Name = "foreach1" + DateTime.Now
};
var forEach1As = forEach1.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, forEach1As, "List", "[List]"); // there shouldn't be any
wf.ContainedActivities.Add(forEach1As);
ActivityTestHelper.AddTransition(wf, getResourcesAs, forEach1As);
ActivityTestHelper.AddTransition(wf, forEach1As, forEach1As, "Loop");
ActivityTestHelper.AddTermination(wf, forEach1As, "Finished");
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
ToDelete.Add(wf.Id);
var run = RunWorkflow(wf);
IDictionary <string, object> outputs = run.GetOutput();
}
}
public void SendMailUsingAddressesFromInbox()
{
string subject = "Subject " + Guid.NewGuid().ToString();
string body = "Body " + Guid.NewGuid().ToString();
var inbox = new Inbox()
{
Name = "Test Inbox 1", InboxEmailAddress = "*****@*****.**"
};
inbox.Save();
var emailSenderMock = new Mock <IEmailSender>();
emailSenderMock
.Setup(m => m.SendMessages(It.IsAny <IReadOnlyCollection <MailMessage> >()))
.Callback <IReadOnlyCollection <MailMessage> >(x =>
{
var emails = x.ToList();
Assert.True(emails.Count == 1);
Assert.True(emails[0].Subject == subject);
Assert.True(emails[0].Body == body);
Assert.True(emails[0].To.Count == 1);
Assert.True(ContainsAddress(emails[0].To, "*****@*****.**"));
Assert.True(emails[0].CC.Count == 1);
Assert.True(ContainsAddress(emails[0].CC, "*****@*****.**"));
Assert.True(emails[0].Bcc.Count == 1);
Assert.True(ContainsAddress(emails[0].Bcc, "*****@*****.**"));
Assert.True(emails[0].Attachments.Count == 0);
Assert.True(emails[0].From.DisplayName == inbox.Name);
Assert.True(emails[0].From.Address == inbox.InboxEmailAddress);
});
Action <Workflow, WfActivity> configurationCallback = (wf, emailActionAs) =>
{
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Email To", new EntityRef("core:sendEmailActivityRecipientsAddress"));
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Send As", new EntityRef("core:sendEmailActivityGroupDistribution"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "To Addresses", "'*****@*****.**'");
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "CC Addresses", "'*****@*****.**'");
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "BCC Addresses", "'*****@*****.**'");
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Subject", $"'{subject}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "Body", $"'{body}'", false);
ActivityTestHelper.AddExpressionToActivityArgument(wf, emailActionAs, "No Reply", "false", false);
ActivityTestHelper.AddEntityExpressionToInputArgument(wf, emailActionAs, "Reply to Inbox", new EntityRef(inbox));
};
SendMailWithConfigAction(configurationCallback, emailSenderMock.Object);
inbox.Delete();
}
public static Workflow AddWorkflowProxy(this Workflow wf, string name, Workflow wfToProxy, string fromNamed = null, string fromExit = null)
{
var proxy = ActivityTestHelper.CreateWorkflowProxy(wfToProxy);
proxy.Name = name;
var proxyAs = proxy.As <WfActivity>();
wf.AddActivity(proxyAs, fromNamed, fromExit);
AddMissingExpressionParametersToWorkflow(wf);
return(wf);
}
public void TestRun( )
{
var wf = new Workflow
{
Name = "Wf"
};
wf.AddDefaultExitPoint( );
var l1 = new LogActivity
{
Name = "l1"
}.Cast <WfActivity>( );
var l2 = new LogActivity
{
Name = "12"
}.Cast <WfActivity>( );
// wf.FirstActivity = l1;
//wf.ContainedActivities.Add(l1);
wf.ContainedActivities.Add(l2);
ActivityTestHelper.AddFirstActivityWithMapping(wf, l1, null);
ActivityTestHelper.AddExpressionToActivityArgument(wf, l1, "Message", "'Message 1'", false);
ActivityTestHelper.AddTransition(wf, l1, l2);
ActivityTestHelper.AddExpressionToActivityArgument(wf, l2, "Message", "'Message 2'", false);
ActivityTestHelper.AddTermination(wf, l2, l2.GetDefaultExitPoint(), CreateDefaultExitPoint());
wf.Save( );
ActivityImplementationBase nextActivity = wf.Cast <WfActivity>( ).CreateWindowsActivity( );
l1.Save( );
l2.Save( );
ToDelete.Add(wf.Id);
ToDelete.Add(l1.Id);
ToDelete.Add(l2.Id);
var run = (RunWorkflow(wf));
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum, "Finished without errors");
// run using service
}
public void TestTwoActivitiesRunInCorrectOrder( )
{
// Check that the activities are running in the correct order.
var runLog = new List <long>( );
RunActionWithNameActivity.Action = runLog.Add;
ActivityType testType = CreateClassBackedType(typeof(RunActionWithNameActivity));
var wf = new Workflow
{
Name = "Wf"
};
wf.AddDefaultExitPoint( );
var l1 = new Entity(testType.Id).Cast <WfActivity>( );
var l2 = new Entity(testType.Id).Cast <WfActivity>( );
l1.Name = "l1";
l2.Name = "l2";
ActivityTestHelper.AddFirstActivityWithMapping(wf, l1, null);
wf.ContainedActivities.Add(l2);
ActivityTestHelper.AddTransition(wf, l1, l2);
ActivityTestHelper.AddTermination(wf, l2);
wf.Save( );
ToDelete.Add(wf.Id);
var run = (RunWorkflow(wf));
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum, "Finished without errors");
var expectedOrder = new List <long>
{
l1.Id,
l2.Id
};
Assert.AreEqual(expectedOrder, runLog);
}
/// <summary>
/// Add a delete activity
/// </summary>
public static Workflow AddDelete(this Workflow wf, string name, string resourceExpression = null, string fromNamed = null, string fromExit = null)
{
var uf = new DeleteActivity()
{
Name = name
};
var ufAs = uf.As <WfActivity>();
if (resourceExpression != null)
{
ActivityTestHelper.AddExpressionToActivityArgument(wf, ufAs, "Record", resourceExpression, false);
}
wf.AddActivity(ufAs, fromNamed, fromExit);
AddMissingExpressionParametersToWorkflow(wf);
return(wf);
}
private static ActivityArgument CreateActivityArg <T>(Workflow wf, string name, string expression, EntityType conformsToType) where T : IEntity, new()
{
var myVar = new T();
myVar.SetField("name", name);
if (conformsToType != null)
{
var typedVar = myVar.As <TypedArgument>();
typedVar.ConformsToType = conformsToType;
}
var myVarAs = myVar.As <ActivityArgument>();
if (expression != null)
{
ActivityTestHelper.AddExpressionToArgument(wf, wf.Cast <WfActivity>(), myVarAs, expression, false);
}
return(myVarAs);
}
/// <summary>
/// Add a get records activity
/// </summary>
public static Workflow AddGetRecords(this Workflow wf, string name, string definitionExpression, string reportExpression = null, string fromNamed = null, string fromExit = null)
{
var act = new GetResourcesActivity()
{
Name = name
};
var actAs = act.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, actAs, "Object", definitionExpression, false);
if (reportExpression != null)
{
ActivityTestHelper.AddExpressionToActivityArgument(wf, actAs, "Report", reportExpression, false);
}
wf.AddActivity(actAs, fromNamed, fromExit);
AddMissingExpressionParametersToWorkflow(wf);
return(wf);
}
/// <summary>
///
/// </summary>
/// <param name="fieldAliasExpressionPairs">An array of field-alias, expression pairs</param>
public static Workflow AddUpdate(this Workflow wf, string name, string resourceExpression, string[] fieldAliasExpressionPairs,
string fromNamed = null, string fromExit = null)
{
var update = new UpdateFieldActivity()
{
Name = name
};
var updateAs = update.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, updateAs, "Record", resourceExpression, false);
wf.AddActivity(updateAs, fromNamed, fromExit);
var count = 0;
for (int i = 0; i < fieldAliasExpressionPairs.Count(); i += 2)
{
var argName = "input" + count++;
var argValueName = argName + "_value";
var result1 = (new StringArgument()
{
Name = argName
}).As <ActivityArgument>();;
update.InputArguments.Add(result1);
AddExpressionToActivityArgument(wf, updateAs, argName, fieldAliasExpressionPairs[i]);
var result2 = (new ObjectArgument {
Name = argValueName
}).As <ActivityArgument>();
update.InputArguments.Add(result2);
AddExpressionToActivityArgument(wf, updateAs, argValueName, fieldAliasExpressionPairs[i + 1]);
}
AddMissingExpressionParametersToWorkflow(wf);
return(wf);
}
public static Workflow AddActivity(this Workflow wf, WfActivity activity, string fromNamed = null, string fromExit = null, bool dontTerminate = false)
{
if (fromNamed != null)
{
var from = wf.ContainedActivities.First(a => a.Name == fromNamed);
ActivityTestHelper.AddTransition(wf, from, activity, fromExit);
}
else
{
if (wf.ContainedActivities.Count > 0)
{
var oldLast = wf.ContainedActivities.First(a => a.ForwardTransitions.Any(t => t.Is <Termination>())).AsWritable <WfActivity>();
var term = oldLast.ForwardTransitions.First(t => t.Is <Termination>()).AsWritable <TransitionStart>();
var oldExitPoint = term.FromExitPoint;
oldLast.ForwardTransitions.Remove(term);
wf.Terminations.Remove(term.As <Termination>());
term.Delete();
ActivityTestHelper.AddTransition(wf, oldLast, activity, oldExitPoint);
}
else
{
wf.FirstActivity = activity;
}
}
wf.ContainedActivities.Add(activity);
if (!dontTerminate)
{
ActivityTestHelper.AddTermination(wf, activity);
}
return(wf);
}
public void TestInputVarNotSet()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var wf = new Workflow();
wf.AddDefaultExitPoint();
var forEach1 = new ForEachResource
{
Name = "foreach1" + DateTime.Now
};
var forEach1As = forEach1.As <WfActivity>();
wf.FirstActivity = forEach1As;
wf.ContainedActivities.Add(forEach1As);
var loopExitPoint = Entity.Get <ExitPoint>(ForeachImplementation.LoopExitPointAlias);
ActivityTestHelper.AddTransition(wf, forEach1As, forEach1As, loopExitPoint);
ActivityTestHelper.AddTermination(wf, forEach1As);
//ActivityHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
ToDelete.Add(wf.Id);
ActivityImplementationBase nextActivity = forEach1As.Cast <WfActivity>().CreateWindowsActivity();
var metaData = new WorkflowMetadata();
nextActivity.Validate(metaData);
Assert.IsTrue(metaData.ValidationMessages.Count() == 1, "There is only one validation message");
Assert.IsTrue(metaData.ValidationMessages.First().StartsWith("Mandatory argument"), "Validation is 'Mandatory argument'");
}
}
public void TestMultipleNestedWorkflowActivities_Bug_24928()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
Workflow wfA = null, wfB = null, wfC = null, wfD = null;
#region Arrange
var exitA = Entity.Create <ExitPoint>();
exitA.Name = "TEST Exit A";
exitA.IsDefaultExitPoint = true;
exitA.Save();
var exitB = Entity.Create <ExitPoint>();
exitB.Name = "TEST Exit B";
exitB.IsDefaultExitPoint = true;
exitB.Save();
var exitC = Entity.Create <ExitPoint>();
exitC.Name = "TEST Exit C";
exitC.IsDefaultExitPoint = true;
exitC.Save();
var exitD = Entity.Create <ExitPoint>();
exitD.Name = "TEST Exit D";
exitD.IsDefaultExitPoint = true;
exitD.Save();
wfA = Entity.Create <Workflow>();
wfA.Name = "TEST WF A";
wfA.ExitPoints.Add(exitA);
var logA = Entity.Create <LogActivity>().As <WfActivity>();
logA.Name = "TEST Log A";
wfA.AddActivity(logA);
ActivityTestHelper.AddExpressionToActivityArgument(wfA, logA, "Message", "'WF A'");
wfA.Save();
wfB = Entity.Create <Workflow>();
wfB.Name = "TEST WF B";
wfB.ExitPoints.Add(exitB);
var logB = Entity.Create <LogActivity>().As <WfActivity>();
logB.Name = "TEST Log B";
wfB.AddActivity(logB);
ActivityTestHelper.AddExpressionToActivityArgument(wfB, logB, "Message", "'WF B'");
wfB.Save();
wfC = Entity.Create <Workflow>();
wfC.Name = "TEST WF C";
wfC.ExitPoints.Add(exitC);
var proxyA = Entity.Create <WorkflowProxy>();
proxyA.Name = "TEST Run WF A";
proxyA.WorkflowToProxy = wfA;
var exitProxyA = Entity.Create <ExitPoint>();
exitProxyA.Name = "TEST Exit A";
exitProxyA.IsDefaultExitPoint = true;
proxyA.ExitPoints.Add(exitProxyA);
wfC.AddActivity(proxyA.As <WfActivity>());
var logCa = Entity.Create <LogActivity>().As <WfActivity>();
logCa.Name = "TEST Log C A";
wfC.AddActivity(logCa);
ActivityTestHelper.AddExpressionToActivityArgument(wfC, logCa, "Message", "'WF C A'");
var proxyB = Entity.Create <WorkflowProxy>();
proxyB.Name = "TEST Run WF B";
proxyB.WorkflowToProxy = wfB;
var exitProxyB = Entity.Create <ExitPoint>();
exitProxyB.Name = "TEST Exit B";
exitProxyB.IsDefaultExitPoint = true;
proxyB.ExitPoints.Add(exitProxyB);
wfC.AddActivity(proxyB.As <WfActivity>());
var logCb = Entity.Create <LogActivity>().As <WfActivity>();
logCb.Name = "TEST Log C B";
wfC.AddActivity(logCb);
ActivityTestHelper.AddExpressionToActivityArgument(wfC, logCb, "Message", "'WF C B'");
wfC.Save();
wfD = Entity.Create <Workflow>();
wfD.Name = "TEST WF D";
wfD.ExitPoints.Add(exitD);
var proxyA2 = Entity.Create <WorkflowProxy>();
proxyA2.Name = "TEST Run WF A";
proxyA2.WorkflowToProxy = wfA;
var exitProxyA2 = Entity.Create <ExitPoint>();
exitProxyA2.Name = "TEST Exit A";
exitProxyA2.IsDefaultExitPoint = true;
proxyA2.ExitPoints.Add(exitProxyA2);
wfD.AddActivity(proxyA2.As <WfActivity>());
var logDa = Entity.Create <LogActivity>().As <WfActivity>();
logDa.Name = "TEST Log D A";
wfD.AddActivity(logDa);
ActivityTestHelper.AddExpressionToActivityArgument(wfD, logDa, "Message", "'WF D A'");
var proxyB2 = Entity.Create <WorkflowProxy>();
proxyB2.Name = "TEST Run WF B";
proxyB2.WorkflowToProxy = wfB;
var exitProxyB2 = Entity.Create <ExitPoint>();
exitProxyB2.Name = "TEST Exit B";
exitProxyB2.IsDefaultExitPoint = true;
proxyB2.ExitPoints.Add(exitProxyB2);
wfD.AddActivity(proxyB2.As <WfActivity>());
var logDb = Entity.Create <LogActivity>().As <WfActivity>();
logDb.Name = "TEST Log D B";
wfD.AddActivity(logDb);
ActivityTestHelper.AddExpressionToActivityArgument(wfD, logDb, "Message", "'WF D B'");
var proxyC = Entity.Create <WorkflowProxy>();
proxyC.Name = "TEST Run D C";
proxyC.WorkflowToProxy = wfC;
var exitProxyC = Entity.Create <ExitPoint>();
exitProxyC.Name = "TEST Exit C";
exitProxyC.IsDefaultExitPoint = true;
proxyC.ExitPoints.Add(exitProxyC);
wfD.AddActivity(proxyC.As <WfActivity>());
var logDc = Entity.Create <LogActivity>().As <WfActivity>();
logDc.Name = "TEST Log D C";
wfD.AddActivity(logDc);
ActivityTestHelper.AddExpressionToActivityArgument(wfD, logDc, "Message", "'WF D C'");
wfD.Save();
#endregion
// Act
WorkflowRun run;
using (new WorkflowRunContext(true))
{
run = RunWorkflow(wfD);
}
// Assert
run.Should().NotBeNull();
run.WorkflowRunStatus_Enum.Should().Be(WorkflowRunState_Enumeration.WorkflowRunCompleted);
run.Id.Should().Be(run.Id);
run.RunStepCounter.Should().Be(7);
}
}
public void LowAccessUserPausedPriorNestedWorkflow_bug_27863()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
Workflow myParentWorkflow = null;
Workflow myChildWorkflow = null;
UserAccount myUser = null;
Person myPerson = null;
PromptUserTask userInputTask = null;
try
{
myChildWorkflow = Entity.Create <Workflow>()
.AddDefaultExitPoint()
.AddInput <BoolArgument>("InputChild")
.AddLog("Child Log", "Child Log");
myChildWorkflow.Name = "Child Workflow 27863 " + DateTime.Now;
myChildWorkflow.WorkflowRunAsOwner = true;
myChildWorkflow.Save();
myParentWorkflow = Entity.Create <Workflow>()
.AddDefaultExitPoint()
.AddInput <BoolArgument>("InputParent")
.AddPromptUser("User Input")
.AddWorkflowProxy("Child Workflow", myChildWorkflow)
.AddLog("Parent Log", "Parent Log");
var childWorkflowActivity = myParentWorkflow.ContainedActivities.FirstOrDefault(a => a.Name == "Child Workflow");
ActivityTestHelper.AddExpressionToActivityArgument(myParentWorkflow, childWorkflowActivity, "InputChild", "[InputParent]");
myParentWorkflow.Name = "Parent Workflow 27863 " + DateTime.Now;
myParentWorkflow.WorkflowRunAsOwner = true;
myParentWorkflow.Save();
myPerson = Entity.Create <Person>();
myPerson.FirstName = "Billy";
myPerson.LastName = "Bob";
myUser = Entity.Create <UserAccount>();
myUser.Name = "bb" + DateTime.Now;
myUser.AccountHolder = myPerson;
myUser.Save();
new AccessRuleFactory().AddAllowByQuery(myUser.As <Subject>(),
Workflow.Workflow_Type.As <SecurableEntity>(),
new EntityRef("core:read").ToEnumerable(),
TestQueries.Entities(new EntityRef("core:workflow")).ToReport());
WorkflowRun run;
using (new SetUser(myUser))
using (new WorkflowRunContext(true)
{
RunTriggersInCurrentThread = true
})
{
run = RunWorkflow(myParentWorkflow);
}
run.WorkflowRunStatus_Enum.Should().Be(WorkflowRunState_Enumeration.WorkflowRunPaused);
run.PendingActivity.Should().NotBeNull();
run.PendingActivity.Name.Should().Be("User Input");
run.TaskWithinWorkflowRun.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(1);
userInputTask = run.TaskWithinWorkflowRun.First().AsWritable <PromptUserTask>();
userInputTask.Should().NotBeNull();
userInputTask.PromptForTaskStateInfo.Should().NotBeNull().And.HaveCount(1);
userInputTask.PromptForTaskStateInfo.Select(si => si.StateInfoArgument.Name).Should().Contain("InputParent");
var value = userInputTask.PromptForTaskStateInfo.First(si => si.StateInfoArgument.Name == "InputParent");
var param = value.StateInfoValue.AsWritable <BoolArgument>();
param.BoolParameterValue = true;
param.Save();
userInputTask.TaskStatus_Enum = TaskStatusEnum_Enumeration.TaskStatusCompleted;
userInputTask.UserTaskIsComplete = true;
using (new SetUser(myUser))
using (new WorkflowRunContext(true)
{
RunTriggersInCurrentThread = true
})
{
userInputTask.Save();
}
var wf = Entity.Get <Workflow>(myParentWorkflow.Id, Workflow.RunningInstances_Field);
wf.RunningInstances.Count().Should().Be(1);
var runResume = wf.RunningInstances.First();
Assert.IsTrue(WaitForWorkflowToStop(runResume), "Workflow run should have completed.");
runResume = Entity.Get <WorkflowRun>(runResume.Id, WorkflowRun.WorkflowRunStatus_Field);
runResume.Should().NotBeNull();
runResume.WorkflowRunStatus_Enum.Should().Be(WorkflowRunState_Enumeration.WorkflowRunCompleted);
runResume.RunLog.Should().NotBeNull().And.NotBeEmpty();
}
finally
{
if (userInputTask != null)
{
ToDelete.Add(userInputTask.Id);
}
if (myParentWorkflow != null)
{
ToDelete.Add(myParentWorkflow.Id);
}
if (myChildWorkflow != null)
{
ToDelete.Add(myChildWorkflow.Id);
}
if (myUser != null)
{
ToDelete.Add(myUser.Id);
}
if (myPerson != null)
{
ToDelete.Add(myPerson.Id);
}
}
}
}
public void SetVariableTest( )
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var workflow = new Workflow
{
Name = "Wf" + DateTime.Now
};
workflow.AddDefaultExitPoint();
var v1 = Entity.Create <IntegerArgument>().As <ActivityArgument>();
v1.Name = "v1";
ActivityTestHelper.AddVariableToWorkflow(workflow, v1);
var v2 = Entity.Create <ResourceArgument>().As <ActivityArgument>();
v2.Name = "v2";
ActivityTestHelper.AddVariableToWorkflow(workflow, v2);
var v3 = Entity.Create <ResourceListArgument>().As <ActivityArgument>();
v3.Name = "v3";
ActivityTestHelper.AddVariableToWorkflow(workflow, v3);
// set starting values
workflow.AddExpressionToWorkflowVariable("v1", "111", false);
workflow.AddEntityExpressionToVariable("v2", new EntityRef("core:person"));
//ActivityHelper.AddExpressionToWorkflowVariable(workflow, "v3", "[Resource Type]", false);
// assign 222 to v1
var setV1 = Entity.Create <AssignToVariable>();
var setV1As = setV1.Cast <WfActivity>();
setV1.TargetVariable = v1;
ActivityTestHelper.AddExpressionToActivityArgument(workflow, setV1As, "Value", "222", false);
workflow.FirstActivity = setV1As;
workflow.ContainedActivities.Add(setV1As);
ActivityTestHelper.AddTermination(workflow, setV1As);
// output
var v1Out = Entity.Create <StringArgument>();
var v1OutAs = v1Out.Cast <ActivityArgument>();
v1Out.Name = "v1Out";
workflow.OutputArguments.Add(v1OutAs);
ActivityTestHelper.AddAssignToVar(workflow, "set out", "'output is ' + v1", "v1Out");
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(workflow);
workflow.Save();
ToDelete.Add(workflow.Id);
var run = (RunWorkflow(workflow));
Assert.IsTrue(run.WorkflowRunStatus_Enum == WorkflowRunState_Enumeration.WorkflowRunCompleted, "Run Completed");
IDictionary <string, object> outputs = run.GetOutput();
Assert.IsTrue(outputs.ContainsKey("v1Out"), "Output has the result.");
Assert.AreEqual("output is 222", outputs["v1Out"], "Ensure the variable was updated and sent to the output");
}
}
public void DecisionTest()
{
var wf = new Workflow
{
Name = "ConnectingParameters Wf"
};
var wfAs = wf.Cast <WfActivity>();
wf.InputArguments.Add((new IntegerArgument
{
Name = "wfInInt"
}).Cast <ActivityArgument>());
var yesExit = new ExitPoint
{
IsDefaultExitPoint = true,
Name = "Yes"
};
var noExit = new ExitPoint
{
Name = "No"
};
wf.ExitPoints.Add(yesExit);
wf.ExitPoints.Add(noExit);
var decision1 = new DecisionActivity
{
Name = "Decision1"
};
var decision1As = decision1.Cast <WfActivity>();
ActivityTestHelper.AddFirstActivityWithMapping(
wf,
decision1As,
null);
string wfInIntSubString = ActivityTestHelper.CreateArgumentInstance(wf, wfAs, wfAs.GetInputArgument("wfInInt"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, decision1As, "DecisionArgument", wfInIntSubString + " > 5", false);
ActivityTestHelper.AddTermination(
wf,
decision1As,
Entity.Get <ExitPoint>(new EntityRef("core", "decisionActivityYesExitPoint")),
yesExit);
ActivityTestHelper.AddTermination(
wf,
decision1As,
Entity.Get <ExitPoint>(new EntityRef("core", "decisionActivityNoExitPoint")),
noExit);
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
ToDelete.Add(wf.Id);
ToDelete.Add(decision1.Id);
var input = new Dictionary <string, object>
{
{
"wfInInt", 10
}
};
var run = RunWorkflow(wf, input);
Assert.AreEqual(run.GetExitPoint().Id, yesExit.Id, "Input of '10' should result in a 'yes' decision");
input = new Dictionary <string, object>
{
{
"wfInInt", 1
}
};
run = RunWorkflow(wf, input);
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum, "Finished without errors");
Assert.AreEqual(noExit.Id, run.GetExitPoint().Id, "Input of '1' should results in a 'no' decision");
}
public static Workflow AddTermination(this Workflow wf, WfActivity activity, string fromExit = null, string toExit = null)
{
ActivityTestHelper.AddTermination(wf, activity, fromExit, toExit);
return(wf);
}
public void SwitchTest( )
{
var wf = new Workflow
{
Name = "ConnectingParameters Wf"
};
var wfAs = wf.Cast <WfActivity>( );
wf.InputArguments.Add((new StringArgument
{
Name = "wfInString"
}).Cast <ActivityArgument>( ));
var wfYesExit = new ExitPoint
{
IsDefaultExitPoint = true,
Name = "Wf Yes"
};
var wfNoExit = new ExitPoint
{
Name = "Wf No"
};
var wfMaybeExit = new ExitPoint
{
Name = "Wf Maybe"
};
var wfDontKnowExit = new ExitPoint
{
Name = "Wf Dont know"
};
wf.ExitPoints.Add(wfYesExit);
wf.ExitPoints.Add(wfNoExit);
wf.ExitPoints.Add(wfMaybeExit);
wf.ExitPoints.Add(wfDontKnowExit);
var switch1 = new SwitchActivity
{
Name = "Switch1"
};
var switch1As = switch1.Cast <WfActivity>( );
ActivityTestHelper.AddFirstActivityWithMapping(
wf,
switch1As,
null);
ActivityTestHelper.CreateArgumentInstance(wf, wfAs, wfAs.GetInputArgument("wfInString"));
ActivityTestHelper.AddExpressionToActivityArgument(wf, switch1As, "Value to Switch On", "wfInString", false);
var switchYesExit = new ExitPoint
{
IsDefaultExitPoint = true,
Name = "Yes"
};
var switchNoExit = new ExitPoint
{
Name = "No"
};
var switchMaybeExit = new ExitPoint
{
Name = "Maybe"
};
switch1.ExitPoints.Add(switchYesExit);
switch1.ExitPoints.Add(switchNoExit);
switch1.ExitPoints.Add(switchMaybeExit);
ActivityTestHelper.AddTermination(
wf,
switch1As,
switchYesExit,
wfYesExit);
ActivityTestHelper.AddTermination(
wf,
switch1As,
switchNoExit,
wfNoExit);
ActivityTestHelper.AddTermination(
wf,
switch1As,
switchMaybeExit,
wfMaybeExit);
var otherwiseExit = Entity.Get <ExitPoint>(new EntityRef("core", "switchActivityOtherwiseExitPoint"));
ActivityTestHelper.AddTermination(
wf,
switch1As,
otherwiseExit,
wfDontKnowExit);
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save( );
ToDelete.Add(wf.Id);
ToDelete.Add(switch1.Id);
TestResult(wf, "Yes", wfYesExit);
TestResult(wf, "No", wfNoExit);
TestResult(wf, "Maybe", wfMaybeExit);
TestResult(wf, "Something else", wfDontKnowExit);
}
