private static void ExecuteNode(IDSFDataObject dsfDataObject, int update, ref IDev2Activity next, ref IDev2Activity lastActivity)
{
var environment = dsfDataObject.Environment;
try
{
Dev2Logger.Debug("Executing first node", GlobalConstants.WarewolfDebug);
while (next != null)
{
var current = next;
lastActivity = current;
next = ExecuteTool(dsfDataObject, current, update);
environment.AllErrors.UnionWith(environment.Errors);
if (dsfDataObject.StopExecution)
{
dsfDataObject.StateNotifier?.LogStopExecutionState(lastActivity);
dsfDataObject.ExecutionException = new Exception(dsfDataObject.Environment.FetchErrors());
break;
}
}
}
catch (Exception exception)
{
Dev2Logger.Error(exception.Message, GlobalConstants.WarewolfError);
dsfDataObject.ExecutionException = new Exception(dsfDataObject.Environment.FetchErrors());
dsfDataObject.StateNotifier?.LogExecuteException(exception, lastActivity);
}
}
static void GetResults(IDev2Activity dsfActivityAbstractString, Dev2FindMissingStrategyFactory stratFac, List <string> results)
{
enFindMissingType findMissingType = dsfActivityAbstractString.GetFindMissingType();
IFindMissingStrategy strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(dsfActivityAbstractString));
}
public void LogStopExecutionState(IDev2Activity activity)
{
foreach (var stateListener in _stateListeners)
{
stateListener.LogStopExecutionState(activity);
}
}
public IDev2Activity Parse(DynamicActivity activity, Guid resourceIdGuid, bool failOnException = false)
{
if (HasActivityInCache(resourceIdGuid))
{
return(GetActivity(resourceIdGuid));
}
var dynamicActivity = activity;
if (dynamicActivity != null)
{
try
{
IDev2Activity act = _activityParser.Parse(dynamicActivity);
if (_cache.TryAdd(resourceIdGuid, act))
{
return(act);
}
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception err) //errors caught inside
// ReSharper restore EmptyGeneralCatchClause
{
Dev2Logger.Log.Error(err);
if (failOnException)
{
throw;
}
}
}
return(null);
}
public void LogPostExecuteState(IDev2Activity previousActivity, IDev2Activity nextActivity)
{
foreach (var stateListener in _stateListeners)
{
stateListener.LogPostExecuteState(previousActivity, nextActivity);
}
}
public void LogPreExecuteState(IDev2Activity nextActivity)
{
foreach (var stateListener in _stateListeners)
{
stateListener.LogPreExecuteState(nextActivity);
}
}
public void LogExecuteException(Exception e, IDev2Activity activity)
{
foreach (var stateListener in _stateListeners)
{
stateListener.LogExecuteException(e, activity);
}
}
public void LogExecuteCompleteState(IDev2Activity activity)
{
foreach (var stateListener in _stateListeners)
{
stateListener.LogExecuteCompleteState(activity);
}
}
/// <summary>
/// Gets all the fields for a specific activity
/// </summary>
/// <param name="activity">The activity that the fields will be retrieved from</param>
/// <returns>Returns all the fields in a list of strings</returns>
public List <string> GetActivityFields(object activity)
{
List <string> results = new List <string>();
Dev2FindMissingStrategyFactory stratFac = new Dev2FindMissingStrategyFactory();
DsfSequenceActivity sequenceActivity = activity as DsfSequenceActivity;
if (sequenceActivity != null)
{
foreach (var innerActivity in sequenceActivity.Activities)
{
IDev2Activity dsfActivityAbstractString = innerActivity as IDev2Activity;
if (dsfActivityAbstractString != null)
{
GetResults(dsfActivityAbstractString, stratFac, results);
}
}
}
IEnumerable <PropertyInfo> properties = StringAttributeRefectionUtils.ExtractAdornedProperties <FindMissingAttribute>(activity);
// ReSharper disable LoopCanBeConvertedToQuery
foreach (PropertyInfo propertyInfo in properties)
// ReSharper restore LoopCanBeConvertedToQuery
{
object property = propertyInfo.GetValue(activity, null);
if (property != null)
{
results.Add(property.ToString());
}
}
return(results);
}
DsfSelectAndApplyActivity SetupArguments(string currentDl, string testData, IDev2Activity activity, bool isInputMapping = false, string inputMapping = null)
{
//DsfActivity activity = inputMapping != null ? CreateWorkflow(inputMapping, isInputMapping) : CreateWorkflow();
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.Assign("[[Person().Name]]", "Bob", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Dora", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Superman", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Batman", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Orlando", 0);
const string dataSource = "[[Person(*).Name]]";
const string alias = "[[a]]";
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity
{
DataSource = dataSource,
Alias = alias,
//ApplyActivityFunc = activity
};
var handler = activity as Activity;
dsfSelectAndApplyActivity.ApplyActivityFunc.Handler = handler;
TestStartNode = new FlowStep
{
Action = dsfSelectAndApplyActivity
};
CurrentDl = testData;
TestData = currentDl;
return(dsfSelectAndApplyActivity);
}
static IDev2Activity ReplaceActivityWithMock(IDev2Activity resource, IServiceTestStep foundTestStep)
{
IDev2Activity overriddenActivity = null;
if (foundTestStep.ActivityType == typeof(DsfDecision).Name)
{
var serviceTestOutput = foundTestStep.StepOutputs.FirstOrDefault(output => output.Variable == GlobalConstants.ArmResultText);
if (serviceTestOutput != null)
{
overriddenActivity = new TestMockDecisionStep(resource.As <DsfDecision>())
{
NameOfArmToReturn = serviceTestOutput.Value
};
}
}
else if (foundTestStep.ActivityType == typeof(DsfSwitch).Name)
{
var serviceTestOutput = foundTestStep.StepOutputs.FirstOrDefault(output => output.Variable == GlobalConstants.ArmResultText);
if (serviceTestOutput != null)
{
overriddenActivity = new TestMockSwitchStep(resource.As <DsfSwitch>())
{
ConditionToUse = serviceTestOutput.Value
};
}
}
else
{
overriddenActivity = new TestMockStep(resource, foundTestStep.StepOutputs.ToList());
}
return(overriddenActivity);
}
public static bool FilterAuditLog(AuditLog auditLog, IDev2Activity previousActivity, IDev2Activity nextActivity)
{
var ret = FilterAuditLog(auditLog, previousActivity);
ret |= FilterAuditLog(auditLog, nextActivity);
return(ret);
}
static void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource, int update)
{
if (resource == null)
{
return;
}
var next = resource.Execute(dsfDataObject, update);
while (next != null)
{
if (!dsfDataObject.StopExecution)
{
next = next.Execute(dsfDataObject, update);
if (dsfDataObject.Environment.Errors.Count > 0)
{
foreach (var e in dsfDataObject.Environment.Errors)
{
dsfDataObject.Environment.AllErrors.Add(e);
}
}
}
else
{
break;
}
}
}
protected override void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource, int update)
{
var startAtActivity = FindActivity(resource) ?? throw new InvalidWorkflowException($"Resume Node not found. UniqueID:{_resumeActivityId}");
dsfDataObject.Environment = _resumeEnvironment;
base.EvalInner(dsfDataObject, startAtActivity, update);
}
public void GivenTheUnderlyingDroppedActivityIsANTool(string tool)
{
IDev2Activity innerActivity = null;
switch (tool)
{
case "SelectAndApplyTestTool":
innerActivity = new SelectAndApplyTestTool();
break;
case "Activity":
innerActivity = new DsfActivity
{
InputMapping = BuildInputMappings(),
OutputMapping = BuildOutputMappings(),
ServiceName = "SpecflowForeachActivityTest"
};
break;
default:
break;
}
scenarioContext.Add("innerActivity", innerActivity);
}
override protected void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource, int update)
{
try
{
AddExecutionToExecutionManager(dsfDataObject, resource);
WorkflowExecutionWatcher.HasAWorkflowBeenExecuted = true;
Dev2Logger.Debug("Starting Execute", GlobalConstants.WarewolfDebug);
var lastActivity = resource;
ExecuteNode(dsfDataObject, update, ref resource, ref lastActivity);
if (!dsfDataObject.StopExecution & dsfDataObject.ExecutionException is null)
{
dsfDataObject.StateNotifier?.LogExecuteCompleteState(lastActivity);
}
}
finally
{
dsfDataObject.StateNotifier?.Dispose();
_executionManager?.CompleteExecution();
}
}
static void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource, int update)
{
if (resource == null)
{
throw new InvalidOperationException(GlobalConstants.NoStartNodeError);
}
WorkflowExecutionWatcher.HasAWorkflowBeenExecuted = true;
var next = resource.Execute(dsfDataObject, update);
while (next != null)
{
if (!dsfDataObject.StopExecution)
{
next = next.Execute(dsfDataObject, update);
if (dsfDataObject.Environment.Errors.Count > 0)
{
foreach (var e in dsfDataObject.Environment.Errors)
{
dsfDataObject.Environment.AllErrors.Add(e);
}
}
}
else
{
break;
}
}
}
private static IDev2Activity ExecuteTool(IDSFDataObject dsfDataObject, IDev2Activity activity, int update)
{
if (activity is IStateNotifierRequired stateNotifierRequired)
{
stateNotifierRequired.SetStateNotifier(dsfDataObject.StateNotifier);
}
return(activity.Execute(dsfDataObject, update));
}
private void Eval(Guid resourceID, IDSFDataObject dataObject)
{
Dev2Logger.Debug("Getting Resource to Execute");
IDev2Activity resource = ResourceCatalog.Instance.Parse(TheWorkspace.ID, resourceID);
Dev2Logger.Debug("Got Resource to Execute");
EvalInner(dataObject, resource, dataObject.ForEachUpdateValue);
}
public void LogPostExecuteState(IDev2Activity previousActivity, IDev2Activity nextActivity)
{
_writer.WriteLine("header:LogPostExecuteState");
WriteHeader(previousActivity, nextActivity);
_dsfDataObject.LogState(_jsonTextWriter);
_jsonTextWriter.Flush();
_writer.WriteLine();
_writer.Flush();
}
public bool FilterLogEntry(AuditLog log, IDev2Activity activity)
{
if (log.WorkflowID.Equals(_workflowId) ||
log.WorkflowName.Equals(_workflowName))
{
return(true);
}
return(false);
}
public void LogExecuteException(Exception e, IDev2Activity activity)
{
_writer.WriteLine("header:LogExecuteException");
WriteHeader(activity, e);
_dsfDataObject.LogState(_jsonTextWriter);
_jsonTextWriter.Flush();
_writer.WriteLine();
_writer.Flush();
}
public void LogPreExecuteState(IDev2Activity nextActivity)
{
var auditLog = new AuditLog(_dsfDataObject, "LogPreExecuteState", null, null, nextActivity);
if (!FilterAuditLog(auditLog, nextActivity))
{
return;
}
LogAuditState(auditLog);
}
public void LogStopExecutionState(IDev2Activity activity)
{
var auditLog = new AuditLog(_dsfDataObject, "LogStopExecutionState", null, activity, null);
if (!FilterAuditLog(auditLog, activity))
{
return;
}
LogAuditState(auditLog);
}
public void LogExecuteException(Exception e, IDev2Activity activity)
{
var auditLog = new AuditLog(_dsfDataObject, "LogExecuteException", e.Message, activity, null);
if (!FilterAuditLog(auditLog, activity))
{
return;
}
LogAuditState(auditLog);
}
public TestAssertStep(IDev2Activity originalActivity, List <IServiceTestOutput> testOutputs)
{
_originalActivity = originalActivity;
_testOutputs = testOutputs;
var act = originalActivity as DsfBaseActivity;
if (act != null)
{
DisplayName = act.DisplayName;
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var dsfSwitchSwitches = _dsfSwitch.Switches;
var hasResult = false;
if (dataObject.IsDebugMode())
{
InitializeDebug(dataObject);
}
IDev2Activity activity = null;
if (ConditionToUse == "Default")
{
if (_dsfSwitch.Default != null)
{
activity = _dsfSwitch.Default.FirstOrDefault();
if (dataObject.IsDebugMode())
{
var debugItemStaticDataParams = new DebugItemStaticDataParams("Default", "", true);
AddDebugOutputItem(debugItemStaticDataParams);
AddDebugAssertResultItem(debugItemStaticDataParams);
}
hasResult = true;
}
}
else
{
if (dsfSwitchSwitches.ContainsKey(ConditionToUse))
{
activity = dsfSwitchSwitches[ConditionToUse];
if (dataObject.IsDebugMode())
{
var debugItemStaticDataParams = new DebugItemStaticDataParams(ConditionToUse, "", true);
AddDebugOutputItem(debugItemStaticDataParams);
AddDebugAssertResultItem(debugItemStaticDataParams);
}
hasResult = true;
}
}
if (dataObject.IsDebugMode() && hasResult)
{
DispatchDebugState(dataObject, StateType.After, update);
DispatchDebugState(dataObject, StateType.Duration, update);
}
if (!hasResult)
{
throw new ArgumentException($"No matching arm for Switch Mock. Mock Arm value '{ConditionToUse}'. Switch Arms: '{string.Join(",", dsfSwitchSwitches.Select(pair => pair.Key))}'.");
}
NextNodes = new List <IDev2Activity> {
activity
};
}
public TestMockStep(IDev2Activity originalActivity, List <IServiceTestOutput> outputs)
{
_originalActivity = originalActivity;
Outputs = outputs;
Act = originalActivity as DsfNativeActivity <string>;
if (Act != null)
{
DisplayName = Act.DisplayName;
UniqueID = Act.UniqueID;
ActualTypeName = originalActivity.GetType().Name;
}
}
public static bool FilterAuditLog(AuditLog auditLog, IDev2Activity activity)
{
foreach (var filter in Filters)
{
var pass = filter.FilterLogEntry(auditLog, activity);
if (pass)
{
return(true);
}
}
return(false);
}
private IServiceTestModelTO Eval(Guid resourceId, IDSFDataObject dataObject, IServiceTestModelTO test)
{
Dev2Logger.Debug("Getting Resource to Execute");
var resourceCatalog = ResourceCat ?? ResourceCatalog.Instance;
IDev2Activity resource = resourceCatalog.Parse(TheWorkspace.ID, resourceId);
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var execPlan = serializer.SerializeToBuilder(resource);
var clonedExecPlan = serializer.Deserialize <IDev2Activity>(execPlan);
Dev2Logger.Debug("Got Resource to Execute");
if (test != null)
{
var testPassed = true;
var canExecute = true;
var failureMessage = new StringBuilder();
if (ServerAuthorizationService.Instance != null)
{
var authorizationService = ServerAuthorizationService.Instance;
var hasView = authorizationService.IsAuthorized(AuthorizationContext.View, DataObject.ResourceID.ToString());
var hasExecute = authorizationService.IsAuthorized(AuthorizationContext.Execute, DataObject.ResourceID.ToString());
canExecute = hasExecute && hasView;
}
if (!canExecute)
{
dataObject.Environment.AllErrors.Add("Unauthorized to execute this resource.");
}
else
{
if (!dataObject.StopExecution)
{
dataObject.ServiceTest = test;
UpdateToPending(test.TestSteps);
EvalInner(dataObject, clonedExecPlan, dataObject.ForEachUpdateValue, test.TestSteps);
if (test.Outputs != null)
{
var dev2DecisionFactory = Dev2DecisionFactory.Instance();
var testRunResults = test.Outputs.SelectMany(output => GetTestRunResults(dataObject, output, dev2DecisionFactory)).ToList();
testPassed = testRunResults.All(result => result.RunTestResult == RunResult.TestPassed);
if (!testPassed)
{
failureMessage = failureMessage.Append(string.Join("", testRunResults.Select(result => result.Message).Where(s => !string.IsNullOrEmpty(s)).ToList()));
}
}
}
}
ValidateError(test, testPassed, failureMessage);
test.FailureMessage = failureMessage.ToString();
return(test);
}
throw new Exception($"Test {dataObject.TestName} for Resource {dataObject.ServiceName} ID {resourceId}");
}
static void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource,int update)
{
if(resource == null)
{
return;
}
var next = resource.Execute(dsfDataObject, update);
while(next != null)
{
if (!dsfDataObject.StopExecution)
{
next = next.Execute(dsfDataObject, update);
if(dsfDataObject.Environment.Errors.Count>0)
{
foreach(var e in dsfDataObject.Environment.Errors)
{
dsfDataObject.Environment.AllErrors.Add(e);
}
}
}
else
{
break;
}
}
}
static void GetResults(IDev2Activity dsfActivityAbstractString, Dev2FindMissingStrategyFactory stratFac, List<string> results)
{
enFindMissingType findMissingType = dsfActivityAbstractString.GetFindMissingType();
IFindMissingStrategy strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(dsfActivityAbstractString));
}
public abstract IExecutionEnvironment Execute(IDSFDataObject inputs,IDev2Activity activity);
public override IExecutionEnvironment Execute(IDSFDataObject inputs, IDev2Activity activity)
{
return null;
}
static void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource,int update)
{
if(resource == null)
{
return;
}
var next = resource.Execute(dsfDataObject, update);
while(next != null)
{
next = next.Execute(dsfDataObject, update);
}
}
