// 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); }