public DateTime CalculateResumptionDate(DateTime persistenceDate, enSuspendOption suspendOption, string scheduleValue)
{
var resumptionDate = DateTime.UtcNow;
switch (suspendOption)
{
case enSuspendOption.SuspendForDays:
resumptionDate = persistenceDate.AddDays(int.Parse(scheduleValue));
break;
case enSuspendOption.SuspendForMonths:
resumptionDate = persistenceDate.AddMonths(int.Parse(scheduleValue));
break;
case enSuspendOption.SuspendUntil:
resumptionDate = DateTime.Parse(scheduleValue);
break;
case enSuspendOption.SuspendForHours:
resumptionDate = persistenceDate.AddHours(int.Parse(scheduleValue));
break;
case enSuspendOption.SuspendForMinutes:
resumptionDate = persistenceDate.AddMinutes(int.Parse(scheduleValue));
break;
case enSuspendOption.SuspendForSeconds:
resumptionDate = persistenceDate.AddSeconds(int.Parse(scheduleValue));
break;
}
return(resumptionDate);
}
public static string GetSuspendValidationMessageType(enSuspendOption suspendOption)
{
switch (suspendOption)
{
case enSuspendOption.SuspendUntil:
return("Date");
case enSuspendOption.SuspendForSeconds:
return("Seconds");
case enSuspendOption.SuspendForMinutes:
return("Minutes");
case enSuspendOption.SuspendForHours:
return("Hours");
case enSuspendOption.SuspendForDays:
return("Days");
case enSuspendOption.SuspendForMonths:
return("Months");
default:
return("");
}
}
public void PersistenceExecution_ResumeJob_Success()
{
var mockDataObject = new Mock <IDSFDataObject>();
var values = new Dictionary <string, StringBuilder>
{
{ "resourceID", new StringBuilder("ab04663e-1e09-4338-8f61-a06a7ae5ebab") },
{ "environment", new StringBuilder("") },
{ "startActivityId", new StringBuilder("4032a11e-4fb3-4208-af48-b92a0602ab4b") },
{ "versionNumber", new StringBuilder("1") }
};
const enSuspendOption suspendOption = enSuspendOption.SuspendUntil;
var suspendOptionValue = DateTime.Now.AddDays(1).ToString(CultureInfo.InvariantCulture);
const string expectedJobId = "1234";
const string environment = "environment";
Config.Persistence.PersistenceScheduler = nameof(Hangfire);
var mockPersistenceScheduler = new Mock <IPersistenceScheduler>();
mockPersistenceScheduler.Setup(o => o.ScheduleJob(suspendOption, suspendOptionValue, values))
.Returns(expectedJobId).Verifiable();
mockPersistenceScheduler.Setup(o => o.ResumeJob(mockDataObject.Object, expectedJobId, true, environment))
.Returns(GlobalConstants.Success).Verifiable();
var scheduler = new PersistenceExecution(mockPersistenceScheduler.Object);
var jobId = scheduler.CreateAndScheduleJob(suspendOption, suspendOptionValue, values);
var result = scheduler.ResumeJob(mockDataObject.Object, expectedJobId, true, environment);
Assert.AreEqual(GlobalConstants.Success, result);
}
public void PersistenceExecution_GetSuspendedEnvironment_Success()
{
var resourceId = Guid.Parse("ab04663e-1e09-4338-8f61-a06a7ae5ebab");
var values = new Dictionary <string, StringBuilder>
{
{ "resourceID", new StringBuilder(resourceId.ToString()) },
{ "environment", new StringBuilder("") },
{ "startActivityId", new StringBuilder("4032a11e-4fb3-4208-af48-b92a0602ab4b") },
{ "versionNumber", new StringBuilder("1") }
};
const enSuspendOption suspendOption = enSuspendOption.SuspendUntil;
var suspendOptionValue = DateTime.Now.AddDays(1).ToString(CultureInfo.InvariantCulture);
const string expectedJobId = "1234";
Config.Persistence.PersistenceScheduler = nameof(Hangfire);
var mockPersistenceScheduler = new Mock <IPersistenceScheduler>();
mockPersistenceScheduler.Setup(o => o.ScheduleJob(suspendOption, suspendOptionValue, values))
.Returns(expectedJobId).Verifiable();
var mockPersistedValues = new Mock <IPersistedValues>();
mockPersistedValues.Setup(o => o.ResourceId).Returns(resourceId);
mockPersistenceScheduler.Setup(o => o.GetPersistedValues(expectedJobId))
.Returns(mockPersistedValues.Object).Verifiable();
var scheduler = new PersistenceExecution(mockPersistenceScheduler.Object);
var result = scheduler.GetPersistedValues(expectedJobId);
Assert.AreEqual(resourceId, result.ResourceId);
}
public string ScheduleJob(enSuspendOption suspendOption, string suspendOptionValue, Dictionary <string, StringBuilder> values)
{
var suspensionDate = DateTime.Now;
var resumptionDate = CalculateResumptionDate(suspensionDate, suspendOption, suspendOptionValue);
var state = new ScheduledState(resumptionDate.ToUniversalTime());
var jobId = _client.Create(() => ResumeWorkflow(values, null), state);
return(jobId);
}
public string CreateAndScheduleJob(enSuspendOption suspendOption, string suspendOptionValue, Dictionary <string, StringBuilder> values)
{
var scheduler = _persistenceScheduler ?? GetScheduler();
if (scheduler is null)
{
throw new Exception(ErrorResource.PersistenceSettingsNoConfigured);
}
var jobId = scheduler.ScheduleJob(suspendOption, suspendOptionValue, values);
return(jobId);
}
public void PersistenceExecution_CreateAndScheduleJob_PersistenceSettingsNoConfigured()
{
var values = new Dictionary <string, StringBuilder>
{
{ "resourceID", new StringBuilder("ab04663e-1e09-4338-8f61-a06a7ae5ebab") },
{ "environment", new StringBuilder("") },
{ "startActivityId", new StringBuilder("4032a11e-4fb3-4208-af48-b92a0602ab4b") },
{ "versionNumber", new StringBuilder("1") }
};
const enSuspendOption suspendOption = enSuspendOption.SuspendForDays;
const string suspendOptionValue = "1";
Config.Persistence.PersistenceScheduler = "";
var scheduler = new PersistenceExecution(null);
scheduler.CreateAndScheduleJob(suspendOption, suspendOptionValue, values);
}
public void PersistenceExecution_CreateAndScheduleJob_Success()
{
var values = new Dictionary <string, StringBuilder>
{
{ "resourceID", new StringBuilder("ab04663e-1e09-4338-8f61-a06a7ae5ebab") },
{ "environment", new StringBuilder("") },
{ "startActivityId", new StringBuilder("4032a11e-4fb3-4208-af48-b92a0602ab4b") },
{ "versionNumber", new StringBuilder("1") }
};
const enSuspendOption suspendOption = enSuspendOption.SuspendForDays;
const string suspendOptionValue = "1";
Config.Persistence.PersistenceScheduler = nameof(Hangfire);
var mockPersistenceScheduler = new Mock <IPersistenceScheduler>();
mockPersistenceScheduler.Setup(o => o.ScheduleJob(suspendOption, suspendOptionValue, values)).Verifiable();
var scheduler = new PersistenceExecution(mockPersistenceScheduler.Object);
scheduler.CreateAndScheduleJob(suspendOption, suspendOptionValue, values);
mockPersistenceScheduler.Verify(o => o.ScheduleJob(suspendOption, suspendOptionValue, values), Times.Once);
}
public void SuspendExecutionActivity_Execute_ServiceTestExecution_Success()
{
//------------Setup for test--------------------------
var workflowName = "workflowName";
var url = "http://localhost:3142/secure/WorkflowResume";
var resourceId = Guid.NewGuid();
var nextNodeId = Guid.NewGuid();
var workflowInstanceId = Guid.NewGuid();
var env = CreateExecutionEnvironment();
env.Assign("[[UUID]]", "public", 0);
env.Assign("[[JourneyName]]", "whatever", 0);
var mockStateNotifier = new Mock<IStateNotifier>();
mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny<IDev2Activity>()));
var environmentId = Guid.Empty;
var mockPrincipal = new Mock<ClaimsPrincipal>();
mockPrincipal.Setup(o => o.Identity).Returns(WindowsIdentity.GetCurrent());
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServiceName = workflowName,
ResourceID = resourceId,
WorkflowInstanceId = workflowInstanceId,
WebUrl = url,
ServerID = Guid.NewGuid(),
ExecutingUser = mockPrincipal.Object,
IsDebug = true,
EnvironmentID = environmentId,
Environment = env,
IsRemoteInvokeOverridden = false,
DataList = new StringBuilder(CurrentDl),
IsServiceTestExecution = true
};
var mockActivity = new Mock<IDev2Activity>();
mockActivity.Setup(o => o.UniqueID).Returns(nextNodeId.ToString());
var dev2Activities = new List<IDev2Activity> {mockActivity.Object};
var activity = CreateWorkflow();
var activityFunction = new ActivityFunc<string, bool>
{
DisplayName = activity.DisplayName,
Handler = activity,
};
var config = new PersistenceSettings
{
Enable = true
};
var expectedSuspendId = Guid.NewGuid().ToString();
const enSuspendOption suspendOption = enSuspendOption.SuspendForSeconds;
var mockSuspendExecution = new Mock<IPersistenceExecution>();
mockSuspendExecution.Setup(o =>
o.CreateAndScheduleJob(suspendOption, It.IsAny<string>(),
It.IsAny<Dictionary<string, StringBuilder>>())).Returns(expectedSuspendId);
var suspendExecutionActivity = new SuspendExecutionActivity(config, mockSuspendExecution.Object)
{
SuspendOption = suspendOption,
PersistValue = "20",
AllowManualResumption = true,
SaveDataFunc = activityFunction,
Result = "[[SuspendID]]",
NextNodes = dev2Activities
};
suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
suspendExecutionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
Assert.AreEqual(0, env.Errors.Count);
Assert.AreEqual(expectedSuspendId, suspendExecutionActivity.Response);
Assert.IsFalse(dataObject.StopExecution, "this will Stop Execution for the whole workflow, which is not ideal for the problem we are resolving");
Assert.IsFalse(dataObject.IsDebugNested);
Assert.AreEqual(0, dataObject.ForEachNestingLevel);
}
