public void Can_be_returned_as_custom_action()
        {
            var workflowStartedEventGraph = _eventGraphBuilder.WorkflowStartedEvent("input");
            var workflowStartedEvent      = new WorkflowStartedEvent(workflowStartedEventGraph);

            _eventsBuilder.AddProcessedEvents(workflowStartedEventGraph);
            _eventsBuilder.AddNewEvents(_eventGraphBuilder
                                        .ActivityCompletedGraph(Identity.New("activityName", "1.0").ScheduleId(), "id", "result").ToArray());

            var workflow = new WorkflowToRestart();

            var decisions = workflow.Decisions(_eventsBuilder.Result());
            var decision  = decisions.Single().SwfDecision();

            Assert.That(decision.DecisionType, Is.EqualTo(DecisionType.ContinueAsNewWorkflowExecution));
            var attr = decision.ContinueAsNewWorkflowExecutionDecisionAttributes;

            Assert.That(attr.Input, Is.EqualTo(workflowStartedEvent.Input));
            Assert.That(attr.ChildPolicy.Value, Is.EqualTo(workflowStartedEvent.ChildPolicy));
            Assert.That(attr.ExecutionStartToCloseTimeout, Is.EqualTo(workflowStartedEvent.ExecutionStartToCloseTimeout.TotalSeconds.ToString()));
            Assert.That(attr.TagList, Is.EqualTo(workflowStartedEvent.TagList));
            Assert.That(attr.TaskList.Name, Is.EqualTo(workflowStartedEvent.TaskList));
            Assert.That(attr.TaskPriority, Is.EqualTo(workflowStartedEvent.TaskPriority.ToString()));
            Assert.That(attr.TaskStartToCloseTimeout, Is.EqualTo(workflowStartedEvent.TaskStartToCloseTimeout.TotalSeconds.ToString()));
        }
        public void Return_start_workflow_action()
        {
            var workflow      = new EmptyWorkflow();
            var workflowEvent = new WorkflowStartedEvent(_builder.WorkflowStartedEvent());

            var workflowAction = workflowEvent.Interpret(workflow);

            Assert.That(workflowAction, Is.EqualTo(workflow.StartupAction));
        }
        public void Can_return_custom_workflow_action()
        {
            var customStartupAction = new Mock <WorkflowAction>().Object;
            var workflow            = new WorkflowWithCustomStartupAction(customStartupAction);
            var workflowEvent       = new WorkflowStartedEvent(_builder.WorkflowStartedEvent());

            var actualStartupAction = workflowEvent.Interpret(workflow);

            Assert.That(actualStartupAction, Is.EqualTo(customStartupAction));
        }
        public void Raise_workflow_started_event()
        {
            var workflow = new EmptyWorkflow();
            WorkflowStartedEventArgs eventArgs = null;

            workflow.Started += (s, e) => { eventArgs = e; };
            var workflowEvent = new WorkflowStartedEvent(_builder.WorkflowStartedEvent());

            workflowEvent.Interpret(workflow);

            Assert.That(eventArgs, Is.Not.Null);
            Assert.That(eventArgs.StartEvent, Is.EqualTo(workflowEvent));
        }
        public void Populate_properties_from_event_attributes()
        {
            var workflowStartedEvent = _builder.WorkflowStartedEvent();
            var startAttributes      = workflowStartedEvent.WorkflowExecutionStartedEventAttributes;

            var workflowEvent = new WorkflowStartedEvent(workflowStartedEvent);

            Assert.AreEqual(startAttributes.ChildPolicy.Value, workflowEvent.ChildPolicy);
            Assert.AreEqual(startAttributes.ContinuedExecutionRunId, workflowEvent.ContinuedExecutionRunId);
            Assert.AreEqual(TimeSpan.FromSeconds(Convert.ToInt32(startAttributes.ExecutionStartToCloseTimeout)), workflowEvent.ExecutionStartToCloseTimeout);
            Assert.AreEqual(startAttributes.Input, workflowEvent.Input);
            Assert.AreEqual(startAttributes.LambdaRole, workflowEvent.LambdaRole);
            Assert.AreEqual(startAttributes.ParentInitiatedEventId, workflowEvent.ParentInitiatedEventId);
            Assert.AreEqual(startAttributes.ParentWorkflowExecution.RunId, workflowEvent.ParentWorkflowRunId);
            Assert.AreEqual(startAttributes.ParentWorkflowExecution.WorkflowId, workflowEvent.ParentWorkflowId);
            Assert.AreEqual(startAttributes.TagList, workflowEvent.TagList);
            Assert.AreEqual(startAttributes.TaskList.Name, workflowEvent.TaskList);
            Assert.AreEqual(int.Parse(startAttributes.TaskPriority), workflowEvent.TaskPriority);
            Assert.AreEqual(TimeSpan.FromSeconds(Convert.ToInt32(startAttributes.TaskStartToCloseTimeout)), workflowEvent.TaskStartToCloseTimeout);
        }
Ejemplo n.º 6
0
        public void Can_be_returned_as_custom_action()
        {
            var workflowStartedEventGraph = _builder.WorkflowStartedEvent("input");
            var workflowStartedEvent      = new WorkflowStartedEvent(workflowStartedEventGraph);
            var activityCompletedEvents   = _builder.ActivityCompletedGraph(Identity.New("activityName", "1.0"), "id", "result");
            var activityCompletedEvent    = new ActivityCompletedEvent(activityCompletedEvents.First(), activityCompletedEvents);
            var eventGraph     = activityCompletedEvents.Concat(new[] { workflowStartedEventGraph });
            var workflowEvents = new WorkflowHistoryEvents(eventGraph);
            var workflow       = new WorkflowToRestart();

            workflow.NewExecutionFor(workflowEvents);

            var restartWorkflowAction = (RestartWorkflowAction)activityCompletedEvent.Interpret(workflow);

            Assert.That(restartWorkflowAction.Input, Is.EqualTo(workflowStartedEvent.Input));
            Assert.That(restartWorkflowAction.ChildPolicy, Is.EqualTo(workflowStartedEvent.ChildPolicy));
            Assert.That(restartWorkflowAction.ExecutionStartToCloseTimeout, Is.EqualTo(workflowStartedEvent.ExecutionStartToCloseTimeout));
            Assert.That(restartWorkflowAction.TagList, Is.EqualTo(workflowStartedEvent.TagList));
            Assert.That(restartWorkflowAction.TaskList, Is.EqualTo(workflowStartedEvent.TaskList));
            Assert.That(restartWorkflowAction.TaskPriority, Is.EqualTo(workflowStartedEvent.TaskPriority));
            Assert.That(restartWorkflowAction.TaskStartToCloseTimeout, Is.EqualTo(workflowStartedEvent.TaskStartToCloseTimeout));
        }
 protected WorkflowAction OnStart(WorkflowStartedEvent workflowSartedEvent)
 {
     return(_workflowAction);
 }