/// <summary> /// Fetches the type of the execution. /// </summary> /// <param name="dataObject">The data object.</param> /// <param name="environment"></param> /// <param name="errors">The errors.</param> /// <param name="update"></param> /// <returns></returns> private ForEachBootstrapTO FetchExecutionType(IDSFDataObject dataObject, IExecutionEnvironment environment, out ErrorResultTO errors, int update) { if (dataObject.IsDebugMode()) { var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams(ForEachType.GetDescription(), ""), debugItem); if (ForEachType == enForEachType.NumOfExecution && !string.IsNullOrEmpty(NumOfExections)) { AddDebugItem(new DebugEvalResult(NumOfExections, "Number", environment, update), debugItem); } if (ForEachType == enForEachType.InCSV && !string.IsNullOrEmpty(CsvIndexes)) { AddDebugItem(new DebugEvalResult(CsvIndexes, "Csv Indexes", environment, update), debugItem); } if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(From)) { AddDebugItem(new DebugEvalResult(From, "From", environment, update), debugItem); } if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(To)) { AddDebugItem(new DebugEvalResult(To, "To", environment, update), debugItem); } if (ForEachType == enForEachType.InRecordset && !string.IsNullOrEmpty(Recordset)) { AddDebugItem(new DebugEvalResult(ExecutionEnvironment.GetPositionColumnExpression(Recordset), "Recordset ", environment, update), debugItem); } _debugInputs.Add(debugItem); } var result = new ForEachBootstrapTO(ForEachType, From, To, CsvIndexes, NumOfExections, Recordset, environment, out errors, update); return(result); }
public void ForEachBootstrapTO_Constructor_IsNewRecordSetNoValue_AddError() { //------------Setup for test-------------------------- ErrorResultTO errors; var envMock = new ExecutionEnvironment(); var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRecordset, "", "", "", "", "", envMock, out errors, 0); //------------Execute Test--------------------------- Assert.IsNotNull(forEachBootstrapTO); //------------Assert Results------------------------- Assert.IsNotNull(errors); Assert.AreEqual(1, errors.FetchErrors().Count); }
public void ForEachBootstrapTO_Constructor_IsNewInRangeMinAndMax_NoError() { //------------Setup for test-------------------------- ErrorResultTO errors; var envMock = new ExecutionEnvironment(); var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRange, "1", "3", "", "", "", envMock, out errors, 0); //------------Execute Test--------------------------- Assert.IsNotNull(forEachBootstrapTO); //------------Assert Results------------------------- Assert.IsNotNull(errors); Assert.AreEqual(0, errors.FetchErrors().Count); }
public void ForEachBootstrapTO_Constructor_IsNewCsvValue_NoError() { //------------Setup for test-------------------------- ErrorResultTO errors; var envMock = new ExecutionEnvironment(); var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InCSV, "", "", "1,2,3", "", "", envMock, out errors, 0); //------------Execute Test--------------------------- Assert.IsNotNull(forEachBootstrapTO); //------------Assert Results------------------------- Assert.IsNotNull(errors); Assert.AreEqual(0, errors.FetchErrors().Count); Assert.AreEqual(forEachBootstrapTO.ExeType, enForEachExecutionType.Scalar); }
public void ForEachBootstrapTO_Constructor_IsNewRecordSetValue_NoError() { //------------Setup for test-------------------------- ErrorResultTO errors; var envMock = new ExecutionEnvironment(); envMock.Assign("[[rec().a]]", "Hello There", 1); var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRecordset, "", "", "", "", "[[rec()]]", envMock, out errors, 0); //------------Execute Test--------------------------- Assert.IsNotNull(forEachBootstrapTO); //------------Assert Results------------------------- Assert.IsNotNull(errors); Assert.AreEqual(0, errors.FetchErrors().Count); }
public void ForEachBootstrapTO_Constructor_IsNewRecordSetNoValueNoInVaribaleList_AddError() { //------------Setup for test-------------------------- ErrorResultTO errors; var envMock = new Mock <IExecutionEnvironment>(); envMock.Setup(environment => environment.EvalRecordSetIndexes("[[rec2()]]", It.IsAny <int>())).Verifiable(); envMock.Setup(environment => environment.HasRecordSet("[[rec2()]]")).Returns(false).Verifiable(); var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRecordset, "", "", "", "", "[[rec2()]]", envMock.Object, out errors, 0); //------------Execute Test--------------------------- Assert.IsNotNull(forEachBootstrapTO); //------------Assert Results------------------------- Assert.IsNotNull(errors); Assert.AreEqual(1, errors.FetchErrors().Count); }
/// <summary> /// Fetches the type of the execution. /// </summary> /// <param name="dataObject">The data object.</param> /// <param name="dlId">The dl ID.</param> /// <param name="compiler">The compiler.</param> /// <param name="errors">The errors.</param> /// <returns></returns> private ForEachBootstrapTO FetchExecutionType(IDSFDataObject dataObject, Guid dlId, IDataListCompiler compiler, out ErrorResultTO errors) { if (dataObject.IsDebugMode()) { var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams(ForEachType.GetDescription(), ""), debugItem); if (ForEachType == enForEachType.NumOfExecution && !string.IsNullOrEmpty(NumOfExections)) { IBinaryDataListEntry numOfExectionsEntry = compiler.Evaluate(dlId, enActionType.User, NumOfExections, false, out errors); AddDebugItem(new DebugItemVariableParams(NumOfExections, "Number", numOfExectionsEntry, dlId), debugItem); } if (ForEachType == enForEachType.InCSV && !string.IsNullOrEmpty(CsvIndexes)) { IBinaryDataListEntry csvIndexesEntry = compiler.Evaluate(dlId, enActionType.User, CsvIndexes, false, out errors); AddDebugItem(new DebugItemVariableParams(CsvIndexes, "Csv Indexes", csvIndexesEntry, dlId), debugItem); } if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(From)) { IBinaryDataListEntry fromEntry = compiler.Evaluate(dlId, enActionType.User, From, false, out errors); AddDebugItem(new DebugItemVariableParams(From, "From", fromEntry, dlId), debugItem); } if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(To)) { IBinaryDataListEntry toEntry = compiler.Evaluate(dlId, enActionType.User, To, false, out errors); AddDebugItem(new DebugItemVariableParams(To, "To", toEntry, dlId), debugItem); } if (ForEachType == enForEachType.InRecordset && !string.IsNullOrEmpty(Recordset)) { var toEmit = Recordset.Replace("()", "(*)"); IBinaryDataListEntry toEntry = compiler.Evaluate(dlId, enActionType.User, toEmit, false, out errors); AddDebugItem(new DebugItemVariableParams(toEmit, "Recordset", toEntry, dlId), debugItem); } _debugInputs.Add(debugItem); } var result = new ForEachBootstrapTO(ForEachType, From, To, CsvIndexes, NumOfExections, Recordset, dlId, compiler, out errors); return(result); }
protected override void ExecuteTool(IDSFDataObject dataObject, int update) { _previousParentId = dataObject.ParentInstanceID; _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); ErrorResultTO allErrors = new ErrorResultTO(); IIndexIterator itr = null; InitializeDebug(dataObject); dataObject.ForEachNestingLevel++; try { ErrorResultTO errors; ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors, update); foreach (var err in errors.FetchErrors()) { dataObject.Environment.AddError(err); } itr = exePayload.IndexIterator; string error; ForEachInnerActivityTO innerA = GetInnerActivity(out error); var exeAct = innerA?.InnerActivity; allErrors.AddError(error); if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before, update); } dataObject.ParentInstanceID = UniqueID; dataObject.IsDebugNested = true; if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.After, update); } exePayload.InnerActivity = innerA; while (itr?.HasMore() ?? false) { operationalData = exePayload; int idx = exePayload.IndexIterator.FetchNextIndex(); int innerupdate = 0; if (exePayload.ForEachType != enForEachType.NumOfExecution) { innerupdate = idx; } _childUniqueID = exeAct?.UniqueID; exeAct?.Execute(dataObject, innerupdate); operationalData.IncIterationCount(); } if (errors.HasErrors()) { allErrors.MergeErrors(errors); } } catch (Exception e) { Dev2Logger.Error("DSFForEach", e); allErrors.AddError(e.Message); } finally { if (itr != null) { if (ForEachType != enForEachType.NumOfExecution) { RestoreHandlerFn(); } } var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.UniqueId == _originalUniqueID); if (dataObject.IsServiceTestExecution) { var serviceTestSteps = serviceTestStep?.Children; UpdateDebugStateWithAssertions(dataObject, serviceTestSteps?.ToList()); if (serviceTestStep != null) { var testRunResult = new TestRunResult(); GetFinalTestRunResult(serviceTestStep, testRunResult); serviceTestStep.Result = testRunResult; } } dataObject.ParentInstanceID = _previousParentId; dataObject.ForEachNestingLevel--; dataObject.IsDebugNested = false; if (dataObject.IsDebugMode()) { if (dataObject.IsServiceTestExecution && serviceTestStep != null) { var debugItems = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName); debugItems = debugItems.Where(state => state.WorkSurfaceMappingId == serviceTestStep.UniqueId).ToList(); var debugStates = debugItems.LastOrDefault(); var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(serviceTestStep.Result.Message, serviceTestStep.Result.RunTestResult == RunResult.TestFailed); DebugItem itemToAdd = new DebugItem(); itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult()); debugStates?.AssertResultList?.Add(itemToAdd); } DispatchDebugState(dataObject, StateType.Duration, 0); } // Handle Errors if (allErrors.HasErrors()) { dataObject.ParentInstanceID = _previousParentId; dataObject.ForEachNestingLevel--; dataObject.IsDebugNested = false; // Handle Errors if (allErrors.HasErrors()) { DisplayAndWriteError("DsfForEachActivity", allErrors); foreach (var fetchError in allErrors.FetchErrors()) { dataObject.Environment.AddError(fetchError); } dataObject.ParentInstanceID = _previousParentId; } } } }
protected override void OnExecute(NativeActivityContext context) { lock (_forEachExecutionObject) { IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); dataObject.ForEachNestingLevel++; ErrorResultTO allErrors = new ErrorResultTO(); InitializeDebug(dataObject); try { ErrorResultTO errors; ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors, 0); if (errors.HasErrors()) { allErrors.MergeErrors(errors); return; } if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before, 0); } dataObject.ParentInstanceID = UniqueID; allErrors.MergeErrors(errors); string error; ForEachInnerActivityTO innerA = GetInnerActivity(out error); allErrors.AddError(error); exePayload.InnerActivity = innerA; operationalData = exePayload; // flag it as scoped so we can use a single DataList dataObject.IsDataListScoped = true; dataObject.IsDebugNested = true; if (exePayload.InnerActivity != null && exePayload.IndexIterator.HasMore()) { int idx = exePayload.IndexIterator.FetchNextIndex(); if (exePayload.ForEachType != enForEachType.NumOfExecution) { IterateIOMapping(idx); } else { dataObject.IsDataListScoped = false; } // schedule the func to execute ;) dataObject.ParentInstanceID = UniqueID; context.ScheduleFunc(DataFunc, string.Empty, ActivityCompleted); } } catch (Exception e) { Dev2Logger.Error("DSFForEach", e); allErrors.AddError(e.Message); } finally { // Handle Errors if (allErrors.HasErrors()) { DisplayAndWriteError("DsfForEachActivity", allErrors); foreach (var fetchError in allErrors.FetchErrors()) { dataObject.Environment.AddError(fetchError); } dataObject.ParentInstanceID = _previousParentId; } if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.After, 0); } } } }
protected override void ExecuteTool(IDSFDataObject dataObject) { _previousParentId = dataObject.ParentInstanceID; _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); dataObject.ForEachNestingLevel++; ErrorResultTO allErrors = new ErrorResultTO(); InitializeDebug(dataObject); try { ErrorResultTO errors; ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors); var itr = exePayload.IndexIterator; string error; ForEachInnerActivityTO innerA = GetInnerActivity(out error); var exeAct = innerA.InnerActivity; allErrors.AddError(error); if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before); } dataObject.ParentInstanceID = UniqueID; dataObject.IsDebugNested = true; if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.After); } exePayload.InnerActivity = innerA; var ind = itr.MaxIndex(); var count = 0; while (itr.HasMore() && count < ind) { operationalData = exePayload; int idx = exePayload.IndexIterator.FetchNextIndex(); if (exePayload.ForEachType != enForEachType.NumOfExecution) { IterateIOMapping(idx); } exeAct.Execute(dataObject); count++; } if (errors.HasErrors()) { allErrors.MergeErrors(errors); } } catch (Exception e) { Dev2Logger.Log.Error("DSFForEach", e); allErrors.AddError(e.Message); } finally { if (ForEachType != enForEachType.NumOfExecution) { RestoreHandlerFn(); } dataObject.ParentInstanceID = _previousParentId; dataObject.ForEachNestingLevel--; dataObject.IsDebugNested = false; // Handle Errors if (allErrors.HasErrors()) { DisplayAndWriteError("DsfForEachActivity", allErrors); foreach (var fetchError in allErrors.FetchErrors()) { dataObject.Environment.AddError(fetchError); } dataObject.ParentInstanceID = _previousParentId; } } }