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);
}
private async Task AddWorkflowToStore(string workflowName, string workflowId, WorkflowEventSubscription[] subscriptions)
{
Workflow workflow = TestWorkflowFactory.Get(workflowName);
workflow.WorkflowEventSubscriptions = subscriptions;
workflow.Id = workflowId;
ITenantedWorkflowStoreFactory storeFactory = this.serviceProvider.GetRequiredService <ITenantedWorkflowStoreFactory>();
IWorkflowStore store = await storeFactory.GetWorkflowStoreForTenantAsync(
this.transientTenantManager.PrimaryTransientClient).ConfigureAwait(false);
try
{
await store.UpsertWorkflowAsync(workflow).ConfigureAwait(false);
}
catch (WorkflowConflictException)
{
// The workflow already exists. Move on.
}
// Get the workflow so we have the correct etag.
workflow = await store.GetWorkflowAsync(workflow.Id).ConfigureAwait(false);
this.scenarioContext.Set(workflow, workflowName);
}
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 dynamic Workflow()
{
var workflowId = Request.Form["WorkflowId"];
var connId = Request.Form["ConnectionId"];
var currentUser = _userStore.GetUser(this.Context.CurrentUser.UserName);
// get the connection and load the workflow store
ConnectionModel connection = _userStore.GetConnection(connId);
IWorkflowStore store = _workflowStoreFactory.GetWorkflowStore(connection);
// extract the data we need to display the workflow
string json = store.GetWorkflowAsJson(workflowId);
if (json == null)
{
return(this.Response.AsJson(new { Message = "No workflow found matching the supplied workflow and connection (the workflow may have completed)." }, HttpStatusCode.NotFound));
}
UIWorkflow wf = _workflowInfoService.GetWorkflowInfoFromJson(json, connection.WorkflowStoreType);
WorkflowViewModel viewModel = new WorkflowViewModel();
viewModel.WorkflowJson = json;
viewModel.IsSuspended = wf.IsSuspended;
return(this.Response.AsJson(viewModel));
}
public void Test_ConnectionSucceeds_ReturnsSuccess()
{
// setup
var currentUser = new UserIdentity()
{
Id = Guid.NewGuid(), UserName = "******"
};
var browser = CreateBrowser(currentUser);
_connectionValidator.Validate(Arg.Any <ConnectionViewModel>()).Returns(new ValidationResult());
// set up the workflow store to throw an exception
IWorkflowStore store = Substitute.For <IWorkflowStore>();
_workflowStoreFactory.GetWorkflowStore(Arg.Any <ConnectionModel>()).Returns(store);
// execute
var response = browser.Post(Actions.Connection.Test, (with) =>
{
with.HttpRequest();
with.FormsAuth(currentUser.Id, new Nancy.Authentication.Forms.FormsAuthenticationConfiguration());
});
// assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
ValidationResult result = JsonConvert.DeserializeObject <ValidationResult>(response.Body.AsString());
Assert.IsTrue(result.Success);
Assert.AreEqual(0, result.Messages.Count);
_workflowStoreFactory.Received(1).GetWorkflowStore(Arg.Any <ConnectionModel>());
store.Received(1).GetIncompleteCount();
}
public WorkflowDesigner(
IWorkflowStore workflowStore,
IActivityShapeFactory activityShapeFactory)
{
this.workflowStore = workflowStore;
this.activityShapeFactory = activityShapeFactory;
}
public WorkflowClient(IWorkflowStore workflowStore, IWorkflowRegistrationService workflowRegistrationService, ICommandFactory commandFactory)
{
_workflowStore = workflowStore;
_workflowRegistrationService = workflowRegistrationService;
this.CommandFactory = commandFactory;
}
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 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 Get_InvalidId_ThrowsException()
{
IWorkflowStore store = GetStore();
TestDelegate del = () => store.Get(Guid.NewGuid());
Assert.Throws <WorkflowNotFoundException>(del);
}
public WorkflowController(
ISiteService siteService,
IWorkflowManager workflowManager,
IWorkflowTypeStore workflowTypeStore,
IWorkflowStore workflowStore,
IAuthorizationService authorizationService,
IActivityDisplayManager activityDisplayManager,
IShapeFactory shapeFactory,
INotifier notifier,
IHtmlLocalizer <WorkflowController> localizer,
ILogger <WorkflowController> logger
)
{
_siteService = siteService;
_workflowManager = workflowManager;
_workflowTypeStore = workflowTypeStore;
_workflowStore = workflowStore;
_authorizationService = authorizationService;
_activityDisplayManager = activityDisplayManager;
_notifier = notifier;
_logger = logger;
New = shapeFactory;
T = localizer;
}
public void GetIncompleteCount_WithSuspendedWorkflows_ReturnsCorrectCount()
{
// 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++)
{
store.Save(new BasicWorkflow(BasicWorkflow.State.Start));
}
store.Save(new BasicWorkflow(BasicWorkflow.State.Start)
{
IsSuspended = true
});
store.Save(new BasicWorkflow(BasicWorkflow.State.Start)
{
IsSuspended = true
});
store.Save(new BasicWorkflow(BasicWorkflow.State.Start)
{
IsSuspended = true
});
long result = store.GetIncompleteCount();
Assert.AreEqual(count, result);
}
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 WorkflowManager
(
IActivityLibrary activityLibrary,
IWorkflowTypeStore workflowTypeRepository,
IWorkflowStore workflowRepository,
IWorkflowIdGenerator workflowIdGenerator,
Resolver <IEnumerable <IWorkflowExecutionContextHandler> > workflowContextHandlers,
Resolver <IEnumerable <IWorkflowValueSerializer> > workflowValueSerializers,
ILogger <WorkflowManager> logger,
ILogger <WorkflowExecutionContext> workflowContextLogger,
ILogger <MissingActivity> missingActivityLogger,
IStringLocalizer <MissingActivity> missingActivityLocalizer,
IClock clock
)
{
_activityLibrary = activityLibrary;
_workflowTypeStore = workflowTypeRepository;
_workflowStore = workflowRepository;
_workflowIdGenerator = workflowIdGenerator;
_workflowContextHandlers = workflowContextHandlers;
_workflowValueSerializers = workflowValueSerializers;
_logger = logger;
_workflowContextLogger = workflowContextLogger;
_missingActivityLogger = missingActivityLogger;
_missingActivityLocalizer = missingActivityLocalizer;
_clock = clock;
}
public async Task GivenIHaveCreatedAndPersistedANewInstanceOfTheDataCatalogWorkflowWithId(string workflowId)
{
IWorkflowMessageQueue workflowMessageQueue =
ContainerBindings.GetServiceProvider(this.featureContext).GetService <IWorkflowMessageQueue>();
Workflow workflow = DataCatalogWorkflowFactory.Create(workflowId, workflowMessageQueue);
ITenantedWorkflowStoreFactory storeFactory =
ContainerBindings.GetServiceProvider(this.featureContext).GetService <ITenantedWorkflowStoreFactory>();
ITenantProvider tenantProvider =
ContainerBindings.GetServiceProvider(this.featureContext).GetService <ITenantProvider>();
IWorkflowStore store = await storeFactory.GetWorkflowStoreForTenantAsync(tenantProvider.Root).ConfigureAwait(false);
await WorkflowRetryHelper.ExecuteWithStandardTestRetryRulesAsync(async() =>
{
try
{
Workflow oldWorkflow = await store.GetWorkflowAsync(workflowId).ConfigureAwait(false);
workflow.ETag = oldWorkflow.ETag;
}
catch (WorkflowNotFoundException)
{
// Don't care if there is no old workflow.
}
await store.UpsertWorkflowAsync(workflow).ConfigureAwait(false);
}).ConfigureAwait(false);
}
public void Unsuspend_SingleWorkflow_UnuspendsWorkflow()
{
// setup
var currentUser = new UserIdentity()
{
Id = Guid.NewGuid(), UserName = "******"
};
var browser = CreateBrowser(currentUser);
var workflowId = Guid.NewGuid();
var connectionId = Guid.NewGuid();
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
ConnectionModel connection = new ConnectionModel()
{
Id = connectionId,
Host = "myserver"
};
_userStore.GetConnection(connectionId).Returns(connection);
_workflowStoreFactory.GetWorkflowStore(connection).Returns(workflowStore);
// execute
var response = browser.Post(Actions.Store.Unsuspend, (with) =>
{
with.HttpRequest();
with.FormsAuth(currentUser.Id, new Nancy.Authentication.Forms.FormsAuthenticationConfiguration());
with.FormValue("WorkflowIds", workflowId.ToString());
with.FormValue("ConnectionId", connectionId.ToString());
});
// assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
_workflowStoreFactory.Received(1).GetWorkflowStore(connection);
workflowStore.Received(1).UnsuspendWorkflow(workflowId);
}
public static async Task ClearDownTransientTenantContentStore(FeatureContext context)
{
ITenant transientTenant = TransientTenantManager.GetInstance(context).PrimaryTransientClient;
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(context);
if (transientTenant != null && serviceProvider != null)
{
await context.RunAndStoreExceptionsAsync(async() =>
{
ITenantedWorkflowStoreFactory workflowStoreFactory = serviceProvider.GetRequiredService <ITenantedWorkflowStoreFactory>();
IWorkflowStore workflowStore = await workflowStoreFactory.GetWorkflowStoreForTenantAsync(transientTenant).ConfigureAwait(false);
if (workflowStore is CosmosWorkflowStore cosmosWorkflowStore)
{
await cosmosWorkflowStore.Container.DeleteContainerAsync().ConfigureAwait(false);
}
}).ConfigureAwait(false);
await context.RunAndStoreExceptionsAsync(async() =>
{
ITenantedWorkflowInstanceStoreFactory workflowInstanceStoreFactory = serviceProvider.GetRequiredService <ITenantedWorkflowInstanceStoreFactory>();
var workflowInstanceStore = (CosmosWorkflowInstanceStore)await workflowInstanceStoreFactory.GetWorkflowInstanceStoreForTenantAsync(transientTenant).ConfigureAwait(false);
await workflowInstanceStore.Container.DeleteContainerAsync().ConfigureAwait(false);
}).ConfigureAwait(false);
}
}
public dynamic Test()
{
var model = this.Bind <ConnectionModel>();
var validationResult = _connectionValidator.Validate(model);
if (!validationResult.Success)
{
return(Response.AsJson <ValidationResult>(validationResult));
}
// try and connect
try
{
// create a store and try and get the active count - this will bomb out if there is a problem
IWorkflowStore store = _workflowStoreFactory.GetWorkflowStore(model);
store.GetIncompleteCount();
// all good, return an empty validation result
return(Response.AsJson <ValidationResult>(new ValidationResult()));
}
catch (Exception ex)
{
return(Response.AsJson <ValidationResult>(new ValidationResult("Connection failed: " + ex.Message)));
}
}
public WorkflowController(
ISiteService siteService,
ISession session,
IWorkflowManager workflowManager,
IWorkflowTypeStore workflowTypeStore,
IWorkflowStore workflowStore,
IAuthorizationService authorizationService,
IActivityDisplayManager activityDisplayManager,
IShapeFactory shapeFactory,
INotifier notifier,
IHtmlLocalizer <WorkflowController> htmlLocalizer,
IStringLocalizer <WorkflowController> stringLocalizer,
IUpdateModelAccessor updateModelAccessor)
{
_siteService = siteService;
_session = session;
_workflowManager = workflowManager;
_workflowTypeStore = workflowTypeStore;
_workflowStore = workflowStore;
_authorizationService = authorizationService;
_activityDisplayManager = activityDisplayManager;
_notifier = notifier;
_updateModelAccessor = updateModelAccessor;
New = shapeFactory;
H = htmlLocalizer;
S = stringLocalizer;
}
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 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 IsSingleInstanceWorkflowRegistered_OnExecute_UsesService()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
IWorkflowRegistrationService regService = Substitute.For <IWorkflowRegistrationService>();
IWorkflowServer workflowServer = new WorkflowServer(workflowStore, regService, Substitute.For <IWorkflowExceptionHandler>());
workflowServer.IsSingleInstanceWorkflowRegistered <BasicWorkflow>();
regService.Received(1).IsSingleInstanceWorkflowRegistered <BasicWorkflow>(workflowStore);
}
public void Delete_OnExecute_RemovesFromStore()
{
Guid workflowId = Guid.NewGuid();
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
IWorkflowClient workflowClient = new WorkflowClient(workflowStore, Substitute.For <IWorkflowRegistrationService>(), Substitute.For <ICommandFactory>());
workflowClient.Delete(workflowId);
workflowStore.Received(1).Delete(workflowId);
}
public void IsSingleInstanceWorkflowRegistered_OnExecute_UsesService()
{
// set up the store and the workflows
IWorkflowStore workflowStore = Substitute.For <IWorkflowStore>();
IWorkflowRegistrationService regService = Substitute.For <IWorkflowRegistrationService>();
IWorkflowClient workflowClient = new WorkflowClient(workflowStore, regService, Substitute.For <ICommandFactory>());
workflowClient.IsSingleInstanceWorkflowRegistered <BasicWorkflow>();
regService.Received(1).IsSingleInstanceWorkflowRegistered <BasicWorkflow>(workflowStore);
}
public WorkflowsController(
IWorkflowStore workflowStore,
IWorkflowSerializer workflowSerializer,
ITokenFormatterProvider tokenFormatterProvider,
IIdGenerator idGenerator)
{
this.workflowStore = workflowStore;
this.workflowSerializer = workflowSerializer;
this.tokenFormatterProvider = tokenFormatterProvider;
this.idGenerator = idGenerator;
}
public WorkflowInvoker(
IActivityInvoker activityInvoker,
IWorkflowStore workflowStore,
IClock clock,
ILogger <WorkflowInvoker> logger)
{
ActivityInvoker = activityInvoker;
this.workflowStore = workflowStore;
this.clock = clock;
this.logger = logger;
}
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 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);
}
