public void GetIncomplete_WorkflowResumeDateInFuture_NotReturned()
{
// factory method for workflows
Func <bool, DateTime, BasicWorkflow> createWorkflow = (isSuspended, resumeOn) =>
{
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
wf.IsSuspended = isSuspended;
wf.ResumeOn = resumeOn;
wf.BasicMetaData = Guid.NewGuid().ToString();
return(wf);
};
Workflow noResumeDateWorkflow = createWorkflow(false, DateTime.MinValue);
Workflow resumeDateActiveWorkflow = createWorkflow(true, DateTime.UtcNow.AddMilliseconds(-1));
Workflow futureDatedWorkflow = createWorkflow(false, DateTime.UtcNow.AddMinutes(3));
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(noResumeDateWorkflow);
store.Save(resumeDateActiveWorkflow);
store.Save(futureDatedWorkflow);
// fetch the workflows, only two should be returned
List <Workflow> workflows = store.GetIncomplete(10).ToList();
Assert.AreEqual(2, workflows.Count);
Assert.IsNotNull(workflows.FirstOrDefault(x => x.Id == noResumeDateWorkflow.Id));
Assert.IsNotNull(workflows.FirstOrDefault(x => x.Id == resumeDateActiveWorkflow.Id));
Assert.IsNull(workflows.FirstOrDefault(x => x.Id == futureDatedWorkflow.Id));
}
public void GetActive_MultipleWorkflowsReturned_OrderedByRetryCountBeforeCreateDate()
{
// factory method for workflows
Func <DateTime, int, BasicWorkflow> createWorkflow = (createdOn, retryCount) => {
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
wf.CreatedOn = createdOn;
wf.RetryCount = retryCount;
return(wf);
};
// create the workflows - ensure they are added in an incorrect order
DateTime baseDate = DateTime.UtcNow;
Workflow workflow1 = createWorkflow(baseDate.AddMinutes(1), 2);
Workflow workflow2 = createWorkflow(baseDate.AddMinutes(-1), 1);
Workflow workflow3 = createWorkflow(baseDate.AddMinutes(1), 3);
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(new[] { workflow1, workflow2, workflow3 });
// fetch the workflows, only two should be returned
List <Workflow> workflows = store.GetActive(10).ToList();
Assert.AreEqual(workflow3.Id, workflows[0].Id);
Assert.AreEqual(workflow1.Id, workflows[1].Id);
Assert.AreEqual(workflow2.Id, workflows[2].Id);
}
public void NotValid_When_New_Created()
{
var basicWorkflow = BasicWorkflow.Create("*****@*****.**", Guid.NewGuid().ToString("N"), 10);
Assert.Equal(SupportedWorkflows.Basic.ToString(), basicWorkflow.Name);
Assert.False(basicWorkflow.IsValid());
}
public void GetIncomplete_MultipleWorkflowsReturned_OrderedByCreateDateAfterRetryCount()
{
// factory method for workflows
Func <DateTime, bool, BasicWorkflow> createWorkflow = (createdOn, isSuspended) =>
{
BasicWorkflow wf = new BasicWorkflow("Start");
wf.CreatedOn = createdOn;
wf.RetryCount = 1;
wf.IsSuspended = isSuspended;
return(wf);
};
// create the workflows - ensure they are added in an incorrect order
DateTime baseDate = DateTime.UtcNow;
Workflow workflow1 = createWorkflow(baseDate.AddMinutes(1), true);
Workflow workflow2 = createWorkflow(baseDate.AddMinutes(2), false);
Workflow workflow3 = createWorkflow(baseDate.AddMinutes(-1), true);
Workflow workflow4 = createWorkflow(baseDate.AddMinutes(-2), false);
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(new[] { workflow1, workflow2, workflow3, workflow4 });
// fetch the workflows, only two should be returned
List <Workflow> workflows = store.GetIncomplete(10).ToList();
Assert.AreEqual(workflow4.Id, workflows[0].Id);
Assert.AreEqual(workflow3.Id, workflows[1].Id);
Assert.AreEqual(workflow1.Id, workflows[2].Id);
Assert.AreEqual(workflow2.Id, workflows[3].Id);
}
public void Ususpend_OnUnsuspension_UpdatesWorkflowAndSaves()
{
IWorkflowStore store = GetStore();
// setup a new workflow
BasicWorkflow wf = new BasicWorkflow("Start");
wf.CreatedOn = DateTime.UtcNow.AddMinutes(-1);
wf.RetryCount = 3;
wf.ResumeOn = DateTime.UtcNow.AddDays(1);
wf.IsSuspended = true;
store.Save(wf);
// execute
DateTime beforeSuspend = DateTime.UtcNow;
store.UnsuspendWorkflow(wf.Id);
DateTime afterSuspend = DateTime.UtcNow;
// assert: fetch the workflow - it should be available and unsuspended
Workflow result = store.GetOrDefault(wf.Id);
Assert.IsNotNull(result);
Assert.IsFalse(result.IsSuspended);
Assert.AreEqual(0, result.RetryCount);
Assert.Greater(result.ResumeOn, beforeSuspend.AddMilliseconds(-1));
Assert.Less(result.ResumeOn, afterSuspend.AddMilliseconds(1));
}
public void GetIncomplete_WorkflowIsSuspended_IsReturned()
{
// factory method for workflows
Func <bool, BasicWorkflow> createWorkflow = (isSuspended) =>
{
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
wf.IsSuspended = isSuspended;
return(wf);
};
Workflow activeWorkflow = createWorkflow(false);
Workflow suspendedWorkflow = createWorkflow(true);
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(activeWorkflow);
store.Save(suspendedWorkflow);
// fetch the workflows, only one should be returned
List <Workflow> workflows = store.GetIncomplete(10).ToList();
Assert.AreEqual(2, workflows.Count);
Assert.IsNotNull(workflows.SingleOrDefault(x => x.Id == activeWorkflow.Id));
Assert.IsNotNull(workflows.SingleOrDefault(x => x.Id == suspendedWorkflow.Id));
}
public void GetActive_MultipleWorkflowsReturned_OrderedByPriorityBeforeRetryCount()
{
DateTime startTime = DateTime.Now;
// factory method for workflows
Func <int, int, BasicWorkflow> createWorkflow = (priority, retryCount) => {
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
wf.Priority = priority;
wf.RetryCount = retryCount;
wf.CreatedOn = startTime;
return(wf);
};
// create the workflows - ensure they are added in an incorrect order
DateTime baseDate = DateTime.UtcNow;
Workflow workflow1 = createWorkflow(4, 3);
Workflow workflow2 = createWorkflow(5, 2);
Workflow workflow3 = createWorkflow(5, 3);
Workflow workflow4 = createWorkflow(4, 2);
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(new[] { workflow1, workflow2, workflow3, workflow4 });
// fetch the workflows
List <Workflow> workflows = store.GetActive(10).ToList();
Assert.AreEqual(workflow3.Id, workflows[0].Id);
Assert.AreEqual(workflow2.Id, workflows[1].Id);
Assert.AreEqual(workflow1.Id, workflows[2].Id);
Assert.AreEqual(workflow4.Id, workflows[3].Id);
}
public void Get_OnExecute_UsesStore()
{
Guid workflowId = Guid.NewGuid();
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
IWorkflowClient workflowClient = new WorkflowClient(workflowStore, Substitute.For <IWorkflowRegistrationService>(), Substitute.For <ICommandFactory>());
BasicWorkflow workflow = workflowClient.Get <BasicWorkflow>(workflowId);
workflowStore.Received(1).Get <BasicWorkflow>(workflowId);
}
public void Archive_WorkflowIsMoved()
{
IWorkflowStore store = GetStore();
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
store.Save(wf);
store.Archive(wf);
Assert.IsNull(store.GetOrDefault(wf.Id));
Assert.IsNotNull(store.GetCompletedOrDefault(wf.Id));
}
public void Archive_WorkflowIsMoved()
{
IWorkflowStore store = GetStore();
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
store.Save(wf);
store.Archive(wf);
Assert.IsNull(store.GetOrDefault(wf.Id));
Assert.IsNotNull(store.GetCompletedOrDefault(wf.Id));
}
public void RegisterWorkflow_OnRegister_UsesService()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
IWorkflowRegistrationService regService = Substitute.For <IWorkflowRegistrationService>();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
IWorkflowServer workflowServer = new WorkflowServer(workflowStore, regService, Substitute.For <IWorkflowExceptionHandler>());
workflowServer.RegisterWorkflow(workflow);
regService.Received(1).RegisterWorkflow(workflowStore, workflow);
}
public void Register_OnRegister_UsesService()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
IWorkflowRegistrationService regService = Substitute.For <IWorkflowRegistrationService>();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
IWorkflowClient workflowClient = new WorkflowClient(workflowStore, regService, Substitute.For <ICommandFactory>());
workflowClient.Register(workflow);
regService.Received(1).RegisterWorkflow(workflowStore, workflow);
}
public void RegisterWorkflow_OnRegister_UsesService()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For<IWorkflowStore>();
IWorkflowRegistrationService regService = Substitute.For<IWorkflowRegistrationService>();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
IWorkflowServer workflowServer = new WorkflowServer(workflowStore, regService, Substitute.For<IWorkflowExceptionHandler>());
workflowServer.RegisterWorkflow(workflow);
regService.Received(1).RegisterWorkflow(workflowStore, workflow);
}
public MockWorkflowDataService()
{
var requestId_1 = Guid.NewGuid().ToString("N");
var requestId_2 = Guid.NewGuid().ToString("N");
var requestId_3 = Guid.NewGuid().ToString("N");
Data = new Dictionary <string, BaseWorkflow>
{
{ "jon", BasicWorkflow.Create("*****@*****.**", requestId_1, 10) },
{ "jane", SimpleWorkflow.Create("*****@*****.**", requestId_2, 10) },
{ "jawad", OnboardingWorkflow.Create("*****@*****.**", requestId_3, 10) }
};
}
public void RegisterWorkflow_MultipleInstanceWorkflowRegistered_Registers()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
IWorkflowRegistrationService regService = new WorkflowRegistrationService();
regService.RegisterWorkflow(workflowStore, workflow);
workflowStore.DidNotReceive().GetAllByType(Arg.Any <string>());
}
public void IsSingleInstanceWorkflowRegistered_WorkflowRegisteredNotSingleInstance_ThrowsException()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.IsSingleInstance = false;
workflowStore.Save(workflow);
// execute
IWorkflowRegistrationService regService = new WorkflowRegistrationService();
bool result = regService.IsSingleInstanceWorkflowRegistered<BasicWorkflow>(workflowStore);
}
public void Get_ValidId_ReturnsWorkflow()
{
// Set up a store with some basic workflows
IWorkflowStore store = GetStore();
store.Save(new BasicWorkflow(BasicWorkflow.State.Start));
store.Save(new BasicWorkflow(BasicWorkflow.State.Start));
Workflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
store.Save(wf);
Workflow result = store.Get(wf.Id);
Assert.IsNotNull(result);
Assert.AreEqual(wf.Id, result.Id);
}
public void IsSingleInstanceWorkflowRegistered_WorkflowRegistered_ReturnsTrue()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.IsSingleInstance = true;
workflowStore.Save(workflow);
// execute
IWorkflowRegistrationService regService = new WorkflowRegistrationService();
bool result = regService.IsSingleInstanceWorkflowRegistered<BasicWorkflow>(workflowStore);
Assert.IsTrue(result);
}
public void IsSingleInstanceWorkflowRegistered_WorkflowRegistered_ReturnsTrue()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.IsSingleInstance = true;
workflowStore.Save(workflow);
// execute
IWorkflowRegistrationService regService = new WorkflowRegistrationService();
bool result = regService.IsSingleInstanceWorkflowRegistered <BasicWorkflow>(workflowStore);
Assert.IsTrue(result);
}
public void Exists_WorkflowExists_ReturnsTrue()
{
Guid workflowId = Guid.NewGuid();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.Id = workflowId;
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
workflowStore.Get(workflowId).Returns(workflow);
IWorkflowClient workflowClient = new WorkflowClient(workflowStore, Substitute.For <IWorkflowRegistrationService>(), Substitute.For <ICommandFactory>());
bool result = workflowClient.Exists(workflowId);
workflowStore.Received(1).Get(workflowId);
Assert.IsTrue(result);
}
public void Get_ValidId_ReturnsWorkflow()
{
// Set up a store with some basic workflows
IWorkflowStore store = GetStore();
store.Save(new BasicWorkflow(BasicWorkflow.State.Start));
store.Save(new BasicWorkflow(BasicWorkflow.State.Start));
Workflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
store.Save(wf);
Workflow result = store.Get(wf.Id);
Assert.IsNotNull(result);
Assert.AreEqual(wf.Id, result.Id);
}
public void GetCompletedCount_OnExecute_ReturnsAccurateCount()
{
// Set up a store with some basic workflows
IWorkflowStore store = GetStore();
int count = new Random().Next(2, 10);
for (int i = 0; i < count; i++)
{
Workflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
store.Save(wf);
store.Archive(wf);
}
long result = store.GetCompletedCount();
Assert.AreEqual(count, result);
}
public void ExecuteWorkflow_OnSuccessfulExecution_RetryCountIsZero()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflow(workflow);
Assert.AreEqual(0, workflow.RetryCount);
}
public void IsSingleInstanceWorkflowRegistered_WorkflowRegisteredNotSingleInstance_ThrowsException()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.IsSingleInstance = false;
workflowStore.Save(workflow);
// execute
IWorkflowRegistrationService regService = new WorkflowRegistrationService();
TestDelegate del = () => regService.IsSingleInstanceWorkflowRegistered <BasicWorkflow>(workflowStore);
// assert
Assert.Throws <WorkflowException>(del);
}
public void ExecuteWorkflow_OnExecution_InitialisesAndFiresTriggers()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowServer = new WorkflowServer(workflowStore);
workflowServer.ExecuteWorkflow(workflow);
Assert.AreEqual(BasicWorkflow.State.Complete.ToString(), workflow.CurrentState);
}
public void ExecuteWorkflow_OnStepCompletion_ExecutesNextStep()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow("Start");
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflow(workflow);
Assert.AreEqual("Complete", workflow.CurrentState);
}
public void ExecuteWorkflow_OnExecution_InitialisesAndFiresTriggers()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowServer = new WorkflowServer(workflowStore);
workflowServer.ExecuteWorkflow(workflow);
Assert.AreEqual(BasicWorkflow.State.Complete.ToString(), workflow.CurrentState);
}
public void Execute_ValidWorkflow_ReturnsWorkflow()
{
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.Id = Guid.NewGuid();
workflow.IsSuspended = true;
workflow.ResumeOn = DateTime.UtcNow.AddMonths(1);
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
workflowStore.Get(workflow.Id).Returns(workflow);
_command.WorkflowStore = workflowStore;
_command.WorkflowId = workflow.Id;
Workflow result = _command.Execute();
Assert.AreEqual(workflow.Id, result.Id);
}
public void ExecuteWorkflow_OnSuccessfulExecution_RetryCountIsZero()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflow(workflow);
Assert.AreEqual(0, workflow.RetryCount);
}
public void OnWorkflowStateEntry_OnStateChange_Persisted()
{
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
// set up the workflow store
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
workflowStore.GetActive(Arg.Any <int>()).Returns(new[] { workflow });
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflows(10);
// We should have received TWO saves as the workflow moves between the states
workflowStore.Received(2).Save(workflow);
}
public void ExecuteWorkflow_OnCompletion_MovesWorkflowIntoCompletedArchive()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.DoingStuff);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.Complete.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflow(workflow);
Assert.IsNull(workflowStore.GetOrDefault(workflow.Id));
Assert.IsNotNull(workflowStore.GetCompleted(workflow.Id));
}
public void ExecuteWorkflow_OnCompletion_MovesWorkflowIntoCompletedArchive()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.DoingStuff);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.Complete.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflow(workflow);
Assert.IsNull(workflowStore.GetOrDefault(workflow.Id));
Assert.IsNotNull(workflowStore.GetCompleted(workflow.Id));
}
public void GetWorkflowAsJson_DocumentExists_ReturnsDocument()
{
IWorkflowStore store = GetStore();
Workflow wf = new BasicWorkflow(BasicWorkflow.State.DoingStuff);
Guid id = wf.Id;
store.Save(wf);
string json = store.GetWorkflowAsJson(id);
Assert.IsNotNull(json);
// convert back to the known type and make sure it's ok
BasicWorkflow workflow = DeserializeJsonWorkflow <BasicWorkflow>(json);
Assert.IsNotNull(workflow);
Assert.AreEqual(id, workflow.Id);
Assert.AreEqual(BasicWorkflow.State.DoingStuff.ToString(), workflow.CurrentState);
}
public void Delete_OnExecute_RemovesWorkflow()
{
Guid workflowId = Guid.NewGuid();
IWorkflowStore store = GetStore();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.Id = workflowId;
store.Save(workflow);
Workflow result1 = store.GetOrDefault(workflowId);
Assert.IsNotNull(result1);
store.Delete(workflowId);
Workflow result2 = store.GetOrDefault(workflowId);
Assert.IsNull(result2);
}
public void Execute_ValidWorkflow_SetsProperties()
{
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.Id = Guid.NewGuid();
workflow.IsSuspended = true;
workflow.ResumeOn = DateTime.UtcNow.AddMonths(1);
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
workflowStore.Get(workflow.Id).Returns(workflow);
_command.WorkflowStore = workflowStore;
_command.WorkflowId = workflow.Id;
Workflow result = _command.Execute();
Assert.IsFalse(workflow.IsSuspended);
Assert.LessOrEqual(workflow.ResumeOn, DateTime.UtcNow);
Assert.Greater(DateTime.UtcNow.AddSeconds(2), workflow.ResumeOn);
}
public void ExecuteWorkflow_OnCompletion_WorkflowOnCompleteCalled()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = Substitute.For <BasicWorkflow>(BasicWorkflow.State.DoingStuff);
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.Complete.ToString();
workflowStore.Save(workflow);
workflow.When(x => x.Fire("Complete")).Do(x => workflow.IsComplete = true);
// execute
IWorkflowServer workflowServer = new WorkflowServer(workflowStore);
workflowServer.ExecuteWorkflow(workflow);
workflow.Received(1).OnComplete();
}
public void Suspend_OnSuspension_UpdatesWorkflowAndSaves()
{
IWorkflowStore store = GetStore();
// setup a new workflow
BasicWorkflow wf = new BasicWorkflow("Start");
wf.CreatedOn = DateTime.UtcNow.AddMinutes(-1);
wf.RetryCount = 0;
wf.IsSuspended = false;
store.Save(wf);
// execute
store.SuspendWorkflow(wf.Id);
// assert: fetch the workflow - it should be available and suspended
Workflow result = store.GetOrDefault(wf.Id);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsSuspended);
}
public void GetActive_WorkflowIsSuspended_NotReturned()
{
// factory method for workflows
Func<bool, BasicWorkflow> createWorkflow = (isSuspended) => {
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
wf.IsSuspended = isSuspended;
return wf;
};
Workflow activeWorkflow = createWorkflow(false);
Workflow suspendedWorkflow = createWorkflow(true);
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(activeWorkflow);
store.Save(suspendedWorkflow);
// fetch the workflows, only one should be returned
List<Workflow> workflows = store.GetActive(10).ToList();
Assert.AreEqual(1, workflows.Count);
Assert.AreEqual(activeWorkflow.Id, workflows[0].Id);
}
public void Unsuspend_OnExecute_ReturnsWorkflow()
{
Guid workflowId = Guid.NewGuid();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.Id = workflowId;
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
UnsuspendWorkflowCommand cmd = Substitute.For <UnsuspendWorkflowCommand>();
cmd.Execute().Returns(workflow);
ICommandFactory commandFactory = Substitute.For <ICommandFactory>();
commandFactory.CreateCommand <UnsuspendWorkflowCommand>().Returns(cmd);
IWorkflowClient workflowClient = new WorkflowClient(workflowStore, Substitute.For <IWorkflowRegistrationService>(), commandFactory);
BasicWorkflow result = (BasicWorkflow)workflowClient.Unsuspend(workflowId);
Assert.AreEqual(workflowId, result.Id);
}
public void GetActive_WorkflowResumeDateInFuture_NotReturned()
{
// factory method for workflows
Func<bool, DateTime, BasicWorkflow> createWorkflow = (isSuspended, resumeOn) => {
BasicWorkflow wf = new BasicWorkflow(BasicWorkflow.State.Start);
wf.IsSuspended = isSuspended;
wf.ResumeOn = resumeOn;
wf.BasicMetaData = Guid.NewGuid().ToString();
return wf;
};
Workflow noResumeDateWorkflow = createWorkflow(false, DateTime.MinValue);
Workflow resumeDateActiveWorkflow = createWorkflow(false, DateTime.UtcNow.AddMilliseconds(-1));
Workflow futureDatedWorkflow = createWorkflow(false, DateTime.UtcNow.AddMinutes(3));
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(noResumeDateWorkflow);
store.Save(resumeDateActiveWorkflow);
store.Save(futureDatedWorkflow);
// fetch the workflows, only two should be returned
List<Workflow> workflows = store.GetActive(10).ToList();
Assert.AreEqual(2, workflows.Count);
Assert.IsNotNull(workflows.FirstOrDefault(x => x.Id == noResumeDateWorkflow.Id));
Assert.IsNotNull(workflows.FirstOrDefault(x => x.Id == resumeDateActiveWorkflow.Id));
Assert.IsNull(workflows.FirstOrDefault(x => x.Id == futureDatedWorkflow.Id));
}
public void ExecuteWorkflow_OnStepCompletion_ExecutesNextStep()
{
// set up the store and the workflows
IWorkflowStore workflowStore = new MemoryWorkflowStore();
BasicWorkflow workflow = new BasicWorkflow("Start");
workflow.CreatedOn = DateTime.UtcNow.AddMinutes(-2);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
workflowStore.Save(workflow);
// execute
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflow(workflow);
Assert.AreEqual("Complete", workflow.CurrentState);
}
public void GetActive_MultipleWorkflowsReturned_OrderedByCreateDateAfterRetryCount()
{
// factory method for workflows
Func<DateTime, BasicWorkflow> createWorkflow = (createdOn) => {
BasicWorkflow wf = new BasicWorkflow("Start");
wf.CreatedOn = createdOn;
wf.RetryCount = 1;
return wf;
};
// create the workflows - ensure they are added in an incorrect order
DateTime baseDate = DateTime.UtcNow;
Workflow workflow1 = createWorkflow(baseDate.AddMinutes(1));
Workflow workflow2 = createWorkflow(baseDate.AddMinutes(-1));
Workflow workflow3 = createWorkflow(baseDate.AddMinutes(2));
// Set up a store with a basic workflow
IWorkflowStore store = GetStore();
store.Save(new[] { workflow1, workflow2, workflow3 });
// fetch the workflows, only two should be returned
List<Workflow> workflows = store.GetActive(10).ToList();
Assert.AreEqual(workflow2.Id, workflows[0].Id);
Assert.AreEqual(workflow1.Id, workflows[1].Id);
Assert.AreEqual(workflow3.Id, workflows[2].Id);
}
public void RegisterWorkflow_MultipleInstanceWorkflowRegistered_Registers()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For<IWorkflowStore>();
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
IWorkflowRegistrationService regService = new WorkflowRegistrationService();
regService.RegisterWorkflow(workflowStore, workflow);
workflowStore.DidNotReceive().GetAllByType(Arg.Any<string>());
}
public void OnWorkflowStateEntry_OnStateChange_Persisted()
{
BasicWorkflow workflow = new BasicWorkflow(BasicWorkflow.State.Start);
workflow.ResumeTrigger = BasicWorkflow.Trigger.DoStuff.ToString();
// set up the workflow store
IWorkflowStore workflowStore = Substitute.For<IWorkflowStore>();
workflowStore.GetActive(Arg.Any<int>()).Returns(new[] { workflow });
IWorkflowServer workflowEngine = new WorkflowServer(workflowStore);
workflowEngine.ExecuteWorkflows(10);
// We should have received TWO saves as the workflow moves between the states
workflowStore.Received(2).Save(workflow);
}
