protected AtLeastOnceDeliveryReceiveActor(PersistenceSettings.AtLeastOnceDeliverySettings settings)
: base()
{
_atLeastOnceDeliverySemantic = new AtLeastOnceDeliverySemantic(Context, settings);
_atLeastOnceDeliverySemantic.Init();
}
public void ManualResumptionActivity_Execute_SuspensionID_IsNullOrWhiteSpace_FailWithMessage()
{
//------------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;
User = new Mock <IPrincipal>().Object;
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServiceName = workflowName,
ResourceID = resourceId,
WorkflowInstanceId = workflowInstanceId,
WebUrl = url,
ServerID = Guid.NewGuid(),
ExecutingUser = User,
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 config = new PersistenceSettings
{
Enable = true
};
var manualResumptionActivity = new ManualResumptionActivity(config, new Mock <IPersistenceExecution>().Object)
{
Response = "[[result]]",
OverrideInputVariables = false,
};
manualResumptionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
manualResumptionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
Assert.AreEqual(1, dataObject.Environment.AllErrors.Count);
var errors = dataObject.Environment.AllErrors.ToList();
Assert.AreEqual("Failed", manualResumptionActivity.Response);
Assert.AreEqual(errors[0], "<InnerError>SuspensionID must not be null or empty.</InnerError>");
}
public void PersistenceSettings_Get_Settings()
{
const string expectedDashboardHostname = @"http://localhost";
const string expectedDashboardPort = @"5001";
const string expectedDashboardName = @"HangfireDashboard";
//arrange
var mockIFile = new Mock <IFile>();
mockIFile.Setup(o => o.Exists(It.IsAny <string>())).Returns(false);
var mockDirectory = new Mock <IDirectory>();
var hangfireSettings = new PersistenceSettings("some path", mockIFile.Object, mockDirectory.Object);
hangfireSettings.PersistenceScheduler = "Hangfire";
hangfireSettings.Enable = true;
hangfireSettings.EncryptDataSource = false;
hangfireSettings.PrepareSchemaIfNecessary = true;
hangfireSettings.ServerName = "LocalServer";
hangfireSettings.DashboardHostname = expectedDashboardHostname;
hangfireSettings.DashboardPort = expectedDashboardPort;
hangfireSettings.DashboardName = expectedDashboardName;
hangfireSettings.PersistenceDataSource = new NamedGuidWithEncryptedPayload();
var result = hangfireSettings.Get();
Assert.IsNotNull(result);
Assert.AreEqual(expectedDashboardHostname, result.DashboardHostname);
Assert.AreEqual(expectedDashboardName, result.DashboardName);
Assert.AreEqual(expectedDashboardPort, result.DashboardPort);
Assert.AreEqual("Hangfire", result.PersistenceScheduler);
Assert.AreEqual(new NamedGuidWithEncryptedPayload(), hangfireSettings.PersistenceDataSource);
Assert.AreEqual(false, result.EncryptDataSource);
Assert.AreEqual(true, result.PrepareSchemaIfNecessary);
Assert.AreEqual(true, result.Enable);
}
public Implementation(IHangfireContext hangfireContext, ConfigImpl configImpl, PersistenceSettings persistenceSettings, IBuilderSerializer deserializer, IEventWaitHandle waitHandle)
: this(hangfireContext, configImpl)
{
_persistence = persistenceSettings;
_deserializer = deserializer;
_eventWaitHandlerFactory = waitHandle;
}
private void InitializeVariables()
{
m_jsonEncrypter = new JsonEncryption();
m_dataStoreHash = new Dictionary <string, DataStore>();
m_settings = PersistenceSettings.GetPersistenceSettings();
m_prefabManager = new PrefabManager(m_settings);
}
private void Awake()
{
var settings = PersistenceSettings.GetPersistenceSettings();
m_persistenceSettings = settings;
serializedObject = new SerializedObject(settings);
}
public ApplicationSettings()
{
Hosting = new HostingSettings();
ServiceBus = new ServiceBusSettings();
InteropServiceBus = new ServiceBusSettings();
Logging = new LoggingSettings();
Persistence = new PersistenceSettings();
}
public PluginInfo Initialise(IntPtr apiInterfacePtr)
{
try
{
_mbApiInterface = new MusicBeeApiInterface();
_mbApiInterface.Initialise(apiInterfacePtr);
_about.PluginInfoVersion = PluginInfoVersion;
_about.Name = MusicBeeExporterConstants.Name;
_about.Description = MusicBeeExporterConstants.Description;
_about.Author = MusicBeeExporterConstants.Author;
_about.TargetApplication =
MusicBeeExporterConstants
.TargetApplication;
_about.Type = PluginType.General;
_about.VersionMajor = MusicBeeExporterConstants.VersionMajor;
_about.VersionMinor = MusicBeeExporterConstants.VersionMinor;
_about.Revision = MusicBeeExporterConstants.Revision;
_about.MinInterfaceVersion = MinInterfaceVersion;
_about.MinApiRevision = MinApiRevision;
_about.ReceiveNotifications =
ReceiveNotificationFlags.PlayerEvents | ReceiveNotificationFlags.TagEvents;
_about.ConfigurationPanelHeight =
MusicBeeExporterConstants.ConfigurationPanelHeight;
// Initialize the plugin after music bee api interface is initialized and the PersistentStoragePath is accessible
IPersistenceSettings persistenceSettings = new PersistenceSettings
{
MusicBeeAllocatedStoragePath = _mbApiInterface.Setting_GetPersistentStoragePath()
};
// Create Plugin Storage folder
Directory.CreateDirectory(persistenceSettings.PluginStorageDirectory);
_repo = new Persistence(persistenceSettings);
// Load exporter settings if it exists, otherwise create a new settings file.
var settingJson = _repo.LoadPluginSettings();
if (!string.IsNullOrWhiteSpace(settingJson))
{
_pluginSettings = JsonConvert.DeserializeObject <MusicBeeExporterSettings>(settingJson);
}
else
{
_pluginSettings = new MusicBeeExporterSettings(persistenceSettings);
_repo.SavePluginSettings(_pluginSettings);
}
CreateMenuItem();
}
catch (Exception ex)
{
UIHelper.DisplayExceptionDialog(ex);
}
return(_about);
}
private void Awake()
{
m_persistenceSettings = PersistenceSettings.GetPersistenceSettings();
m_persistentGameObject = (PersistentGameObject)target;
if (String.IsNullOrEmpty(m_persistentGameObject.ObjectId))
{
m_persistentGameObject.ObjectId = m_persistentGameObject.gameObject.name + "_" + Guid.NewGuid();
}
}
public static void ClearSaveFile()
{
var settings = PersistenceSettings.GetPersistenceSettings();
if (File.Exists(settings.FilePath))
{
File.Delete(settings.FilePath);
}
}
public void HangfireServer_Program_ConnectionString_Exists()
{
var args = new Args
{
ShowConsole = true,
};
var implConfig = SetupHangfireImplementationConfigs(out var mockWriter, out var mockPauseHelper, out var mockExecutionLogPublisher);
var dbSource = new DbSource
{
ConnectionString = "connectionString",
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = dbSource.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var mockSerializer = new Mock <IBuilderSerializer>();
var mockFile = new Mock <IFile>();
var mockDirectory = new Mock <IDirectory>();
var persistenceSettings = new PersistenceSettings("some path", mockFile.Object, mockDirectory.Object)
{
Enable = false,
PersistenceDataSource = new NamedGuidWithEncryptedPayload
{
Name = "Data Source", Value = Guid.Empty, Payload = serializeToJsonString
},
};
mockSerializer.Setup(o => o.Deserialize <DbSource>(persistenceSettings.PersistenceDataSource.Payload)).Returns(dbSource).Verifiable();
var mockContext = new HangfireContext(args);
var mockEventWaitHandle = new Mock <IEventWaitHandle>();
mockEventWaitHandle.Setup(o => o.New()).Verifiable();
mockEventWaitHandle.Setup(o => o.WaitOne()).Verifiable();
var item = new Implementation(mockContext, implConfig, persistenceSettings, mockSerializer.Object, mockEventWaitHandle.Object);
item.Run();
mockWriter.Verify(o => o.WriteLine("Starting Hangfire server..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Starting Hangfire server..."), Times.Once);
mockSerializer.Verify(o => o.Deserialize <DbSource>(persistenceSettings.PersistenceDataSource.Payload), Times.Once);
mockWriter.Verify(o => o.WriteLine("Hangfire dashboard started..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Hangfire dashboard started..."), Times.Once);
mockWriter.Verify(o => o.WriteLine("Hangfire server started..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Hangfire server started..."), Times.Once);
mockPauseHelper.Verify(o => o.Pause(), Times.Never);
mockEventWaitHandle.Verify(o => o.New(), Times.Never);
mockEventWaitHandle.Verify(o => o.WaitOne(), Times.Never);
}
public ManualResumptionActivity(PersistenceSettings config, IPersistenceExecution resumeExecution)
{
DisplayName = "Manual Resumption";
OverrideDataFunc = new ActivityFunc <string, bool>
{
DisplayName = "Data Action",
Argument = new DelegateInArgument <string>($"explicitData_{DateTime.Now:yyyyMMddhhmmss}"),
};
_persistenceEnabled = config.Enable;
_scheduler = resumeExecution;
}
public SuspendExecutionActivity(PersistenceSettings config, IPersistenceExecution suspendExecution)
{
DisplayName = "Suspend Execution";
SaveDataFunc = new ActivityFunc <string, bool>
{
DisplayName = "Data Action",
Argument = new DelegateInArgument <string>($"explicitData_{DateTime.Now:yyyyMMddhhmmss}"),
};
_persistenceEnabled = config.Enable;
_scheduler = suspendExecution;
}
public static bool OnOpenAsset(int instanceId, int line)
{
PersistenceSettings persistenceSettings = EditorUtility.InstanceIDToObject(instanceId) as PersistenceSettings;
if (persistenceSettings != null)
{
OpenSettingsWindow();
return(true);
}
return(false);
}
public void ManualResumptionActivity_Execute_PersistenceNotConfigured_FailWithMessage()
{
//------------Setup for test--------------------------
var resourceId = Guid.NewGuid();
var workflowInstanceId = Guid.NewGuid();
var mockStateNotifier = new Mock <IStateNotifier>();
mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny <IDev2Activity>()));
var env = CreateExecutionEnvironment();
env.Assign("[[UUID]]", "public", 0);
env.Assign("[[JourneyName]]", "whatever", 0);
var environmentId = Guid.Empty;
User = new Mock <IPrincipal>().Object;
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServiceName = "workflowName",
ResourceID = resourceId,
WorkflowInstanceId = workflowInstanceId,
WebUrl = "url",
ServerID = Guid.NewGuid(),
ExecutingUser = User,
IsDebug = true,
EnvironmentID = environmentId,
Environment = env,
IsRemoteInvokeOverridden = false,
DataList = new StringBuilder(CurrentDl),
IsServiceTestExecution = true
};
var config = new PersistenceSettings
{
Enable = false
};
var manualResumptionActivity = new ManualResumptionActivity(config, new Mock <IPersistenceExecution>().Object)
{
Response = "[[result]]",
OverrideInputVariables = false,
SuspensionId = "321"
};
manualResumptionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
manualResumptionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
Assert.AreEqual(1, dataObject.Environment.AllErrors.Count);
var errors = dataObject.Environment.AllErrors.ToList();
Assert.AreEqual("Failed", manualResumptionActivity.Response);
Assert.AreEqual(errors[0], "<InnerError>Could not find persistence config. Please configure in Persistence Settings.</InnerError>");
}
public CandlesPersistenceManager(
ICandlesPersistenceQueue persistenceQueue,
IHealthService healthService,
ILog log,
PersistenceSettings settings) :
base(nameof(CandlesPersistenceManager), (int)TimeSpan.FromSeconds(5).TotalMilliseconds, log)
{
_persistenceQueue = persistenceQueue;
_healthService = healthService;
_settings = settings;
_lastDispatchMoment = DateTime.MinValue;
}
public static void OpenSaveFolder()
{
var settings = PersistenceSettings.GetPersistenceSettings();
ProcessStartInfo startInformation = new ProcessStartInfo();
if (!Directory.Exists(settings.FileFolder))
{
Directory.CreateDirectory(settings.FileFolder);
}
startInformation.FileName = settings.FileFolder;
Process.Start(startInformation);
}
public CandlesPersistenceQueue(
ICandlesHistoryRepository repository,
ILogFactory logFactory,
IHealthService healthService,
PersistenceSettings settings) :
base(logFactory, nameof(CandlesPersistenceQueue))
{
_repository = repository;
_log = logFactory.CreateLog(this);
_healthService = healthService;
_settings = settings;
_candlesToDispatch = new ConcurrentQueue <ICandle>();
}
public CandlesPersistenceManager(
ICandlesPersistenceQueue persistenceQueue,
IHealthService healthService,
ILogFactory logFactory,
PersistenceSettings settings) :
base(TimeSpan.FromSeconds(5), logFactory, nameof(CandlesPersistenceManager))
{
_persistenceQueue = persistenceQueue;
_healthService = healthService;
_settings = settings;
_lastDispatchMoment = DateTime.MinValue;
}
public CandlesPersistenceQueue(
ICandlesHistoryRepository repository,
ILog log,
IHealthService healthService,
PersistenceSettings settings) :
base(nameof(CandlesPersistenceQueue), log)
{
_repository = repository;
_log = log;
_healthService = healthService;
_settings = settings;
_candlesToDispatch = new ConcurrentQueue <ICandle>();
}
public RavenDbContext(IOptionsMonitor <PersistenceSettings> settings)
{
_persistenceSettings = settings.CurrentValue;
_localStore = new DocumentStore()
{
Database = _persistenceSettings.DatabaseName,
Urls = _persistenceSettings.Urls
};
_localStore.Initialize();
EnsureDatabaseIsCreated();
}
/// <summary>
/// The AddPersistence
/// </summary>
/// <param name="services">The services<see cref="IServiceCollection"/></param>
/// <param name="configuration">The configuration<see cref="IConfiguration"/></param>
/// <returns>The <see cref="IServiceCollection"/></returns>
public static IServiceCollection AddPersistence(
this IServiceCollection services,
IConfiguration configuration)
{
bool useFake = configuration.GetValue <bool>("PersistenceModule:UseFake");
var persistenceSettings = new PersistenceSettings {
SqlDbConnectionString = configuration.GetValue <string>("ConnectionStrings:SqlDb"),
NoSqlDbConnectionString = configuration.GetValue <string>("ConnectionStrings:EmbeddedDb")
};
services.AddSingleton <PersistenceSettings>(persistenceSettings);
services.AddDbContext <SqlDataContext>(x => x.UseSqlServer(persistenceSettings.SqlDbConnectionString));
services.AddScoped <IUserRepository, Infrastructure.SqlServerDataAccess.Repositories.UserRepository>();
return(services);
}
public void PersistenceSettings_SaveIfNotExists()
{
var mockIFile = new Mock <IFile>();
mockIFile.Setup(o => o.Exists(It.IsAny <string>())).Returns(false).Verifiable();
mockIFile.Setup(o => o.WriteAllText(PersistenceSettings.SettingsPath, It.IsAny <string>()));
var mockDirectory = new Mock <IDirectory>();
mockDirectory.Setup(o => o.CreateIfNotExists(Path.GetDirectoryName(PersistenceSettings.SettingsPath))).Returns(PersistenceSettings.SettingsPath);
//act
var settings = new PersistenceSettings("some path", mockIFile.Object, mockDirectory.Object);
settings.SaveIfNotExists();
//assert
mockIFile.Verify();
mockDirectory.Verify();
}
public void HangfireServer_Program_ConnectionString_Payload_Empty_WaitOne()
{
var args = new Args
{
ShowConsole = false,
};
var implConfig = SetupHangfireImplementationConfigs(out var mockWriter, out var mockPauseHelper, out var mockExecutionLogPublisher);
var mockFile = new Mock <IFile>();
var mockDirectory = new Mock <IDirectory>();
var persistenceSettings = new PersistenceSettings("", mockFile.Object, mockDirectory.Object);
var mockContext = new HangfireContext(args);
var mockEventWaitHandle = new Mock <IEventWaitHandle>();
mockEventWaitHandle.Setup(o => o.New()).Verifiable();
mockEventWaitHandle.Setup(o => o.WaitOne()).Verifiable();
var item = new Implementation(mockContext, implConfig, persistenceSettings, new Mock <IBuilderSerializer>().Object, mockEventWaitHandle.Object);
item.Run();
item.WaitForExit();
mockWriter.Verify(o => o.WriteLine("Starting Hangfire server..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Starting Hangfire server..."), Times.Once);
mockWriter.Verify(o => o.WriteLine("Fatal Error: Could not find persistence config file. Hangfire server is unable to start."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Error("Fatal Error: Could not find persistence config file. Hangfire server is unable to start."), Times.Once);
mockWriter.Verify(o => o.Write("Press any key to exit..."), Times.Once);
mockPauseHelper.Verify(o => o.Pause(), Times.Never);
mockWriter.Verify(o => o.WriteLine("Hangfire dashboard started..."), Times.Never);
mockExecutionLogPublisher.Verify(o => o.Info("Hangfire dashboard started..."), Times.Never);
mockWriter.Verify(o => o.WriteLine("Hangfire server started..."), Times.Never);
mockExecutionLogPublisher.Verify(o => o.Info("Hangfire server started..."), Times.Never);
mockEventWaitHandle.Verify(o => o.New(), Times.Never);
mockEventWaitHandle.Verify(o => o.WaitOne(), 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);
}
public void SuspendExecutionActivity_Execute_PersistenceNotConfigured_FailWithMessage()
{
//------------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;
User = new Mock<IPrincipal>().Object;
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServiceName = workflowName,
ResourceID = resourceId,
WorkflowInstanceId = workflowInstanceId,
WebUrl = url,
ServerID = Guid.NewGuid(),
ExecutingUser = User,
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 suspendUntil = DateTime.Now.AddDays(1);
var config = new PersistenceSettings
{
Enable = false
};
var suspendExecutionActivity = new SuspendExecutionActivity(config, new Mock<IPersistenceExecution>().Object)
{
SuspendOption = enSuspendOption.SuspendUntil,
PersistValue = suspendUntil.ToString(),
AllowManualResumption = true,
SaveDataFunc = activityFunction,
Result = "[[SuspendID]]",
NextNodes = dev2Activities
};
suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
suspendExecutionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
suspendExecutionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
Assert.AreEqual(1, env.AllErrors.Count);
var errors = env.AllErrors.ToList();
Assert.AreEqual(ErrorResource.PersistenceSettingsNoConfigured, errors[0]);
}
public void SuspendExecutionActivity_Execute_EncryptData_False()
{
//------------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 suspendUntil = DateTime.Now.AddDays(1);
var config = new PersistenceSettings
{
Enable = true
};
var currentEnvironment = dataObject.Environment.ToJson();
var values = new Dictionary<string, StringBuilder>
{
{"resourceID", new StringBuilder(dataObject.ResourceID.ToString())},
{"environment", new StringBuilder(currentEnvironment)},
{"startActivityId", new StringBuilder(nextNodeId.ToString())},
{"versionNumber", new StringBuilder(dataObject.VersionNumber.ToString())},
{"currentuserprincipal", new StringBuilder(WindowsIdentity.GetCurrent().Name)}
};
var mockSuspendExecution = new Mock<IPersistenceExecution>();
mockSuspendExecution.Setup(o => o.CreateAndScheduleJob(enSuspendOption.SuspendUntil, suspendUntil.ToString(), values)).Verifiable();
var suspendExecutionActivity = new SuspendExecutionActivity(config, mockSuspendExecution.Object)
{
SuspendOption = enSuspendOption.SuspendUntil,
PersistValue = suspendUntil.ToString(),
AllowManualResumption = true,
EncryptData = false,
SaveDataFunc = activityFunction,
//Result = "[[SuspendID]]",
NextNodes = dev2Activities
};
suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
suspendExecutionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
Assert.AreEqual(0, env.Errors.Count);
GetScalarValueFromEnvironment(env, "SuspendID", out string suspendId, out string error);
Assert.AreEqual(suspendId, suspendExecutionActivity.Response);
//TODO: We need to improve on this verify to validate that the environment is not encrypted. Verify fails for unknown mismatch
mockSuspendExecution.Verify(o => o.CreateAndScheduleJob(enSuspendOption.SuspendUntil, suspendUntil.ToString(), It.IsAny<Dictionary<string, StringBuilder>>()), Times.Once);
}
public void SuspendExecutionActivity_Execute_SuspendForSeconds_SaveSuspendIDIntoEnv_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;
User = GlobalConstants.GenericPrincipal;
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServiceName = workflowName,
ResourceID = resourceId,
WorkflowInstanceId = workflowInstanceId,
WebUrl = url,
ServerID = Guid.NewGuid(),
ExecutingUser = User,
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 suspendExecutionActivity = new SuspendExecutionActivity(config, new Mock<IPersistenceExecution>().Object)
{
SuspendOption = enSuspendOption.SuspendForSeconds,
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);
GetScalarValueFromEnvironment(env, "SuspendID", out string suspendId, out string error);
Assert.AreEqual(suspendId, suspendExecutionActivity.Response);
}
public void SuspendExecutionActivity_Execute_Empty_SuspendOptionValue()
{
//------------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 suspendExecutionActivity =
new SuspendExecutionActivity(config, new Mock<IPersistenceExecution>().Object)
{
SuspendOption = enSuspendOption.SuspendUntil,
PersistValue = string.Empty,
AllowManualResumption = true,
SaveDataFunc = activityFunction,
NextNodes = dev2Activities,
};
suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
suspendExecutionActivity.Execute(dataObject, 0);
Assert.AreEqual(null, suspendExecutionActivity.Response);
Assert.AreEqual(1, env.Errors.Count());
var errors = env.Errors.ToList();
Assert.AreEqual("Suspend option Date value must not be null or empty.", errors[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlDataContext"/> class.
/// </summary>
/// <param name="options">The options<see cref="DbContextOptions{SqlDataContext}"/></param>
public SqlDataContext(DbContextOptions <SqlDataContext> options, PersistenceSettings persistenceSettings) : base(options)
{
_persistenceSettings = persistenceSettings;
}
protected AtLeastOnceDeliveryActor(PersistenceSettings.AtLeastOnceDeliverySettings settings)
{
_atLeastOnceDeliverySemantic = new AtLeastOnceDeliverySemantic(Context, settings);
}
public void ManualResumptionActivity_Execute_OverrideInputVariables_NonVariableInput_True_Success()
{
//------------Setup for test--------------------------
var activity = CreateWorkflowNoVariable();
var activityFunction = new ActivityFunc <string, bool>
{
DisplayName = activity.DisplayName,
Handler = activity,
};
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]]", "1234", 0);
env.Assign("[[JourneyName]]", "whatever", 0);
var mockStateNotifier = new Mock <IStateNotifier>();
mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny <IDev2Activity>()));
var environmentId = Guid.Empty;
User = new Mock <IPrincipal>().Object;
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServiceName = workflowName,
ResourceID = resourceId,
WorkflowInstanceId = workflowInstanceId,
WebUrl = url,
ServerID = Guid.NewGuid(),
ExecutingUser = User,
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 config = new PersistenceSettings
{
Enable = true
};
var suspensionId = "321";
var overrideInputVariables = true;
var overrideEnvironment = env.ToJson();
var mockResumeJob = new Mock <IPersistenceExecution>();
mockResumeJob.Setup(o => o.ResumeJob(dataObject, suspensionId, overrideInputVariables, overrideEnvironment)).Verifiable();
var manualResumptionActivity = new ManualResumptionActivity(config, mockResumeJob.Object)
{
Response = "[[result]]",
OverrideInputVariables = overrideInputVariables,
SuspensionId = suspensionId,
OverrideDataFunc = activityFunction,
};
manualResumptionActivity.SetStateNotifier(mockStateNotifier.Object);
//------------Execute Test---------------------------
manualResumptionActivity.Execute(dataObject, 0);
//------------Assert Results-------------------------
Assert.AreEqual(0, dataObject.Environment.AllErrors.Count);
mockResumeJob.Verify(o => o.ResumeJob(dataObject, suspensionId, overrideInputVariables, overrideEnvironment), Times.Once);
}
