private static QCTestSet UpdateExistingTestSet(BusinessFlow businessFlow, QCTestSet mappedTestSet, string uploadPath, ObservableList <ExternalItemFieldBase> testSetFields)
        {
            QCTestSet testSet = ImportFromQCRest.GetQCTestSet(mappedTestSet.Id.ToString());

            //set item fields for test set
            foreach (ExternalItemFieldBase field in testSetFields)
            {
                if (field.ToUpdate || field.Mandatory)
                {
                    if (string.IsNullOrEmpty(field.ExternalID) == false && field.SelectedValue != "NA")
                    {
                        if (testSet.ElementsField.ContainsKey(field.ID))
                        {
                            testSet.ElementsField[field.ExternalID] = field.SelectedValue;
                        }
                    }
                }
            }

            testSet.ElementsField["name"] = businessFlow.Name;

            try
            {
                QCItem          item     = ConvertObjectValuesToQCItem(testSet, ResourceType.TEST_SET, true);
                ALMResponseData response = QCRestAPIConnect.UpdateEntity(ResourceType.TEST_SET, testSet.Id, item);
                return(QCRestAPIConnect.GetTestSetDetails(testSet.Id));
            }
            catch (Exception ex)
            {
                Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}");
                return(null);
            }
        }
        public static bool ExportExceutionDetailsToALM(BusinessFlow bizFlow, ref string result, ObservableList <ExternalItemFieldBase> runFields, bool exectutedFromAutomateTab, PublishToALMConfig publishToALMConfig = null)
        {
            result = string.Empty;
            if (bizFlow.ExternalID == "0" || String.IsNullOrEmpty(bizFlow.ExternalID))
            {
                result = GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + bizFlow.Name + " is missing ExternalID, cannot locate QC TestSet without External ID";
                return(false);
            }

            try
            {
                //get the BF matching test set
                QCTestSet testSet = ImportFromQCRest.GetQCTestSet(bizFlow.ExternalID);//bf.externalID holds the TestSet TSTests collection id
                if (testSet != null)
                {
                    //get the Test set TC's
                    QCTestInstanceColl qcTSTests = QCRestAPIConnect.GetTestInstancesOfTestSet(testSet.Id); //list of TSTest's on main TestSet in TestLab

                    //get all BF Activities groups
                    ObservableList <ActivitiesGroup> activGroups = bizFlow.ActivitiesGroups;
                    if (activGroups.Count > 0)
                    {
                        foreach (ActivitiesGroup activGroup in activGroups)
                        {
                            if ((publishToALMConfig.FilterStatus == FilterByStatus.OnlyPassed && activGroup.RunStatus == ActivitiesGroup.eActivitiesGroupRunStatus.Passed) ||
                                (publishToALMConfig.FilterStatus == FilterByStatus.OnlyFailed && activGroup.RunStatus == ActivitiesGroup.eActivitiesGroupRunStatus.Failed) ||
                                publishToALMConfig.FilterStatus == FilterByStatus.All)
                            {
                                QCTestInstance tsTest = null;
                                //go by TC ID = TC Instancs ID
                                tsTest = qcTSTests.Find(x => x.TestId == activGroup.ExternalID && x.Id == activGroup.ExternalID2);
                                if (tsTest == null)
                                {
                                    //go by Linked TC ID + TC Instancs ID
                                    tsTest = qcTSTests.Find(x => ImportFromQCRest.GetTSTestLinkedID(x) == activGroup.ExternalID && x.Id == activGroup.ExternalID2);
                                }
                                if (tsTest == null)
                                {
                                    //go by TC ID
                                    tsTest = qcTSTests.Find(x => x.TestId == activGroup.ExternalID);
                                }
                                if (tsTest != null)
                                {
                                    //get activities in group
                                    List <Activity> activities   = (bizFlow.Activities.Where(x => x.ActivitiesGroupID == activGroup.Name)).Select(a => a).ToList();
                                    string          TestCaseName = PathHelper.CleanInValidPathChars(tsTest.Name);
                                    if ((publishToALMConfig.VariableForTCRunName == null) || (publishToALMConfig.VariableForTCRunName == string.Empty))
                                    {
                                        String timeStamp = DateTime.Now.ToString("dd-MMM-yyyy HH:mm:ss");
                                        publishToALMConfig.VariableForTCRunName = "GingerRun_" + timeStamp;
                                    }

                                    QCRun runToExport = new QCRun();

                                    foreach (ExternalItemFieldBase field in runFields)
                                    {
                                        if (field.ToUpdate || field.Mandatory)
                                        {
                                            if (string.IsNullOrEmpty(field.SelectedValue) == false && field.SelectedValue != "NA")
                                            {
                                                runToExport.ElementsField.Add(field.ExternalID, field.SelectedValue);
                                            }
                                            else
                                            {
                                                try { runToExport.ElementsField.Add(field.ExternalID, "NA"); }
                                                catch { }
                                            }
                                        }
                                    }

                                    runToExport.ElementsField["name"]        = publishToALMConfig.VariableForTCRunNameCalculated;
                                    runToExport.ElementsField["test-id"]     = tsTest.TestId;
                                    runToExport.ElementsField["testcycl-id"] = tsTest.Id;
                                    runToExport.ElementsField["cycle-id"]    = tsTest.CycleId;
                                    runToExport.ElementsField["duration"]    = "0";
                                    runToExport.ElementsField["subtype-id"]  = "hp.qc.run.MANUAL";
                                    runToExport.ElementsField["owner"]       = ALMCore.AlmConfig.ALMUserName;

                                    QCItem          itemToExport = ConvertObjectValuesToQCItem(runToExport, ResourceType.TEST_RUN);
                                    ALMResponseData responseData = QCRestAPIConnect.CreateNewEntity(ResourceType.TEST_RUN, itemToExport);
                                    if (!responseData.IsSucceed)
                                    {
                                        result = "Failed to create run using rest API";
                                        return(false);
                                    }
                                    QCRun currentRun = QCRestAPIConnect.GetRunDetail(responseData.IdCreated);

                                    // Attach ActivityGroup Report if needed
                                    if (publishToALMConfig.ToAttachActivitiesGroupReport)
                                    {
                                        if ((activGroup.TempReportFolder != null) && (activGroup.TempReportFolder != string.Empty) &&
                                            (System.IO.Directory.Exists(activGroup.TempReportFolder)))
                                        {
                                            //Creating the Zip file - start
                                            string targetZipPath = System.IO.Directory.GetParent(activGroup.TempReportFolder).ToString();
                                            string zipFileName   = targetZipPath + "\\" + TestCaseName.ToString() + "_GingerHTMLReport.zip";

                                            if (!System.IO.File.Exists(zipFileName))
                                            {
                                                ZipFile.CreateFromDirectory(activGroup.TempReportFolder, zipFileName);
                                            }
                                            else
                                            {
                                                System.IO.File.Delete(zipFileName);
                                                ZipFile.CreateFromDirectory(activGroup.TempReportFolder, zipFileName);
                                            }
                                            System.IO.Directory.Delete(activGroup.TempReportFolder, true);
                                            //Creating the Zip file - finish
                                            //Attaching Zip file - start
                                            //AttachmentFactory attachmentFactory = (AttachmentFactory)run.Attachments;
                                            //TDAPIOLELib.Attachment attachment = (TDAPIOLELib.Attachment)attachmentFactory.AddItem(System.DBNull.Value);
                                            //attachment.Description = "TC Ginger Execution HTML Report";
                                            //attachment.Type = 1;
                                            //attachment.FileName = zipFileName;
                                            //attachment.Post();

                                            //Attaching Zip file - finish
                                            System.IO.File.Delete(zipFileName);
                                        }
                                    }


                                    //create run with activities as steps
                                    QCRunStepColl runSteps = ImportFromQCRest.GetRunSteps(currentRun.Id);

                                    int index = 1;
                                    foreach (QCRunStep runStep in runSteps)
                                    {
                                        //search for matching activity based on ID and not order, un matching steps need to be left as No Run
                                        string   stepName         = runStep.Name;
                                        Activity matchingActivity = activities.Where(x => x.ExternalID == runStep.ElementsField["desstep-id"].ToString()).FirstOrDefault();
                                        if (matchingActivity != null)
                                        {
                                            switch (matchingActivity.Status)
                                            {
                                            case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed:
                                                runStep.Status = "Failed";
                                                List <Act> failedActs = matchingActivity.Acts.Where(x => x.Status == Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed).ToList();
                                                string     errors     = string.Empty;
                                                foreach (Act act in failedActs)
                                                {
                                                    errors += act.Error + Environment.NewLine;
                                                }
                                                runStep.Actual = errors;
                                                break;

                                            case Amdocs.Ginger.CoreNET.Execution.eRunStatus.NA:
                                                runStep.ElementsField["status"] = "N/A";
                                                runStep.ElementsField["actual"] = "NA";
                                                break;

                                            case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Passed:
                                                runStep.ElementsField["status"] = "Passed";
                                                runStep.ElementsField["actual"] = "Passed as expected";
                                                break;

                                            case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Skipped:
                                                runStep.ElementsField["status"] = "N/A";
                                                runStep.ElementsField["actual"] = "Skipped";
                                                break;

                                            case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Pending:
                                                runStep.ElementsField["status"] = "No Run";
                                                runStep.ElementsField["actual"] = "Was not executed";
                                                break;

                                            case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Running:
                                                runStep.ElementsField["status"] = "Not Completed";
                                                runStep.ElementsField["actual"] = "Not Completed";
                                                break;
                                            }
                                        }
                                        else
                                        {
                                            //Step not exist in Ginger so left as "No Run" unless it is step data
                                            if (runStep.Name.ToUpper() == "STEP DATA")
                                            {
                                                runStep.ElementsField["status"] = "Passed";
                                            }
                                            else
                                            {
                                                runStep.ElementsField["status"] = "No Run";
                                            }
                                        }

                                        QCItem          stepToUpdate      = ConvertObjectValuesToQCItem(runStep, ResourceType.RUN_STEP);
                                        ALMResponseData stepDataForUpdate = QCRestAPIConnect.UpdateEntity(ResourceType.RUN_STEP, runStep.Id, stepToUpdate);

                                        index++;
                                    }

                                    //get all execution status for all steps
                                    ObservableList <string> stepsStatuses = new ObservableList <string>();
                                    foreach (QCRunStep runStep in runSteps)
                                    {
                                        stepsStatuses.Add(runStep.Status);
                                    }

                                    //update the TC general status based on the activities status collection.
                                    if (stepsStatuses.Where(x => x == "Failed").Count() > 0)
                                    {
                                        currentRun.Status = "Failed";
                                    }
                                    else if (stepsStatuses.Where(x => x == "No Run").Count() == runSteps.Count || stepsStatuses.Where(x => x == "N/A").Count() == runSteps.Count)
                                    {
                                        currentRun.Status = "No Run";
                                    }
                                    else if (stepsStatuses.Where(x => x == "Passed").Count() == runSteps.Count || (stepsStatuses.Where(x => x == "Passed").Count() + stepsStatuses.Where(x => x == "N/A").Count()) == runSteps.Count)
                                    {
                                        currentRun.ElementsField["status"] = "Passed";
                                    }
                                    else
                                    {
                                        currentRun.ElementsField["status"] = "Not Completed";
                                    }

                                    QCItem          runToUpdate      = ConvertObjectValuesToQCItem(currentRun, ResourceType.TEST_RUN);
                                    ALMResponseData runDataForUpdate = QCRestAPIConnect.UpdateEntity(ResourceType.TEST_RUN, currentRun.Id, runToUpdate);
                                }
                                else
                                {
                                    //No matching TC was found for the ActivitiesGroup in QC
                                    result = "Matching TC's were not found for all " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroups) + " in QC/ALM.";
                                }
                            }
                            if (result != string.Empty)
                            {
                                return(false);
                            }
                        }
                    }
                    else
                    {
                        //No matching Test Set was found for the BF in QC
                        result = "No matching Test Set was found in QC/ALM.";
                    }

                    if (result == string.Empty)
                    {
                        result = "Export performed successfully.";
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            catch (Exception ex)
            {
                result = "Unexpected error occurred- " + ex.Message;
                Reporter.ToLog(eLogLevel.ERROR, "Failed to export execution details to QC/ALM", ex);
                return(false);
            }

            return(false); // Remove it at the end
        }
Exemple #3
0
 public QCTestSet GetQCTestSet(string testSetID)
 {
     return(ImportFromQCRest.GetQCTestSet(testSetID));
 }