public bool ImportActivitiesGroupActivitiesFromRepository(ActivitiesGroup activitiesGroup, ObservableList <Activity> activitiesRepository, bool inSilentMode = true, bool keepOriginalTargetApplicationMapping = false, Activity indexActivity = null)
{
string missingActivities = string.Empty;
if (activitiesGroup != null && activitiesGroup.ActivitiesIdentifiers.Count == 0)
{
return(true);
}
//import Activities
if (activitiesGroup != null && activitiesRepository != null)
{
foreach (ActivityIdentifiers actIdent in activitiesGroup.ActivitiesIdentifiers)
{
Activity repoAct = activitiesRepository.Where(x => x.ActivityName == actIdent.ActivityName && x.Guid == actIdent.ActivityGuid).FirstOrDefault();
if (repoAct == null)
{
repoAct = activitiesRepository.Where(x => x.Guid == actIdent.ActivityGuid).FirstOrDefault();
}
if (repoAct == null)
{
repoAct = activitiesRepository.Where(x => x.ActivityName == actIdent.ActivityName).FirstOrDefault();
}
if (repoAct != null)
{
Activity actInstance = (Activity)repoAct.CreateInstance(true);
actInstance.ActivitiesGroupID = activitiesGroup.Name;
if (keepOriginalTargetApplicationMapping == false)
{
SetActivityTargetApplication(actInstance);
}
if (indexActivity == null && ActivitiesGroups.Count > 1)
{
this.AddActivity(actInstance);
}
else
{
this.AddActivity(actInstance, indexActivity);
}
actIdent.IdentifiedActivity = actInstance;
indexActivity = actInstance;
}
else
{
missingActivities += "'" + actIdent.ActivityName + "', ";
}
}
//notify on missing activities
if (missingActivities != string.Empty && inSilentMode == false)
{
missingActivities = missingActivities.TrimEnd(new char[] { ',', ' ' });
// AppReporter.ToUser(eUserMsgKey.PartOfActivitiesGroupActsNotFound, missingActivities);
return(false);
}
else
{
return(true);
}
}
//if (inSilentMode == false)
// AppReporter.ToUser(eUserMsgKey.ActivitiesGroupActivitiesNotFound);
return(false);
}
public void MoveActivityInGroupsTest2()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group2);
busFlow.AddActivity(activity3, group2);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group2);
busFlow.AddActivity(activity6, group3);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
busFlow.MoveActivityInGroup(activity5, 1);
//Assert
Assert.IsTrue(busFlow.Activities.IndexOf(activity5) == 1, "Validate Activity moved to correct index in Activities list");
Assert.IsTrue(group2.ActivitiesIdentifiers.IndexOf(group2.ActivitiesIdentifiers.Where(x => x.IdentifiedActivity == activity5).First()) == 0, "Validate Activity moved to correct indx in target group");
}
public abstract bool ExportActivitiesGroupToALM(ActivitiesGroup activtiesGroup, string uploadPath = null, bool performSaveAfterExport = false, BusinessFlow businessFlow = null);
public void MoveActivitiesGroupDownTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity6);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
group1.AddActivityToGroup(activity1);
group1.AddActivityToGroup(activity2);
group2.AddActivityToGroup(activity3);
group2.AddActivityToGroup(activity4);
group2.AddActivityToGroup(activity5);
group3.AddActivityToGroup(activity6);
//Act
busFlow.MoveActivitiesGroupDown(group1);
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups[0] == group2, "Validate group 2 moved to place 1");
Assert.IsTrue(busFlow.ActivitiesGroups[1] == group1, "Validate group 1 moved to place 2");
Assert.IsTrue(busFlow.Activities[0] == activity3, "Validate group 2 Activities moved up");
Assert.IsTrue(busFlow.Activities[1] == activity4, "Validate group 2 Activities moved up");
Assert.IsTrue(busFlow.Activities[2] == activity5, "Validate group 2 Activities moved up");
Assert.IsTrue(busFlow.Activities[3] == activity1, "Validate group 1 Activities moved down");
Assert.IsTrue(busFlow.Activities[4] == activity2, "Validate group 1 Activities moved down");
}
public void MoveActivityBetweenGroupsTest3()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group1);
busFlow.AddActivity(activity3, group2);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group3);
busFlow.AddActivity(activity6, group3);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
busFlow.MoveActivityBetweenGroups(activity6, group2, 2);
//Assert
Assert.IsTrue(group3.ActivitiesIdentifiers.Where(x => x.IdentifiedActivity == activity6).FirstOrDefault() == null, "Validate Activity removed from original group");
Assert.IsTrue(activity6.ActivitiesGroupID == group2.Name, "Validate Activity moved to target group");
Assert.IsTrue(busFlow.Activities.IndexOf(activity6) == 2, "Validate Activity moved to correct index in Activities list");
Assert.IsTrue(group2.ActivitiesIdentifiers.IndexOf(group2.ActivitiesIdentifiers.Where(x => x.IdentifiedActivity == activity6).First()) == 0, "Validate Activity moved to correct indx in target group");
}
public override bool ExportActivitiesGroupToALM(ActivitiesGroup activtiesGroup, string uploadPath = null, bool performSaveAfterExport = false)
{
throw new NotImplementedException();
}
public void GroupsOrderTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
group1.AddActivityToGroup(activity1);
group1.AddActivityToGroup(activity2);
group2.AddActivityToGroup(activity3);
group3.AddActivityToGroup(activity4);
group3.AddActivityToGroup(activity5);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups[0] == group1, "Validate first group is group 1 same as in Activities flow");
Assert.IsTrue(busFlow.ActivitiesGroups[1] == group2, "Validate first group is group 2 same as in Activities flow");
Assert.IsTrue(busFlow.ActivitiesGroups[2] == group3, "Validate first group is group 3 same as in Activities flow");
}
public TestCaseResource UpdateTestCase(long treeNodeId, ActivitiesGroup activtiesGroup, List <BaseResponseItem> matchingTC)
{
return(zephyrEntExportManager.UpdateTestCase(treeNodeId, activtiesGroup, matchingTC));
}
public TestCaseResource CreateTestCase(long treeNodeId, ActivitiesGroup activtiesGroup, Dictionary <string, string> testInstanceFields)
{
return(zephyrEntExportManager.CreateTestCase(treeNodeId, activtiesGroup, testInstanceFields));
}
// fix
public override void ActionEnd(uint eventTime, Act action, bool offlineMode = false)
{
// if user set special action log in output
if (action.EnableActionLogConfig)
{
if (mGingerRunnerLogger == null)
{
string loggerFile = Path.Combine(mExecutionLogger.ExecutionLogfolder, FileSystem.AppendTimeStamp("GingerLog.txt"));
mGingerRunnerLogger = new GingerRunnerLogger(loggerFile);
}
mGingerRunnerLogger.LogAction(action);
}
Activity currentActivity = null;
try
{
string executionLogFolder = string.Empty;
//if offline mode then execution logger path exists in action object so making executionLogFolder empty to avoid duplication of path.
if (!offlineMode)
{
executionLogFolder = mExecutionLogger.ExecutionLogfolder;
}
//ActionReport AR = new ActionReport(action, mContext);
//if action call the Shared actvity then mContext.Activity and mCurrentActivity will be different,so keeping the shared activity in temp variable
if (mContext.Activity != mCurrentActivity)
{
currentActivity = mContext.Activity;
}
mContext.Activity = mCurrentActivity;
Object AR = null;
if (this.Configuration.ExecutionLoggerConfigurationIsEnabled)
{
AR = mExecutionLogger.SetReportAction(action, mContext, this.ExecutedFrom, offlineMode);
//
// Defects Suggestion section (to be considered to remove to separate function)
//
if (action.Status == Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed)
{
if (WorkSpace.Instance.RunsetExecutor.DefectSuggestionsList.Where(z => z.FailedActionGuid == action.Guid).ToList().Count > 0)
{
return;
}
//
ActivitiesGroup currrentGroup = mContext.BusinessFlow.ActivitiesGroups.Where(x => x.Name == mCurrentActivity.ActivitiesGroupID).FirstOrDefault();
string currrentGroupName = string.Empty;
if (currrentGroup != null)
{
currrentGroupName = currrentGroup.Name;
}
//
List <string> screenShotsPathes = new List <string>();
bool isScreenshotButtonEnabled = false;
if ((action.ScreenShots != null) && (action.ScreenShots.Count > 0))
{
screenShotsPathes = action.ScreenShots.ToList();
isScreenshotButtonEnabled = true;
}
//
bool automatedOpeningFlag = false;
if (action.FlowControls.Where(x => x.FlowControlAction == eFlowControlAction.FailureIsAutoOpenedDefect && action.Status == Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed).ToList().Count > 0)
{
automatedOpeningFlag = true;
}
// OMG !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
StringBuilder description = new StringBuilder();
description.Append("<html><body><b>" + this.GingerData.GingerName + "<b><br>");
description.Append("<div><ul style='list - style - type:circle'><li><b>" + mContext.BusinessFlow.Name + " (failed)<b></li>");
if (currrentGroupName != string.Empty)
{
description.Append("<ul style = 'list - style - type:square'>");
this.mCurrentBusinessFlow.ActivitiesGroups.ToList().TakeWhile(x => x.Name != mCurrentActivity.ActivitiesGroupID).ToList().ForEach(r => { description.Append("<li>" + r.Name + "</li>"); });
description.Append("<li><b>" + currrentGroupName + " (failed)<b></li>");
description.Append("<ul style = 'list - style - type:upper-roman'>");
this.mCurrentBusinessFlow.Activities.Where(x => currrentGroup.ActivitiesIdentifiers.Select(z => z.ActivityGuid).ToList().Contains(x.Guid)).ToList().TakeWhile(x => x.Guid != mCurrentActivity.Guid).ToList().ForEach(r => { description.Append("<li>" + r.ActivityName + "</li>"); });
description.Append("<li><b>" + mCurrentActivity.ActivityName + " (failed)<b></li>");
description.Append("<ul style = 'list - style - type:disc'>");
mCurrentActivity.Acts.TakeWhile(x => x.Guid != action.Guid).ToList().ForEach(r => { description.Append("<li>" + r.Description + "</li>"); });
description.Append("<li><b><font color='#ff0000'b>" + action.Description + " (failed)</font><b></li></li></li></li></ul></ul></ul></ul></div></body></html>");
}
else
{
description.Append("<ul style = 'list - style - type:upper-roman'>");
mContext.BusinessFlow.Activities.TakeWhile(x => x.Guid != mCurrentActivity.Guid).ToList().ForEach(r => { description.Append("<li>" + r.ActivityName + "</li>"); });
description.Append("<li><b>" + mCurrentActivity.ActivityName + " (failed)<b></li>");
description.Append("<ul style = 'list - style - type:disc'>");
mCurrentActivity.Acts.TakeWhile(x => x.Guid != action.Guid).ToList().ForEach(r => { description.Append("<li>" + r.Description + "</li>"); });
description.Append("<li><b><font color='#ff0000'b>" + action.Description + " (failed)</font><b></li></li></li></li></ul></ul></ul></div></body></html>");
}
if (GingerData.GingerName == null)
{
GingerData.GingerName = "";
}
WorkSpace.Instance.RunsetExecutor.DefectSuggestionsList.Add(new DefectSuggestion(action.Guid, this.GingerData.GingerName, mContext.BusinessFlow.Name, currrentGroupName,
mContext.BusinessFlow.ExecutionLogActivityCounter, mCurrentActivity.ActivityName, mCurrentActivity.ExecutionLogActionCounter,
action.Description, action.RetryMechanismCount, action.Error, action.ExInfo, screenShotsPathes,
isScreenshotButtonEnabled, automatedOpeningFlag, description.ToString(),
currrentGroup.ExternalID, mCurrentActivity.ExternalID, new Tuple <string, string>(mContext.BusinessFlow.ExternalID, mContext.BusinessFlow.ExternalID2)));
}
//
// Defects Suggestion section - end
//
}
if (!offlineMode)
{
ExecutionProgressReporterListener.AddExecutionDetailsToLog(ExecutionProgressReporterListener.eExecutionPhase.End, "Action", string.Format("{0} (ID:{1}, ParentID:{2})", action.Description, action.Guid, action.ExecutionParentGuid), AR);
}
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Exception occurred in ExecutionLogger Action end", ex);
}
finally
{
if (currentActivity != null)
{
mContext.Activity = currentActivity;
}
}
}
// remove to GinngerRunner.SetBFOfflineData
public bool OfflineBusinessFlowExecutionLog(BusinessFlow businessFlow, string logFolderPath)
{
try
{
//handle root directory
if (Directory.Exists(logFolderPath))
{
executionLoggerHelper.CleanDirectory(logFolderPath);
}
else
{
Directory.CreateDirectory(logFolderPath);
}
GingerRunner Gr = new GingerRunner();
mCurrentBusinessFlow = businessFlow;
businessFlow.OffilinePropertiesPrep(logFolderPath);
System.IO.Directory.CreateDirectory(businessFlow.ExecutionLogFolder);
foreach (Activity activity in businessFlow.Activities)
{
ActivitiesGroup currentActivityGroup = businessFlow.ActivitiesGroups.Where(x => x.ActivitiesIdentifiers.Select(z => z.ActivityGuid).ToList().Contains(activity.Guid)).FirstOrDefault();
if (currentActivityGroup != null)
{
currentActivityGroup.ExecutionLogFolder = logFolderPath;
switch (currentActivityGroup.ExecutionLoggerStatus)
{
case executionLoggerStatus.NotStartedYet:
ActivityGroupStart(meventtime, currentActivityGroup);
break;
}
}
Gr.CalculateActivityFinalStatus(activity);
if (activity.GetType() == typeof(IErrorHandler))
{
continue;
}
if (activity.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Passed && activity.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed && activity.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Stopped)
{
continue;
}
mCurrentActivity = activity;
activity.OfflinePropertiesPrep(businessFlow.ExecutionLogFolder, businessFlow.ExecutionLogActivityCounter, ExtensionMethods.folderNameNormalazing(activity.ActivityName));
System.IO.Directory.CreateDirectory(activity.ExecutionLogFolder);
foreach (Act action in activity.Acts)
{
if (action.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Passed && action.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed && action.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Stopped && action.Status != Amdocs.Ginger.CoreNET.Execution.eRunStatus.FailIgnored)
{
continue;
}
activity.ExecutionLogActionCounter++;
action.ExecutionLogFolder = Path.Combine(activity.ExecutionLogFolder, activity.ExecutionLogActionCounter + " " + ExtensionMethods.folderNameNormalazing(action.Description));
System.IO.Directory.CreateDirectory(action.ExecutionLogFolder);
ActionEnd(meventtime, action, true);
}
ActivityEnd(meventtime, activity, true);
businessFlow.ExecutionLogActivityCounter++;
}
Gr.SetActivityGroupsExecutionStatus(businessFlow, true);
Gr.CalculateBusinessFlowFinalStatus(businessFlow);
BusinessFlowEnd(meventtime, businessFlow, true);
businessFlow.ExecutionLogFolder = string.Empty;
return(true);
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Execution Logger Failed to do Offline BusinessFlow Execution Log", ex);
return(false);
}
}
public override void ActivityGroupStart(uint eventTime, ActivitiesGroup activityGroup)
{
activityGroup.StartTimeStamp = eventTime; // DateTime.Now.ToUniversalTime();
ExecutionProgressReporterListener.AddExecutionDetailsToLog(ExecutionProgressReporterListener.eExecutionPhase.Start, GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup), string.Format("{0} (ID:{1}, ParentID:{2})", activityGroup.Name, activityGroup.Guid, activityGroup.ExecutionParentGuid), null);
}
private ExecutionResult GetExeResultforAg(BusinessFlow businessFlow, string bfExportedID, ActivitiesGroup activGroup, ref string result, RQMTestPlan testPlan)
{
try
{
LoginDTO loginData = new LoginDTO()
{
User = ALMCore.AlmConfig.ALMUserName, Password = ALMCore.AlmConfig.ALMPassword, Server = ALMCore.AlmConfig.ALMServerURL
};
if (string.IsNullOrEmpty(activGroup.ExternalID))
{
result = "At " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + businessFlow.Name + " " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup) + ", is missing ExternalID, cannot export RQM TestPlan execution results without External ID";
return(null);
}
ExecutionResult exeResult = new ExecutionResult {
TestPlanExportID = bfExportedID
};
List <Activity> relevantActivities = new List <Activity>();
relevantActivities = businessFlow.Activities.Where(x => x.ActivitiesGroupID == activGroup.FileName).ToList();
exeResult.ExecutionStep = new List <ExecutionStep>();
string txExportID = GetExportedIDString(activGroup.ExternalID, "RQMID");
string tsExportID = GetExportedIDString(activGroup.ExternalID, "RQMScriptID");
string erExportID = GetExportedIDString(activGroup.ExternalID, "RQMRecordID");
if ((activGroup.TestSuiteId != null) && (activGroup.TestSuiteId != string.Empty))
{
// check if test suite execution record is exists per current Test Suite ID
// if not exists to create it and than procced to work on just created
RQMTestSuite testSuite = testPlan.TestSuites.Where(z => z.RQMID == activGroup.TestSuiteId).FirstOrDefault();
if ((testSuite != null) && (testSuite.RQMID != null) && (testSuite.URLPathVersioned != null) &&
(testSuite.RQMID != string.Empty) && (testSuite.URLPathVersioned != string.Empty))
{
try
{
ResultInfo resultInfo;
// check if execution record of testSuite exist. If not - to create it
if ((testSuite.TestSuiteExecutionRecord == null) || (testSuite.TestSuiteExecutionRecord.RQMID == null) || (testSuite.TestSuiteExecutionRecord.URLPathVersioned == string.Empty))
{
testSuite.ACL_TestSuite_Copy = new TestSuite();
testSuite.ACL_TestSuite_Copy.TestSuiteName = testSuite.Name;
testSuite.ACL_TestSuite_Copy.TestSuiteExportID = testSuite.RQMID;
resultInfo = RQMConnect.Instance.RQMRep.CreateTestSuiteExecutionRecord(loginData, RQMCore.ALMProjectGuid, ALMCore.AlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, testSuite.ACL_TestSuite_Copy, bfExportedID, businessFlow.Name.ToString());
if (resultInfo.IsSuccess)
{
if (testSuite.TestSuiteExecutionRecord == null)
{
testSuite.TestSuiteExecutionRecord = new RQMTestSuiteExecutionRecord();
}
testSuite.TestSuiteExecutionRecord.RQMID = testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportID;
testSuite.TestSuiteExecutionRecord.URLPathVersioned = testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportUri;
}
}
else
{
testSuite.ACL_TestSuite_Copy = new TestSuite();
testSuite.ACL_TestSuite_Copy.TestSuiteName = testSuite.Name;
testSuite.ACL_TestSuite_Copy.TestSuiteExportID = testSuite.RQMID;
testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportID = testSuite.TestSuiteExecutionRecord.RQMID;
testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportUri = testSuite.TestSuiteExecutionRecord.URLPathVersioned;
}
// after creating of execution record at RQM and as object at Ginger (or checking that it's exists)
// need to create testsuiteLOG on it and add test caseexecution records on it Ginger (the objects at RQM will be created after loop)
ACL_Data_Contract.Activity currentActivity = GetTestCaseFromActivityGroup(activGroup);
resultInfo = RQMConnect.Instance.RQMRep.CreateExecutionRecordPerActivityWithInTestSuite(loginData, RQMCore.ALMProjectGuid, ALMCore.AlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, currentActivity, bfExportedID, businessFlow.Name, testSuite.Name.ToString());
if (resultInfo.IsSuccess)
{
if ((testSuite.TestSuiteExecutionRecord.TestSuiteResults == null) || (testSuite.TestSuiteExecutionRecord.TestSuiteResults.Count == 0) || (testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult == null))
{
testSuite.TestSuiteExecutionRecord.TestSuiteResults = new ObservableList <RQMTestSuiteResults>();
testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult = new RQMTestSuiteResults();
testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.RQMExecutionRecords = new ObservableList <RQMExecutionRecord>();
testSuite.TestSuiteExecutionRecord.TestSuiteResults.Add(testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult);
}
RQMExecutionRecord executionRecord = new RQMExecutionRecord(currentActivity.ExportedTcExecutionRecId.ToString(), currentActivity.ExportedTestScriptId.ToString(), currentActivity.ExportedID.ToString());
testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.RQMExecutionRecords.Add(executionRecord);
testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.ACL_TestSuiteLog_Copy.TestSuiteLogExecutionRecords.Add(exeResult);
exeResult.ExpectedResultName = currentActivity.EntityName;
erExportID = executionRecord.RQMID;
currentActivity.ExportedID = long.Parse(executionRecord.RQMID);
string atsID = GetExportedIDString(activGroup.ExternalID, "AtsID");
if (atsID == "0")
{
atsID = string.Empty;
}
activGroup.ExternalID = "RQMID=" + txExportID + "|RQMScriptID=" + tsExportID + "|RQMRecordID=" + erExportID + "|AtsID=" + atsID;
}
}
catch { }
}
else
{
}
}
else if (string.IsNullOrEmpty(erExportID) || erExportID.Equals("0") || !testPlan.RQMExecutionRecords.Select(z => z.RQMID).ToList().Contains(erExportID))
{
ResultInfo resultInfo;
ACL_Data_Contract.Activity currentActivity = GetTestCaseFromActivityGroup(activGroup);
try
{
// check if executionRecordID exist in RQM but still was not updated in business flow XML
RQMExecutionRecord currentExecutionRecord = testPlan.RQMExecutionRecords.Where(y => y.RelatedTestCaseRqmID == txExportID && y.RelatedTestScriptRqmID == tsExportID).ToList().FirstOrDefault();
if (currentExecutionRecord != null)
{
erExportID = currentExecutionRecord.RQMID;
}
else
{
// if executionRecord not updated and not exists - so create one in RQM and update BussinesFlow object (this may be not saved due not existed "autosave" functionality)
resultInfo = RQMConnect.Instance.RQMRep.CreateExecutionRecordPerActivity(loginData, RQMCore.ALMProjectGuid, ALMCore.AlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, currentActivity, bfExportedID, businessFlow.Name);
if (!currentActivity.ExportedTcExecutionRecId.Equals("0"))
{
string atsID = GetExportedIDString(activGroup.ExternalID, "AtsID");
if (atsID == "0")
{
atsID = string.Empty;
}
erExportID = currentActivity.ExportedTcExecutionRecId.ToString();
activGroup.ExternalID = "RQMID=" + txExportID + "|RQMScriptID=" + tsExportID + "|RQMRecordID=" + erExportID + "|AtsID=" + atsID;
;
}
}
}
catch
{
Reporter.ToLog(eLogLevel.ERROR, "Failed to create Execution Record Per Activity - " + currentActivity.EntityName);
}
}
if (string.IsNullOrEmpty(txExportID) || string.IsNullOrEmpty(tsExportID) || string.IsNullOrEmpty(erExportID) || txExportID.Equals("0") || tsExportID.Equals("0") || erExportID.Equals("0"))
{
result = "At " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + businessFlow.Name + " " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup) + ", is missing ExternalID, cannot export RQM TestPlan execution results without Extrnal ID";
return(null);
}
exeResult.TestCaseExportID = txExportID;
exeResult.TestScriptExportID = tsExportID;
exeResult.ExecutionRecordExportID = erExportID;
int i = 1;
foreach (Activity act in relevantActivities)
{
ExecutionStep exeStep = new ExecutionStep
{
StepExpResults = act.Expected,
StepOrderId = i,
EntityDesc = act.ActivityName,
};
i++;
switch (act.Status)
{
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.Failed;
string errors = string.Empty;
List <IAct> failedActs = act.Acts.Where(x => x.Status == Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed).ToList();
foreach (IAct action in failedActs)
{
errors += action.Error + Environment.NewLine;
}
exeStep.StepActualResult = errors;
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Passed:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.Passed;
exeStep.StepActualResult = "Passed as expected";
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.NA:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.NA;
exeStep.StepActualResult = "NA";
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Pending:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.In_Progress;
exeStep.StepActualResult = "Was not executed";
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Running:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.In_Progress;
exeStep.StepActualResult = "Not Completed";
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Skipped:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.Outscoped;
exeStep.StepActualResult = "Skipped";
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Blocked:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.Blocked;
exeStep.StepActualResult = "Blocked";
break;
case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Stopped:
exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.Inconclusive;
exeStep.StepActualResult = "Stopped";
break;
}
exeResult.ExecutionStep.Add(exeStep);
}
return(exeResult);
}
catch (Exception ex)
{
result = "Unexpected error occurred- " + ex.Message;
Reporter.ToLog(eLogLevel.ERROR, "Failed to export execution details to RQM/ALM", ex);
return(null);
}
}
public override bool ExportActivitiesGroupToALM(ActivitiesGroup activtiesGroup, string uploadPath = null, bool performSaveAfterExport = false)
{
if (activtiesGroup == null)
{
return(false);
}
Test matchingTC = null;
//check if the ActivitiesGroup already mapped to QC Test Case
if (String.IsNullOrEmpty(activtiesGroup.ExternalID) == false)
{
matchingTC = ((QCCore)ALMIntegration.Instance.AlmCore).GetQCTest(activtiesGroup.ExternalID);
if (matchingTC != null)
{
//ask user if want to continue
Amdocs.Ginger.Common.eUserMsgSelection userSelec = Reporter.ToUser(eUserMsgKey.ActivitiesGroupAlreadyMappedToTC, activtiesGroup.Name, matchingTC["TS_SUBJECT"].Path + "\\" + matchingTC.Name);
if (userSelec == Amdocs.Ginger.Common.eUserMsgSelection.Cancel)
{
return(false);
}
else if (userSelec == Amdocs.Ginger.Common.eUserMsgSelection.No)
{
matchingTC = null;
}
}
}
if (matchingTC == null && String.IsNullOrEmpty(uploadPath))
{
//get the QC Test Plan path to upload the activities group to
uploadPath = SelectALMTestPlanPath();
if (String.IsNullOrEmpty(uploadPath))
{
//no path to upload to
return(false);
}
}
//upload the Activities Group
Reporter.ToStatus(eStatusMsgKey.ExportItemToALM, null, activtiesGroup.Name);
string res = string.Empty;
//TODO: retireve test case fields -->DONE
ObservableList <ExternalItemFieldBase> testCaseFields = WorkSpace.UserProfile.Solution.ExternalItemsFields;
ALMIntegration.Instance.RefreshALMItemFields(testCaseFields, true, null);
var filterTestCaseFields = testCaseFields.Where(tc => tc.ItemType == eQCItemType.TestCase.ToString()).ToList();
bool exportRes = ((QCCore)ALMIntegration.Instance.AlmCore).ExportActivitiesGroupToALM(activtiesGroup, matchingTC, uploadPath, new ObservableList <ExternalItemFieldBase>(filterTestCaseFields), ref res);
Reporter.HideStatusMessage();
if (exportRes)
{
if (performSaveAfterExport)
{
Reporter.ToStatus(eStatusMsgKey.SaveItem, null, activtiesGroup.Name, GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup));
WorkSpace.Instance.SolutionRepository.SaveRepositoryItem(activtiesGroup);
Reporter.HideStatusMessage();
}
return(true);
}
else
{
Reporter.ToUser(eUserMsgKey.ExportItemToALMFailed, GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup), activtiesGroup.Name, res);
}
return(false);
}
public bool ExportActivitiesGroupToALM(ActivitiesGroup activtiesGroup, QCTestCase matchingTC, string uploadPath, ObservableList <ExternalItemFieldBase> testCaseFields, ObservableList <ExternalItemFieldBase> designStepsFields, ObservableList <ExternalItemFieldBase> designStepsParamsFields, ref string res)
{
return(ExportToQCRestAPI.ExportActivitiesGroupToQC(activtiesGroup, matchingTC, uploadPath, testCaseFields, designStepsFields, designStepsParamsFields, ref res));
}
public bool ExportActivitiesGroupToALM(ActivitiesGroup activitiesGroup, Test mappedTest, string uploadPath, ObservableList <ExternalItemFieldBase> testCaseFields, ref string result)
{
return(ExportToQC.ExportActivitiesGroupToQC(activitiesGroup, mappedTest, uploadPath, testCaseFields, ref result));
}
public static BusinessFlow ConvertRallyTestPlanToBF(RallyTestPlan testPlan)
{
try
{
if (testPlan == null)
{
return(null);
}
//Create Business Flow
BusinessFlow busFlow = new BusinessFlow();
busFlow.Name = testPlan.Name;
busFlow.ExternalID = "RallyID=" + testPlan.RallyID;
busFlow.Status = BusinessFlow.eBusinessFlowStatus.Development;
busFlow.Activities = new ObservableList <Activity>();
busFlow.Variables = new ObservableList <VariableBase>();
//Create Activities Group + Activities for each TC
foreach (RallyTestCase tc in testPlan.TestCases)
{
//check if the TC is already exist in repository
ActivitiesGroup tcActivsGroup;
ActivitiesGroup repoActivsGroup = null;
if (repoActivsGroup == null)
{
repoActivsGroup = GingerActivitiesGroupsRepo.Where(x => x.ExternalID != null ? x.ExternalID.Split('|').First().Split('=').Last() == tc.RallyID : false).FirstOrDefault();
}
if (repoActivsGroup != null)
{
tcActivsGroup = (ActivitiesGroup)repoActivsGroup.CreateInstance();
busFlow.AddActivitiesGroup(tcActivsGroup);
busFlow.ImportActivitiesGroupActivitiesFromRepository(tcActivsGroup, GingerActivitiesRepo, true, true);
busFlow.AttachActivitiesGroupsAndActivities();
}
else // TC not exist in Ginger repository so create new one
{
tcActivsGroup = new ActivitiesGroup();
tcActivsGroup.Name = tc.Name;
tcActivsGroup.Description = tc.Description;
tcActivsGroup.ExternalID = "RallyID=" + tc.RallyID + "|AtsID=" + tc.BTSID;
busFlow.AddActivitiesGroup(tcActivsGroup);
}
foreach (RallyTestStep step in tc.TestSteps)
{
Activity stepActivity;
bool toAddStepActivity = false;
// check if mapped activity exist in repository
Activity repoStepActivity = GingerActivitiesRepo.Where(x => x.ExternalID != null ? x.ExternalID.Split('|').First().Split('=').Last() == step.RallyIndex : false).FirstOrDefault();
if (repoStepActivity != null)
{
//check if it is part of the Activities Group
ActivityIdentifiers groupStepActivityIdent = tcActivsGroup.ActivitiesIdentifiers.Where(x => x.ActivityExternalID == step.RallyIndex).FirstOrDefault();
if (groupStepActivityIdent != null)
{
//already in Activities Group so get link to it
stepActivity = busFlow.Activities.Where(x => x.Guid == groupStepActivityIdent.ActivityGuid).FirstOrDefault();
}
else // not in ActivitiesGroup so get instance from repo
{
stepActivity = (Activity)repoStepActivity.CreateInstance();
toAddStepActivity = true;
}
}
else //Step not exist in Ginger repository so create new one
{
string strBtsID = string.Empty;
stepActivity = new Activity();
stepActivity.ActivityName = tc.Name + ">" + step.Name;
stepActivity.ExternalID = "RallyID=" + step.RallyIndex + "|AtsID=" + strBtsID;
stepActivity.Description = StripHTML(step.Description);
stepActivity.Expected = StripHTML(step.ExpectedResult);
toAddStepActivity = true;
}
if (toAddStepActivity)
{
// not in group- need to add it
busFlow.AddActivity(stepActivity);
tcActivsGroup.AddActivityToGroup(stepActivity);
}
//pull TC-Step parameters and add them to the Activity level
foreach (RallyTestParameter param in tc.Parameters) // Params taken from TestScriptLevel only!!!! Also exists parapameters at TestCase, to check if them should be taken!!!
{
bool?isflowControlParam = null;
//detrmine if the param is Flow Control Param or not based on it value and agreed sign "$$_"
if (param.Value.ToString().StartsWith("$$_"))
{
isflowControlParam = false;
if (param.Value.ToString().StartsWith("$$_"))
{
param.Value = param.Value.ToString().Substring(3); //get value without "$$_"
}
}
else if (param.Value.ToString() != "<Empty>")
{
isflowControlParam = true;
}
//check if already exist param with that name
VariableBase stepActivityVar = stepActivity.Variables.Where(x => x.Name.ToUpper() == param.Name.ToUpper()).FirstOrDefault();
if (stepActivityVar == null)
{
//#Param not exist so add it
if (isflowControlParam == true)
{
//add it as selection list param
stepActivityVar = new VariableSelectionList();
stepActivityVar.Name = param.Name;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because new flow control param was added
}
else
{
//add as String param
stepActivityVar = new VariableString();
stepActivityVar.Name = param.Name;
((VariableString)stepActivityVar).InitialStringValue = param.Value;
stepActivity.AddVariable(stepActivityVar);
}
}
else
{
//#param exist
if (isflowControlParam == true)
{
if (!(stepActivityVar is VariableSelectionList))
{
//flow control param must be Selection List so transform it
stepActivity.Variables.Remove(stepActivityVar);
stepActivityVar = new VariableSelectionList();
stepActivityVar.Name = param.Name;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because flow control param was added
}
}
else if (isflowControlParam == false)
{
if (stepActivityVar is VariableSelectionList)
{
//change it to be string variable
stepActivity.Variables.Remove(stepActivityVar);
stepActivityVar = new VariableString();
stepActivityVar.Name = param.Name;
((VariableString)stepActivityVar).InitialStringValue = param.Value;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because flow control param was removed
}
}
}
//add the variable selected value
if (stepActivityVar is VariableSelectionList)
{
OptionalValue stepActivityVarOptionalVar = ((VariableSelectionList)stepActivityVar).OptionalValuesList.Where(x => x.Value == param.Value).FirstOrDefault();
if (stepActivityVarOptionalVar == null)
{
//no such variable value option so add it
stepActivityVarOptionalVar = new OptionalValue(param.Value);
((VariableSelectionList)stepActivityVar).OptionalValuesList.Add(stepActivityVarOptionalVar);
if (isflowControlParam == true)
{
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because new param value was added
}
}
//set the selected value
((VariableSelectionList)stepActivityVar).SelectedValue = stepActivityVarOptionalVar.Value;
}
else
{
//try just to set the value
try
{
stepActivityVar.Value = param.Value;
if (stepActivityVar is VariableString)
{
((VariableString)stepActivityVar).InitialStringValue = param.Value;
}
}
catch (Exception ex) { Reporter.ToLog(eAppReporterLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}", ex); }
}
}
}
}
return(busFlow);
}
catch (Exception ex)
{
Reporter.ToLog(eAppReporterLogLevel.ERROR, "Failed to import Rally test set and convert it into " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow), ex);
return(null);
}
}
public override void ActivityGroupStart(uint eventTime, ActivitiesGroup activityGroup)
{
AddExecutionDetailsToLog(eExecutionPhase.Start, GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup), activityGroup.Name, new ActivityGroupReport(activityGroup, mBusinessFlow));
}
public void CreateNewGroupToUnSyncedGroupedActivitiesTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
group1.AddActivityToGroup(activity1);
group1.AddActivityToGroup(activity2);
group2.AddActivityToGroup(activity3);
group1.AddActivityToGroup(activity4);
group1.AddActivityToGroup(activity5);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups.Count == 3, "Validate 1 extra groups were added");
Assert.IsTrue(group1.ActivitiesIdentifiers.Count == 2, "Validate only 2 Activities are attached to first group");
Assert.IsTrue(group2.ActivitiesIdentifiers.Count == 1, "Validate 1 Activities were attached to second group");
Assert.IsTrue(busFlow.ActivitiesGroups.Where(x => x.Name == group1.Name + "_2").FirstOrDefault() != null, "Validate new added group name");
Assert.IsTrue(activity4.ActivitiesGroupID == group1.Name + "_2", "Validate Activity was re-grouped to new added group");
Assert.IsTrue(activity5.ActivitiesGroupID == group1.Name + "_2", "Validate Activity was re-grouped to new added group");
}
public override void ActivityGroupEnd(uint eventTime, ActivitiesGroup activityGroup, bool offlineMode = false)
{
AddExecutionDetailsToLog(eExecutionPhase.End, GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup), activityGroup.Name, new ActivityGroupReport(activityGroup, mBusinessFlow));
}
public void GroupsActivitiesOrderTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
group1.AddActivityToGroup(activity3);
group1.AddActivityToGroup(activity2);
group1.AddActivityToGroup(activity1);
group2.AddActivityToGroup(activity4);
group2.AddActivityToGroup(activity5);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(group1.ActivitiesIdentifiers[0].IdentifiedActivity == activity1, "Validate group 1 Activity 1 order is same as in Activities flow");
Assert.IsTrue(group1.ActivitiesIdentifiers[1].IdentifiedActivity == activity2, "Validate group 1 Activity 2 order is same as in Activities flow");
Assert.IsTrue(group1.ActivitiesIdentifiers[2].IdentifiedActivity == activity3, "Validate group 1 Activity 3 order is same as in Activities flow");
Assert.IsTrue(group2.ActivitiesIdentifiers[0].IdentifiedActivity == activity4, "Validate group 2 Activity 4 order is same as in Activities flow");
Assert.IsTrue(group2.ActivitiesIdentifiers[1].IdentifiedActivity == activity5, "Validate group 2 Activity 5 order is same as in Activities flow");
}
public bool ExportBusinessFlowToALM(BusinessFlow businessFlow, QtestTestSuite mappedTestSuite, string parentObjectId, ObservableList <ExternalItemFieldBase> testSetFields, ref string result)
{
ConnectALMServer();
testrunApi = new QTestApi.TestrunApi(connObj.Configuration);
testcaseApi = new QTestApi.TestcaseApi(connObj.Configuration);
QTestApi.TestsuiteApi testsuiteApi = new QTestApi.TestsuiteApi(connObj.Configuration);
ObservableList <ActivitiesGroup> existingActivitiesGroups = new ObservableList <ActivitiesGroup>();
try
{
QTestApiModel.TestSuiteWithCustomFieldResource testSuite = null;
if (mappedTestSuite == null)
{
testSuite = new QTestApiModel.TestSuiteWithCustomFieldResource(null, null, null, null,
businessFlow.Name,
new List <QTestApiModel.PropertyResource>());
testSuite = testsuiteApi.CreateTestSuite((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), testSuite, (long)Convert.ToInt32(parentObjectId), "test-cycle");
foreach (ActivitiesGroup ag in businessFlow.ActivitiesGroups)
{
QTestApiModel.TestRunWithCustomFieldResource testRun = new QTestApiModel.TestRunWithCustomFieldResource(null, null, null, null,
ag.Name,
new List <QTestApiModel.PropertyResource>(),
testcaseApi.GetTestCase((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), (long)Convert.ToInt32(ag.ExternalID)));
testrunApi.Create((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), testRun, testSuite.Id, "test-suite");
}
}
else
{
//##update existing TestSuite -> TestRun
foreach (QtestTest test in mappedTestSuite.Tests)
{
QTestApiModel.TestRunWithCustomFieldResource testRun = testrunApi.Get((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), (long)Convert.ToInt32(test.Runs[0].RunID), "descendents");
QTestApiModel.TestCaseWithCustomFieldResource testCase = testcaseApi.GetTestCase((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), testRun.TestCase.Id);
ActivitiesGroup ag = businessFlow.ActivitiesGroups.Where(x => (x.ExternalID == test.TestID.ToString())).FirstOrDefault();
if (ag != null)
{
foreach (ActivityIdentifiers actIdent in ag.ActivitiesIdentifiers)
{
if ((actIdent.IdentifiedActivity.ExternalID == null) && (actIdent.IdentifiedActivity.ExternalID2 == null))
{
QTestApiModel.TestCaseWithCustomFieldResource newTestCase = new QTestApiModel.TestCaseWithCustomFieldResource(null, null, null, new List <QTestApiModel.PropertyResource>());
newTestCase.Description = actIdent.ActivityDescription;
newTestCase.Name = actIdent.ActivityName;
testcaseApi.CreateTestCase((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), newTestCase);
QTestApiModel.TestStepResource stepResource = new QTestApiModel.TestStepResource(null, null,
((Activity)actIdent.IdentifiedActivity).Description == null ? string.Empty : ((Activity)actIdent.IdentifiedActivity).Description,
((Activity)actIdent.IdentifiedActivity).Expected == null ? string.Empty : ((Activity)actIdent.IdentifiedActivity).Expected);
stepResource.PlainValueText = ((Activity)actIdent.IdentifiedActivity).ActivityName;
testcaseApi.AddTestStep((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), newTestCase.Id, stepResource);
stepResource = new QTestApiModel.TestStepResource(null, null, string.Empty, string.Empty,
null, null, null, null, null, newTestCase.Id);
stepResource = testcaseApi.AddTestStep((long)Convert.ToInt32(ALMCore.DefaultAlmConfig.ALMProjectKey), testCase.Id, stepResource);
actIdent.IdentifiedActivity.ExternalID = newTestCase.Id.ToString();
actIdent.IdentifiedActivity.ExternalID2 = stepResource.Id.ToString();
}
}
}
}
}
businessFlow.ExternalID = testSuite != null?testSuite.Id.ToString() : string.Empty;
WorkSpace.Instance.SolutionRepository.SaveRepositoryItem(businessFlow);
return(true);
}
catch (Exception ex)
{
result = "Unexpected error occurred- " + ex.Message;
Reporter.ToLog(eLogLevel.ERROR, "Failed to export the " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + " to qTest", ex);
return(false);
}
}
public void AddActivityWithNewGroupTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group1);
busFlow.AddActivity(activity3, group1);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group2);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity6, group3);
//Assert
Assert.IsTrue(busFlow.Activities[5] == activity6, "Validate new Activity added in last");
Assert.IsTrue(busFlow.ActivitiesGroups[2] == group3, "Validate new group was added to BF");
Assert.IsTrue(activity6.ActivitiesGroupID == group3.Name, "Validate new Activity is mapped to new group");
Assert.IsTrue(group3.ActivitiesIdentifiers[0].IdentifiedActivity == activity6, "Validate new Activity is mapped to new group");
}
public override void ActivityGroupEnd(uint eventTime, ActivitiesGroup activityGroup, bool offlineMode = false)
{
WorkSpace.Instance.Telemetry.Add("activitygroupend", new { Guid = activityGroup.Guid, Elapsed = activityGroup.Elapsed });
}
public void GroupUnGroupedActivitiesTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
group1.AddActivityToGroup(activity1);
group2.AddActivityToGroup(activity4);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups.Count == 2, "Validate no extra groups were added");
Assert.IsTrue(group1.ActivitiesIdentifiers.Count == 3, "Validate first three Activities were attached to first group");
Assert.IsTrue(group2.ActivitiesIdentifiers.Count == 2, "Validate last two Activities were attached to second group");
Assert.IsTrue(group1.ActivitiesIdentifiers[2].ActivityName == activity3.ActivityName, "Validate group 1 has correct activities mapped to it");
Assert.IsTrue(group2.ActivitiesIdentifiers[1].ActivityName == activity5.ActivityName, "Validate group 2 has correct activities mapped to it");
Assert.IsTrue(activity2.ActivitiesGroupID == group1.Name, "Validate Activities mapped to group 1");
Assert.IsTrue(activity5.ActivitiesGroupID == group2.Name, "Validate Activities mapped to group 2");
}
private ActivitiesGroup CreateScenario(ScenarioDefinition sc, int?index = null)
{
// Create new activity per each step
// Each scenario is in one ActivitiesGroup
ActivitiesGroup AG = new ActivitiesGroup();
AG.Name = sc.Name;
if (index != null)
{
AG.Name += " #" + index; // Adding Scenario index so it will be unique
}
mBizFlow.AddActivitiesGroup(AG);
//Add Tags - on ActivitiesGroup and solution if needed
IEnumerable <Tag> TagList = null;
if (sc is ScenarioOutline)
{
TagList = ((ScenarioOutline)sc).Tags;
}
else if (sc is Scenario)
{
TagList = ((Scenario)sc).Tags;
}
foreach (var t in TagList)
{
Guid tg = GetOrCreateTagInSolution(t.Name);
AG.Tags.Add(tg);
}
foreach (Guid guid in mBizFlow.Tags)
{
AG.Tags.Add(guid);
}
foreach (Gherkin.Ast.Step step in sc.Steps)
{
// Find the Activity from the template BF with All activity, create a copy and add to BF
string GN = GherkinGeneral.GetActivityGherkinName(step.Text);
Activity a = (Activity)SearchActivityByName(GN);
if (a != null)
{
Activity a1 = (Activity)a.CreateCopy(false);
a1.ActivityName = step.Text;
a1.Active = true;
a1.ParentGuid = a1.Guid;
Guid g = Guid.NewGuid();
a1.Guid = g;
foreach (var t in AG.Tags)
{
if (!a1.Tags.Contains(t))
{
a1.Tags.Add(t);
}
if (!a.Tags.Contains(t))
{
a.Tags.Add(t);
}
}
//Adding feature tags
foreach (Guid guid in mBizFlow.Tags)
{
if (!a1.Tags.Contains(guid))
{
a1.Tags.Add(guid);
}
if (!a.Tags.Contains(guid))
{
a.Tags.Add(guid);
}
}
UpdateActivityVars(a1, a.ActivityName);
mBizFlow.AddActivity(a1, AG);
}
else
{
//TODO: err activity not found...
Reporter.ToUser(eUserMsgKey.GherkinActivityNotFound, GN);
}
}
return(AG);
}
private void CreateTestCaseFields(ActivitiesGroup activtiesGroup, IEnumerable <ExternalItemFieldBase> issueFields, JiraIssueExport jiraIssue)
{
jiraIssue.name = activtiesGroup.Name;
jiraIssue.resourceType = ALM_Common.DataContracts.ResourceType.TEST_CASE;
jiraIssue.ExportFields.Add("project", new List <IJiraExportData>()
{
new JiraExportData()
{
value = ALMCore.AlmConfig.ALMProjectKey
}
});
jiraIssue.ExportFields.Add("summary", new List <IJiraExportData>()
{
new JiraExportData()
{
value = activtiesGroup.Name
}
});
jiraIssue.ExportFields.Add("description", new List <IJiraExportData>()
{
new JiraExportData()
{
value = activtiesGroup.Description
}
});
jiraIssue.ExportFields.Add("issuetype", new List <IJiraExportData>()
{
new JiraExportData()
{
value = "Test"
}
});
jiraIssue.ExportFields.Add("reporter", new List <IJiraExportData>()
{
new JiraExportData()
{
value = ALMCore.AlmConfig.ALMUserName
}
});
if (!string.IsNullOrEmpty(activtiesGroup.ExternalID2))
{
jiraIssue.ExportFields.Add("labels", new List <IJiraExportData>()
{
new JiraExportData()
{
value = activtiesGroup.ExternalID2
}
});
}
foreach (var item in issueFields)
{
var issueTemplate = jiraRepObj.GetFieldFromTemplateByName(ALM_Common.DataContracts.ResourceType.TEST_CASE, ALMCore.AlmConfig.ALMProjectKey, item.Name);
if (issueTemplate == null || jiraIssue.ExportFields.ContainsKey(issueTemplate.key))
{
continue;
}
if (issueTemplate != null)
{
jiraIssue.ExportFields.Add(issueTemplate.key, new List <IJiraExportData>()
{
new JiraExportData()
{
value = item.SelectedValue
}
});
}
}
}
public void CreateScenarios(BusinessFlow BF)
{
string FileName = string.Empty;
if (BF.ExternalID != null)
{
FileName = BF.ExternalID.Replace(@"~", WorkSpace.Instance.Solution.Folder);
}
if (!System.IO.File.Exists(FileName))
{
// General
Reporter.ToUser(eUserMsgKey.GherkinFileNotFound, FileName);
return;
}
Parser parser = new Parser();
GherkinDocument gherkinDocument = parser.Parse(FileName);
mBizFlow = BF;
ClearGeneretedActivites(mBizFlow);
ClearOptimizedScenariosVariables(mBizFlow);
//Add Tags to BF
foreach (var t in gherkinDocument.Feature.Tags)
{
Guid TagGuid = GetOrCreateTagInSolution(t.Name);
mBizFlow.Tags.Add(TagGuid);
}
foreach (Gherkin.Ast.ScenarioDefinition sc in gherkinDocument.Feature.Children)
{
IEnumerable <Examples> examples = null;
// In case of Scenario Outline we need to generate new BF per each line in the table of examples
if (sc.Keyword == "Scenario Outline")
{
ScenarioOutline so = (ScenarioOutline)sc;
examples = so.Examples;
}
// Create new BF per each scenario
if (examples == null)
{
CreateScenario(sc);
}
else
{
int i = 0;
ValuesDict = new Dictionary <string, List <OptionalValue> >();
//TODO: handle case of more than one example table - check what is Gherking expected todo: all combinations!!??
foreach (Examples x in examples)
{
foreach (Gherkin.Ast.TableRow tr in x.TableBody)
{
i++;
ActivitiesGroup AG = CreateScenario(sc, i);
// Now the we have the flow created with activities, we update the activities var replacing <param> with value from table
var activities = from z in BF.Activities where z.ActivitiesGroupID == AG.Name select z;
foreach (Activity a in activities)
{
while (true)
{
string ColName = General.GetStringBetween(a.ActivityName, "<", ">");
if (string.IsNullOrEmpty(ColName))
{
break;
}
string val = GetExampleValue(x.TableHeader, tr, ColName);
a.ActivityName = a.ActivityName.Replace("<" + ColName + ">", "\"" + val + "\"");
VariableBase v = a.Variables.Where(y => y.Name == ColName).FirstOrDefault();
OptionalValue ov = new OptionalValue(val);
if (ValuesDict.ContainsKey(ColName))
{
ValuesDict[ColName].Add(ov);
}
else
{
List <OptionalValue> newList = new List <OptionalValue>();
newList.Add(ov);
ValuesDict.Add(ColName, newList);
}
((VariableSelectionList)v).OptionalValuesList.Add(ov);
((VariableSelectionList)v).SelectedValue = val;
}
}
}
}
foreach (Activity a in BF.Activities)
{
foreach (VariableBase vb in a.Variables)
{
if (vb is VariableSelectionList)
{
if (ValuesDict.ContainsKey(vb.Name))
{
foreach (OptionalValue ov in ValuesDict[vb.Name])
{
OptionalValue ExistedOV = ((VariableSelectionList)vb).OptionalValuesList.Where(y => y.Value == ov.Value).FirstOrDefault();
if (ExistedOV == null)
{
((VariableSelectionList)vb).OptionalValuesList.Add(ov);
}
}
}
}
}
}
}
}
if (!string.IsNullOrEmpty(NotFoundItems))
{
Reporter.ToUser(eUserMsgKey.GherkinColumnNotExist, NotFoundItems);
}
}
public static void ClassInit(TestContext context)
{
BF1 = new BusinessFlow();
BF1.Name = "VariableDependancyTest";
BF1.Active = true;
ActivitiesGroup activityGroup = new ActivitiesGroup();
Activity activity1 = new Activity();
activity1.Active = true;
ActDummy actDummy1 = new ActDummy();
actDummy1.Active = true;
ActDummy actDummy2 = new ActDummy();
actDummy2.Active = true;
activity1.Acts.Add(actDummy1);
activity1.Acts.Add(actDummy2);
Activity activity2 = new Activity();
activity2.Active = true;
ActDummy actDummy3 = new ActDummy();
actDummy3.Active = true;
ActDummy actDummy4 = new ActDummy();
actDummy4.Active = true;
ActDummy actDummy7 = new ActDummy();
actDummy7.Active = true;
ActDummy actDummy8 = new ActDummy();
actDummy8.Active = true;
activity2.Acts.Add(actDummy3);
activity2.Acts.Add(actDummy4);
activity2.Acts.Add(actDummy7);
activity2.Acts.Add(actDummy8);
Activity activity3 = new Activity();
activity3.Active = true;
ActDummy actDummy5 = new ActDummy();
actDummy5.Active = true;
ActDummy actDummy6 = new ActDummy();
actDummy6.Active = true;
activity3.Acts.Add(actDummy5);
activity3.Acts.Add(actDummy6);
activityGroup.AddActivityToGroup(activity1);
activityGroup.AddActivityToGroup(activity2);
activityGroup.AddActivityToGroup(activity3);
BF1.Activities.Add(activity1);
BF1.Activities.Add(activity2);
BF1.Activities.Add(activity3);
BF1.ActivitiesGroups.Add(activityGroup);
Platform p = new Platform();
p.PlatformType = ePlatformType.Web;
BF1.TargetApplications.Add(new TargetApplication()
{
AppName = "SCM"
});
if (WorkSpace.Instance != null && WorkSpace.Instance.Solution != null && WorkSpace.Instance.Solution.LoggerConfigurations != null)
{
string TempRepositoryFolder = TestResources.GetTestTempFolder(Path.Combine("Solutions", "temp"));
WorkSpace.Instance.Solution.LoggerConfigurations.CalculatedLoggerFolder = Path.Combine(TempRepositoryFolder, "ExecutionResults");
WorkSpace.Instance.Solution.SolutionOperations = new SolutionOperations(WorkSpace.Instance.Solution);
}
mGR = new GingerRunner();
mGR.Executor = new GingerExecutionEngine(mGR);
mGR.Name = "Test Runner";
mGR.Executor.CurrentSolution = new Ginger.SolutionGeneral.Solution();
ProjEnvironment environment = new ProjEnvironment();
environment.Name = "Default";
BF1.Environment = environment.Name;
Agent a = new Agent();
a.DriverType = Agent.eDriverType.SeleniumChrome;
((GingerExecutionEngine)mGR.Executor).SolutionAgents = new ObservableList <Agent>();
((GingerExecutionEngine)mGR.Executor).SolutionAgents.Add(a);
mGR.ApplicationAgents.Add(new ApplicationAgent()
{
AppName = "SCM", Agent = a
});
mGR.Executor.SolutionApplications = new ObservableList <ApplicationPlatform>();
mGR.Executor.SolutionApplications.Add(new ApplicationPlatform()
{
AppName = "SCM", Platform = ePlatformType.Web, Description = "New application"
});
mGR.Executor.BusinessFlows.Add(BF1);
Context context1 = new Context();
context1.BusinessFlow = BF1;
context1.Activity = BF1.Activities[0];
mGR.Executor.CurrentBusinessFlow = BF1;
mGR.Executor.CurrentBusinessFlow.CurrentActivity = BF1.Activities[0];
mGR.Executor.Context = context1;
}
public virtual void ActivityGroupEnd(uint eventTime, ActivitiesGroup activityGroup, bool offlineMode = false)
{
}
