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 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 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 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 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 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
}
/// <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);
}
/// <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 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 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);
}
protected Workflow CreateDisplayFormTestWf(EntityRef priority, decimal?percentageComplete, bool?waitForNext, decimal?timeoutSeconds = null, bool?keepTask = null)
{
// moved this out to help with deadlocking issues when running the test.
Person dummyPerson = null;
UserAccount dummyAccount = null;
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
dummyPerson = Entity.Create <Person>();
var tag = Rand.Next().ToString();
dummyPerson.FirstName = "Dummy" + tag;
dummyPerson.LastName = "Dummy" + tag;
dummyPerson.Name = dummyPerson.FirstName + ' ' + dummyPerson.LastName;
dummyPerson.Save();
dummyAccount = Entity.Create <UserAccount>();
dummyAccount.Name = "Dummy" + DateTime.Now + Rand.Next();
dummyAccount.AccountHolder = dummyPerson;
dummyAccount.Save();
}
var displayFormWf = Entity.Create <Workflow>();
displayFormWf.Name = "Test approval Wf";
displayFormWf
.AddWfExitPoint("First Exit", true)
.AddWfExitPoint("Second Exit")
.AddWfExitPoint("Time-out")
.AddLog("log", "Test");
var displayForm = Entity.Create <DisplayFormActivity>();
displayForm.Name = "displayForm";
var displayFormAs = displayForm.Cast <WfActivity>();
var withExits = displayForm.Cast <EntityWithArgsAndExits>();
// add some exits
foreach (var name in new[]
{
"Option 1",
"Option 2"
})
{
var exitPoint = Entity.Create <ExitPoint>();
exitPoint.Name = name;
exitPoint.ExitPointActionSummary = name + " action summary";
exitPoint.IsDefaultExitPoint = name == "Option 1";
withExits.ExitPoints.Add(exitPoint);
}
displayFormWf.AddActivity(displayFormAs, dontTerminate: true);
var timeOutExitPoint = Entity.Get <ExitPoint>("core:displayFormTimeout");
displayFormWf
.AddEntityExpressionToInputArgument(displayFormAs, "Form", new EntityRef("test", "personForm"))
.AddEntityExpressionToInputArgument(displayFormAs, "Record", new EntityRef("test", "aaAaSriKorada"))
.AddEntityExpressionToInputArgument(displayFormAs, "For Person", dummyPerson);
if (timeoutSeconds != null)
{
var days = (double)timeoutSeconds / 60.0 / 60.0 / 24.0;
ActivityTestHelper.AddExpressionToActivityArgument(displayFormWf, displayFormAs, "Due in (Days)",
days.ToString(CultureInfo.InvariantCulture));
}
if (priority != null)
{
displayFormWf.AddEntityExpressionToInputArgument(displayFormAs, "Priority", priority);
}
if (percentageComplete != null)
{
displayFormWf.AddExpressionToActivityArgument(displayFormAs, "% Completed", percentageComplete.ToString());
}
if (waitForNext != null)
{
displayFormWf.AddExpressionToActivityArgument(displayFormAs, "Wait for next form", waitForNext.ToString());
}
if (keepTask != null)
{
displayFormWf.AddExpressionToActivityArgument(displayFormAs, "Record history", keepTask.ToString());
}
displayFormWf
.AddOutput <ResourceArgument>("UserTaskOutput")
.AddAssignToVar("AssignOutput", "[displayForm_Completed task]", "UserTaskOutput", "displayForm", "Option 2")
.AddTermination("displayForm", "Option 1", "First Exit")
.AddTermination("AssignOutput", null, "Second Exit")
.AddTermination("displayForm", timeOutExitPoint.Name, "Time-out");
//ActivityTestHelper.AddTermination(displayFormWf, displayFormAs, "Option 2", "Second Exit");
//ActivityTestHelper.AddTermination(displayFormWf, displayFormAs, timeOutExitPoint.Name, "Time-out");
displayFormWf.Save();
ToDelete.Add(displayFormWf.Id);
ToDelete.Add(dummyAccount.Id);
ToDelete.Add(dummyAccount.AccountHolder.Id);
return(displayFormWf);
}
public void TestDisplayFormDeleteInputParameter_Bug_25116()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
IEntity driver = null;
Workflow wf = null;
try
{
WorkflowRun run, run2;
#region Arrange
var driverType = new EntityRef("test", "driver");
driver = Entity.Create(driverType);
driver.SetField("core:name", "Test Delete Driver");
driver.Save();
wf = Entity.Create <Workflow>();
wf.Name = "TEST WF";
wf.AddDefaultExitPoint();
wf.AddInput <ResourceArgument>("Input", Entity.Get <EntityType>(driverType));
wf.InputArgumentForAction = wf.InputArguments.First();
var i = Entity.Create <WfExpression>();
i.ArgumentToPopulate = wf.InputArgumentForAction;
wf.ExpressionMap = new EntityCollection <WfExpression> {
i
};
wf.InputArgumentForAction.PopulatedByExpression = new EntityCollection <WfExpression> {
i
};
var uAExitA = Entity.Create <ExitPoint>();
uAExitA.Name = "Exit A";
uAExitA.ExitPointActionSummary = "Exit A action summary";
uAExitA.IsDefaultExitPoint = true;
uAExitA.Save();
var userActionA = Entity.Create <DisplayFormActivity>();
userActionA.Name = "A";
userActionA.ExitPoints.Add(uAExitA);
var uA = userActionA.As <WfActivity>();
wf.AddActivity(uA);
ActivityTestHelper.AddExpressionToActivityArgument(wf, uA, "Record", "[Input]");
ActivityTestHelper.AddExpressionToActivityArgument(wf, uA, "Wait for next form", "true");
ActivityTestHelper.AddExpressionToActivityArgument(wf, uA, "Hide comment field", "true");
ActivityTestHelper.AddExpressionToActivityArgument(wf, uA, "Record history", "false");
ActivityTestHelper.AddEntityExpression(wf, uA, uA.GetInputArgument("For Person"), new EntityRef("core", "administratorPerson"));
ActivityTestHelper.AddEntityExpression(wf, uA, uA.GetInputArgument("Form"), new EntityRef("test", "personForm"));
uA.Save();
var delete = Entity.Create <DeleteActivity>();
delete.Name = "Delete";
var d = delete.As <WfActivity>();
wf.AddActivity(d);
ActivityTestHelper.AddExpressionToActivityArgument(wf, d, "Record", "[Input]");
d.Save();
var uBExitC = Entity.Create <ExitPoint>();
uBExitC.Name = "Exit C";
uBExitC.ExitPointActionSummary = "Exit C action summary";
uBExitC.IsDefaultExitPoint = true;
uBExitC.Save();
var userActionB = Entity.Create <DisplayFormActivity>();
userActionB.Name = "B";
userActionB.ExitPoints.Add(uBExitC);
var uB = userActionB.As <WfActivity>();
wf.AddActivity(uB);
ActivityTestHelper.AddEntityExpression(wf, uB, uB.GetInputArgument("For Person"), new EntityRef("core", "administratorPerson"));
uB.Save();
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
#endregion
// Act
var wfInput = new Dictionary <string, object> {
{ "Input", driver }
};
using (new WorkflowRunContext(true))
{
run = RunWorkflow(wf, wfInput);
}
run.WorkflowRunStatus_Enum.Should().Be(WorkflowRunState_Enumeration.WorkflowRunPaused);
run.PendingActivity.Should().NotBeNull();
run.PendingActivity.Name.Should().Be("A");
run.TaskWithinWorkflowRun.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(1);
var userTaskA = run.TaskWithinWorkflowRun.First().AsWritable <DisplayFormUserTask>();
userTaskA.AvailableTransitions.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(1);
userTaskA.WorkflowRunForTask.Id.Should().Be(run.Id);
var resumeEvent = new UserCompletesTaskEvent
{
CompletionStateId = userTaskA.AvailableTransitions.First(t => t.Name == "Exit A").Id,
UserTaskId = run.TaskWithinWorkflowRun.First().Id
};
using (new WorkflowRunContext(true))
{
run2 = WorkflowRunner.Instance.ResumeWorkflow(run, resumeEvent);
}
// Assert
run2.WorkflowRunStatus_Enum.Should().Be(WorkflowRunState_Enumeration.WorkflowRunPaused);
run2.PendingActivity.Should().NotBeNull();
run2.PendingActivity.Name.Should().Be("B");
run2.TaskWithinWorkflowRun.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(1);
var deletedDriver = Entity.Exists(new EntityRef(driver.Id));
deletedDriver.Should().BeFalse();
}
finally
{
if (wf != null)
{
ToDelete.Add(wf.Id);
}
if (driver != null && Entity.Exists(new EntityRef(driver.Id)))
{
ToDelete.Add(driver.Id);
}
}
}
}
public void EditPausedWorkflowUnderHobbledSecurityAccount_Bug_25246()
{
Workflow wf = null, wfClone = null;
try
{
#region Arrange
var dogBreedType = Entity.GetByName <EntityType>("AA_DogBreeds").FirstOrDefault();
dogBreedType.Should().NotBeNull("Couldn't locate the type for dog breeds.");
var poodle = Entity.GetByName("Poodle").FirstOrDefault();
poodle.Should().NotBeNull("Couldn't locate poodle.");
wf = Entity.Create <Workflow>();
wf.Name = "Pet the poodle.";
wf.AddDefaultExitPoint();
wf.AddInput <ResourceArgument>("Input", dogBreedType);
wf.InputArgumentForAction = wf.InputArguments.First();
var i = Entity.Create <WfExpression>();
i.ArgumentToPopulate = wf.InputArgumentForAction;
wf.ExpressionMap = new EntityCollection <WfExpression> {
i
};
wf.InputArgumentForAction.PopulatedByExpression = new EntityCollection <WfExpression> {
i
};
var exitPoint = Entity.Create <ExitPoint>();
exitPoint.Name = "Pet";
exitPoint.IsDefaultExitPoint = true;
exitPoint.Save();
var userAction = Entity.Create <DisplayFormActivity>();
userAction.Name = "Do Action";
userAction.ExitPoints.Add(exitPoint);
var act = userAction.As <WfActivity>();
wf.AddActivity(act);
ActivityTestHelper.AddExpressionToActivityArgument(wf, act, "Record", "[Input]");
ActivityTestHelper.AddEntityExpression(wf, act, act.GetInputArgument("For Person"), new EntityRef("core", "administratorPerson"));
act.Save();
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
#endregion
// Act
using (new SetUser(Entity.Get <UserAccount>("core:administratorUserAccount")))
{
// Hobbled.
var wfInput = new Dictionary <string, object> {
{ "Input", poodle }
};
var run = RunWorkflow(wf, wfInput);
run.WorkflowRunStatus_Enum.Should().Be(WorkflowRunState_Enumeration.WorkflowRunPaused);
run.PendingActivity.Should().NotBeNull();
run.PendingActivity.Name.Should().Be("Do Action");
run.TaskWithinWorkflowRun.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(1);
run.WorkflowBeingRun.Should().NotBeNull();
run.WorkflowBeingRun.FirstActivity.Should().NotBeNull();
run.WorkflowBeingRun.RunningInstances.Should().NotBeNull();
run.WorkflowBeingRun.RunningInstances.Count.Should().Be(1);
// Edit
WorkflowUpdateHelper.Update(wf.Id, () =>
{
var wfEdit = Entity.Get <Workflow>(wf.Id, true).AsWritable <Workflow>();
wfEdit.Description = "What?";
var actEdit = wfEdit.FirstActivity.AsWritable <WfActivity>();
actEdit.Name += "2";
actEdit.Save();
wfEdit.Save();
});
// Assert
var wfOriginal = Entity.Get <Workflow>(wf.Id);
wfOriginal.Should().NotBeNull();
wfOriginal.Description.Should().Be("What?");
wfOriginal.FirstActivity.Should().NotBeNull();
wfOriginal.FirstActivity.Name.Should().Be("Do Action2"); // i guess?
wfOriginal.RunningInstances.Should().NotBeNull().And.BeEmpty();
wfOriginal.WfOlderVersion.Should().NotBeNull();
wfOriginal.WfNewerVersion.Should().BeNull();
wfClone = wfOriginal.WfOlderVersion;
wfClone.Description.Should().BeNullOrEmpty();
wfClone.FirstActivity.Should().NotBeNull();
wfClone.FirstActivity.Name.Should().Be("Do Action");
wfClone.RunningInstances.Should().NotBeNull();
wfClone.RunningInstances.Count.Should().Be(1);
}
}
finally
{
if (wf != null)
{
ToDelete.Add(wf.Id);
}
if (wfClone != null)
{
ToDelete.Add(wfClone.Id);
}
}
}
public void LoopWithinLoop_bug_17651()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var wf = new Workflow()
{
Name = "LoopWithinLoop_bug_17651"
};
wf.AddDefaultExitPoint();
var count = new IntegerArgument()
{
Name = "count"
};
ActivityTestHelper.AddVariableToWorkflow(wf, count.As <ActivityArgument>());
wf.AddExpressionToWorkflowVariable("count", "0");
var foreachX = new ForEachResource()
{
Name = "ForEachX" + DateTime.Now
};
var foreachXAs = foreachX.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, foreachXAs, "List", "all([Workflow Event])");
wf.FirstActivity = foreachXAs;
wf.ContainedActivities.Add(foreachXAs);
var foreachY = new ForEachResource()
{
Name = "ForEachY" + DateTime.Now
};
var foreachYAs = foreachY.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, foreachYAs, "List", "all([Event Email Priority Enum])");
wf.ContainedActivities.Add(foreachYAs);
ActivityTestHelper.AddTransition(wf, foreachXAs, foreachYAs, "Loop");
ActivityTestHelper.AddTermination(wf, foreachXAs, "Finished");
var assign = new AssignToVariable()
{
Name = "Assign"
};
var assignAs = assign.As <WfActivity>();
assign.TargetVariable = count.As <ActivityArgument>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, assignAs, "Value", "count + 1");
wf.ContainedActivities.Add(assignAs);
ActivityTestHelper.AddTransition(wf, foreachYAs, assignAs, "Loop");
ActivityTestHelper.AddTransition(wf, foreachYAs, foreachXAs, "Finished");
ActivityTestHelper.AddTransition(wf, assignAs, foreachYAs);
var output = new IntegerArgument()
{
Name = "out"
};
var outputAs = output.As <ActivityArgument>();
wf.OutputArguments.Add(outputAs);
ActivityTestHelper.AddAssignToVar(wf, "Set Output", "count", "out");
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
ToDelete.Add(wf.Id);
var run = (RunWorkflow(wf));
var outputs = run.GetOutput();
Assert.AreEqual(1, outputs.Count, "There is one output argument");
var result = (int)outputs["out"];
var triggeredOnCount = Entity.GetInstancesOfType <WorkflowEventEnum>(false).Count();
var runStateCount = Entity.GetInstancesOfType <EventEmailPriorityEnum>(false).Count();
Assert.AreEqual(triggeredOnCount * runStateCount, result, "The nested loops ran the correct number of times.");
}
}
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 PassingValuesBetweenActivities( )
{
// This test creates a person with an age of ten and a workflow that takes the persons resource id as inputs, reads that persons age and writes it out to the log embedded in a message.
// Testing:
// Mapping workflow input arguments.
// Mapping an output argument to a variable.
// Using an expression that contains an input parameter.
var personType = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>();
var ageField = personType.Fields.First(f => f.Name == "Age");
var peter = Entity.Create(personType).As <Resource>();
peter.Name = "Peter" + DateTime.Now;
peter.SetField(ageField, 10);
peter.Save( );
ToDelete.Add(peter.Id);
var workflow = new Workflow
{
Name = "Wf" + DateTime.Now
};
workflow.AddDefaultExitPoint( );
var resourceIdArg = new ResourceArgument
{
Name = "ResourceId",
ConformsToType = personType
};
var resourceIdArgAs = resourceIdArg.As <ActivityArgument>( );
workflow.InputArguments.Add(resourceIdArg.As <ActivityArgument>( ));
//workflow.Save( );
var workflowAs = workflow.As <WfActivity>( );
// log activity
var log = new LogActivity
{
Name = "log" + DateTime.Now
};
var logAs = log.As <WfActivity>( );
workflow.ContainedActivities.Add(logAs);
workflow.FirstActivity = logAs;
ActivityTestHelper.AddExpressionToActivityArgument(workflow, logAs, "Message", "'Peters age is ' + ResourceId.Age", false);
ActivityTestHelper.AddTermination(workflow, logAs);
workflow.Save( );
ToDelete.Add(workflow.Id);
ActivityImplementationBase nextActivity = workflow.Cast <WfActivity>( ).CreateWindowsActivity( );
var input = new Dictionary <string, object>
{
{
"ResourceId", peter
}
};
var run = (RunWorkflow(workflow, input));
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum, "The workflow run and completed without error");
//RunActivity( nextActivity, input );
}