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 ExportBusinessFlowToQC(BusinessFlow businessFlow, QCTestSet mappedTestSet, string uploadPath, ObservableList <ExternalItemFieldBase> testSetFields, ObservableList <ExternalItemFieldBase> testInstanceFields, ref string result)
        {
            QCTestSet testSet = null;
            ObservableList <ActivitiesGroup> existingActivitiesGroups = new ObservableList <ActivitiesGroup>();

            try
            {
                if (mappedTestSet == null) //##create new Test Set in QC
                {
                    testSet = CreateNewTestSet(businessFlow, uploadPath, testSetFields);
                    CreateNewTestInstances(businessFlow, existingActivitiesGroups, testSet, testInstanceFields);
                }
                else //##update existing test set
                {
                    testSet = UpdateExistingTestSet(businessFlow, mappedTestSet, uploadPath, testSetFields);
                    UpdateTestInstances(businessFlow, existingActivitiesGroups, testSet, testInstanceFields);
                }

                businessFlow.ExternalID = testSet.Id.ToString();
                return(true);
            }
            catch (Exception ex)
            {
                result = "Unexpected error occurred- " + ex.Message;
                Reporter.ToLog(eLogLevel.ERROR, "Failed to export the Business Flow to QC/ALM", ex);
                return(false);
            }
        }
Esempio n. 3
0
        private static BusinessFlow CreateBusinessFlow(QCTestSet tS)
        {
            BusinessFlow busFlow = new BusinessFlow();

            busFlow.Name        = tS.Name;
            busFlow.ExternalID  = tS.Id;
            busFlow.Description = tS.ElementsField["description"].ToString();
            busFlow.Status      = BusinessFlow.eBusinessFlowStatus.Development;
            busFlow.Activities  = new ObservableList <Activity>();
            busFlow.Variables   = new ObservableList <VariableBase>();

            return(busFlow);
        }
        private static QCTestSet CreateNewTestSet(BusinessFlow businessFlow, string uploadPath, ObservableList <ExternalItemFieldBase> testSetFields)
        {
            QCTestSet testSet = new QCTestSet();

            //set the upload path
            testSet.ElementsField["parent-id"] = QCRestAPIConnect.GetLastTestSetIdFromPath(uploadPath).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")
                    {
                        testSet.ElementsField[field.ExternalID] = field.SelectedValue;
                    }
                    else
                    {
                        try { testSet.ElementsField[field.ID] = "NA"; }
                        catch { }
                    }
                }
            }

            testSet.ElementsField["name"]       = businessFlow.Name;
            testSet.ElementsField["subtype-id"] = "hp.qc.test-set.default";

            try
            {
                QCItem          item     = ConvertObjectValuesToQCItem(testSet, ResourceType.TEST_SET);
                ALMResponseData response = QCRestAPIConnect.CreateNewEntity(ResourceType.TEST_SET, item);
                return(QCRestAPIConnect.GetTestSetDetails(response.IdCreated));
            }
            catch (Exception ex)
            {
                if (ex.Message.Contains("The Test Set already exists"))
                {
                    string result = "Cannot export Business Flow - The Test Set already exists in the selected folder. ";
                    Reporter.ToLog(eLogLevel.ERROR, result, ex);
                    return(null);
                }

                Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}");
                return(null);
            }
        }
Esempio n. 5
0
        private void SetTestSetsData()
        {
            mQcTestCasesList.Clear();
            mTestCaseDetailsList.Clear();
            mAutomatedPrecentage  = 0;
            mExecutedNumber       = 0;
            mRunsNumber           = 0;
            mPassedRunsPrecentage = 0;
            if (mSelectQcTestSets != null && mSelectQcTestSets.Count > 0)
            {
                foreach (QCTestSetTreeItem testSetItem in mSelectQcTestSets)
                {
                    QCTestSet TS = new QCTestSet();
                    TS.TestSetID   = testSetItem.TestSetID;
                    TS.TestSetName = testSetItem.TestSetName;
                    TS.TestSetPath = testSetItem.Path;
                    TS             = ImportFromQC.ImportTestSetData(TS);//get test cases

                    foreach (QCTSTest tc in TS.Tests)
                    {
                        mQcTestCasesList.Add(tc);
                        int automatedStepsCouter = 0;
                        QCManagerReportTestCaseDetails testCaseDetails = new QCManagerReportTestCaseDetails();
                        testCaseDetails.TestSetID    = TS.TestSetID;
                        testCaseDetails.TestSetName  = TS.TestSetName;
                        testCaseDetails.TestCaseID   = tc.LinkedTestID;
                        testCaseDetails.TestCaseName = tc.TestName;

                        //check if the TC is already exist in repository
                        ActivitiesGroup repoActivsGroup = null;

                        ObservableList <ActivitiesGroup> activitiesGroup = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <ActivitiesGroup>();
                        if (tc.LinkedTestID != null && tc.LinkedTestID != string.Empty)
                        {
                            repoActivsGroup = activitiesGroup.Where(x => x.ExternalID == tc.LinkedTestID).FirstOrDefault();
                        }
                        if (repoActivsGroup == null)
                        {
                            repoActivsGroup = activitiesGroup.Where(x => x.ExternalID == tc.TestID).FirstOrDefault();
                        }
                        if (repoActivsGroup != null)
                        {
                            testCaseDetails.ActivitiesGroupID   = repoActivsGroup.Guid;
                            testCaseDetails.ActivitiesGroupName = repoActivsGroup.Name;
                            //check for automation percentage
                            foreach (QCTSTestStep step in tc.Steps)
                            {
                                ObservableList <Activity> activities = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();
                                Activity repoStepActivity            = activities.Where(x => x.ExternalID == step.StepID).FirstOrDefault();
                                if (repoStepActivity != null)
                                {
                                    if (repoStepActivity.AutomationStatus == Activity.eActivityAutomationStatus.Automated)
                                    {
                                        automatedStepsCouter++;
                                    }
                                }
                            }
                        }
                        else
                        {
                            testCaseDetails.ActivitiesGroupName = "NA";
                        }
                        //set automation percentage
                        double automatedActsPrecanteg = 0;
                        if (tc.Steps.Count > 0)
                        {
                            automatedActsPrecanteg = ((double)automatedStepsCouter / (double)tc.Steps.Count);
                            mAutomatedPrecentage  += automatedActsPrecanteg;
                            automatedActsPrecanteg = Math.Floor(automatedActsPrecanteg * 100);
                            testCaseDetails.ActivitiesGroupAutomationPrecentage = automatedActsPrecanteg.ToString() + "%";
                        }
                        else
                        {
                            testCaseDetails.ActivitiesGroupAutomationPrecentage = "0%";
                        }

                        //set execution details
                        CalculateTCExecutionDetails(tc, testCaseDetails);

                        mTestCaseDetailsList.Add(testCaseDetails);
                    }
                }
            }

            //get the executers names
            var groups = mQcTestCasesList.SelectMany(x => x.Runs).GroupBy(y => y.Tester)
                         .Select(n => new
            {
                TesterName = n.Key.ToString(),
                Count      = n.Count()
            }
                                 )
                         .OrderBy(n => n.TesterName);

            ExecutionTesterFilterComboBox.SelectionChanged -= ExecutionTesterFilterComboBox_SelectionChanged;
            ExecutionTesterFilterComboBox.SelectedItem      = null;
            ExecutionTesterFilterComboBox.Items.Clear();
            ExecutionTesterFilterComboBox.Items.Add("Any");
            foreach (var v in groups)
            {
                ExecutionTesterFilterComboBox.Items.Add(v.TesterName);
            }
            ExecutionTesterFilterComboBox.SelectedValue     = "Any";
            ExecutionTesterFilterComboBox.SelectionChanged += ExecutionTesterFilterComboBox_SelectionChanged;
        }
        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
        }
        private static void UpdateTestInstances(BusinessFlow businessFlow, ObservableList <ActivitiesGroup> existingActivitiesGroups, QCTestSet testSet, ObservableList <ExternalItemFieldBase> testInstancesFields)
        {
            QCTestInstanceColl testInstances = ImportFromQCRest.ImportTestSetInstanceData(testSet);

            foreach (QCTestInstance testInstance in testInstances)
            {
                ActivitiesGroup ag = businessFlow.ActivitiesGroups.Where(x => (x.ExternalID == testInstance.TestId.ToString() && x.ExternalID2 == testInstance.Id.ToString())).FirstOrDefault();
                if (ag == null)
                {
                    QCRestAPIConnect.DeleteEntity(ResourceType.TEST_CYCLE, testInstance.Id);
                }
                else
                {
                    existingActivitiesGroups.Add(ag);
                    //set item fields for test instances
                    foreach (ExternalItemFieldBase field in testInstancesFields)
                    {
                        if ((field.ToUpdate || field.Mandatory) && (!(field.ExternalID == "test-id") && !(field.ExternalID == "cycle-id")))
                        {
                            if (string.IsNullOrEmpty(field.ExternalID) == false && field.SelectedValue != "NA")
                            {
                                if (testInstance.ElementsField.ContainsKey(field.ID))
                                {
                                    testInstance.ElementsField[field.ExternalID] = field.SelectedValue;
                                }
                            }
                        }
                    }

                    try
                    {
                        QCItem          item     = ConvertObjectValuesToQCItem(testInstance, ResourceType.TEST_CYCLE, true);
                        ALMResponseData response = QCRestAPIConnect.UpdateEntity(ResourceType.TEST_CYCLE, testInstance.Id, item);

                        if (response.IsSucceed)
                        {
                            testInstances.Add(QCRestAPIConnect.GetTestInstanceDetails(testInstance.Id));
                            ag.ExternalID2 = response.IdCreated;//the test case instance ID in the test set- used for exporting the execution details
                        }
                    }
                    catch (Exception ex)
                    {
                        Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}");
                    }
                }
            }
        }
        private static void CreateNewTestInstances(BusinessFlow businessFlow, ObservableList <ActivitiesGroup> existingActivitiesGroups, QCTestSet testSet, ObservableList <ExternalItemFieldBase> testInstancesFields)
        {
            int counter = 1;

            foreach (ActivitiesGroup ag in businessFlow.ActivitiesGroups)
            {
                if (existingActivitiesGroups.Contains(ag) == false && string.IsNullOrEmpty(ag.ExternalID) == false && ImportFromQCRest.GetQCTest(ag.ExternalID) != null)
                {
                    QCTestInstance testInstance = new QCTestInstance
                    {
                        TestId    = ag.ExternalID,
                        CycleId   = testSet.Id,
                        TestOrder = counter++.ToString(),
                    };

                    //set item fields for test instances
                    foreach (ExternalItemFieldBase field in testInstancesFields)
                    {
                        if ((field.ToUpdate || field.Mandatory) && (!(field.ExternalID == "test-id") && !(field.ExternalID == "cycle-id")))
                        {
                            if (string.IsNullOrEmpty(field.ExternalID) == false && field.SelectedValue != "NA")
                            {
                                testInstance.ElementsField[field.ExternalID] = field.SelectedValue;
                            }
                            else
                            {
                                try { testInstance.ElementsField[field.ID] = "NA"; }
                                catch { }
                            }
                        }
                    }

                    testInstance.ElementsField["subtype-id"] = "hp.qc.test-instance.MANUAL";
                    QCItem          item     = ConvertObjectValuesToQCItem(testInstance, ResourceType.TEST_CYCLE);
                    ALMResponseData response = QCRestAPIConnect.CreateNewEntity(ResourceType.TEST_CYCLE, item);

                    if (response.IsSucceed) // # Currently bug in HPE failing the test instance creation despite it working.
                    {
                        //QCTestInstance testInstanceCreated = QCRestAPIConnect.QcRestClient.GetTestInstanceDetails(response.IdCreated);
                        ag.ExternalID2 = response.IdCreated;//the test case instance ID in the test set- used for exporting the execution details
                    }
                }
            }
        }
Esempio n. 9
0
        public override bool ImportSelectedTests(string importDestinationPath, IEnumerable <Object> selectedTestSets)
        {
            if (selectedTestSets != null && selectedTestSets.Count() > 0)
            {
                ObservableList <QCTestSetTreeItem> testSetsItemsToImport = new ObservableList <QCTestSetTreeItem>();
                bool bfsWereDeleted = false;
                foreach (QCTestSetTreeItem testSetItem in selectedTestSets)
                {
                    //check if some of the Test Set was already imported
                    if (testSetItem.AlreadyImported == true)
                    {
                        Amdocs.Ginger.Common.eUserMsgSelection userSelection = Reporter.ToUser(eUserMsgKey.TestSetExists, testSetItem.TestSetName);
                        if (userSelection == Amdocs.Ginger.Common.eUserMsgSelection.Yes)
                        {
                            //Delete the mapped BF
                            File.Delete(testSetItem.MappedBusinessFlow.FileName);
                            bfsWereDeleted = true;
                            testSetsItemsToImport.Add(testSetItem);
                        }
                    }
                    else
                    {
                        testSetsItemsToImport.Add(testSetItem);
                    }
                }

                if (testSetsItemsToImport.Count == 0)
                {
                    return(false);                                  //noting to import
                }
                //Refresh Ginger repository and allow GingerQC to use it
                ALMIntegration.Instance.AlmCore.GingerActivitiesGroupsRepo = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <ActivitiesGroup>();
                ALMIntegration.Instance.AlmCore.GingerActivitiesRepo       = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();

                foreach (QCTestSetTreeItem testSetItemtoImport in testSetsItemsToImport)
                {
                    try
                    {
                        //import test set data
                        Reporter.ToStatus(eStatusMsgKey.ALMTestSetImport, null, testSetItemtoImport.TestSetName);
                        QCTestSet TS = new QCTestSet();
                        TS.TestSetID   = testSetItemtoImport.TestSetID;
                        TS.TestSetName = testSetItemtoImport.TestSetName;
                        TS.TestSetPath = testSetItemtoImport.Path;
                        TS             = ((QCCore)ALMIntegration.Instance.AlmCore).ImportTestSetData(TS);

                        //convert test set into BF
                        BusinessFlow tsBusFlow = ((QCCore)ALMIntegration.Instance.AlmCore).ConvertQCTestSetToBF(TS);

                        //Set BF/Activities target application
                        //if ( WorkSpace.UserProfile.Solution.MainApplication != null)
                        //{
                        //    if (tsBusFlow.TargetApplications.Count == 0)
                        //    {
                        //        tsBusFlow.TargetApplications.Add(new TargetApplication() { AppName =  WorkSpace.UserProfile.Solution.MainApplication });
                        //        if (tsBusFlow.TargetApplications.Count > 0)
                        //            foreach (Activity activ in tsBusFlow.Activities)
                        //                activ.TargetApplication = tsBusFlow.TargetApplications[0].AppName;
                        //    }
                        //}
                        if (WorkSpace.UserProfile.Solution.MainApplication != null)
                        {
                            //add the applications mapped to the Activities
                            foreach (Activity activ in tsBusFlow.Activities)
                            {
                                if (string.IsNullOrEmpty(activ.TargetApplication) == false)
                                {
                                    if (tsBusFlow.TargetApplications.Where(x => x.Name == activ.TargetApplication).FirstOrDefault() == null)
                                    {
                                        ApplicationPlatform appAgent = WorkSpace.UserProfile.Solution.ApplicationPlatforms.Where(x => x.AppName == activ.TargetApplication).FirstOrDefault();
                                        if (appAgent != null)
                                        {
                                            tsBusFlow.TargetApplications.Add(new TargetApplication()
                                            {
                                                AppName = appAgent.AppName
                                            });
                                        }
                                    }
                                }
                            }
                            //handle non mapped Activities
                            if (tsBusFlow.TargetApplications.Count == 0)
                            {
                                tsBusFlow.TargetApplications.Add(new TargetApplication()
                                {
                                    AppName = WorkSpace.UserProfile.Solution.MainApplication
                                });
                            }
                            foreach (Activity activ in tsBusFlow.Activities)
                            {
                                if (string.IsNullOrEmpty(activ.TargetApplication))
                                {
                                    activ.TargetApplication = tsBusFlow.MainApplication;
                                }
                                activ.Active = true;
                            }
                        }
                        else
                        {
                            foreach (Activity activ in tsBusFlow.Activities)
                            {
                                activ.TargetApplication = null; // no app configured on solution level
                            }
                        }

                        //save bf
                        WorkSpace.Instance.SolutionRepository.AddRepositoryItem(tsBusFlow);
                        Reporter.HideStatusMessage();
                    }
                    catch (Exception ex)
                    {
                        Reporter.ToUser(eUserMsgKey.ErrorInTestsetImport, testSetItemtoImport.TestSetName, ex.Message);
                        Reporter.ToLog(eLogLevel.ERROR, "Error importing from QC", ex);
                    }
                }

                Reporter.ToUser(eUserMsgKey.TestSetsImportedSuccessfully);

                Reporter.ToLog(eLogLevel.DEBUG, "Imported from QC successfully");
                return(true);
            }
            Reporter.ToLog(eLogLevel.ERROR, "Error importing from QC");
            return(false);
        }
Esempio n. 10
0
        public override bool ExportBusinessFlowToALM(BusinessFlow businessFlow, bool performSaveAfterExport = false, ALMIntegration.eALMConnectType almConectStyle = ALMIntegration.eALMConnectType.Manual, string testPlanUploadPath = null, string testLabUploadPath = null)
        {
            if (businessFlow == null)
            {
                return(false);
            }

            if (businessFlow.ActivitiesGroups.Count == 0)
            {
                Reporter.ToUser(eUserMsgKey.StaticInfoMessage, "The " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + " do not include " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroups) + " which supposed to be mapped to ALM Test Cases, please add at least one " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup) + " before doing export.");
                return(false);
            }

            QCTestSet matchingTS = null;

            Amdocs.Ginger.Common.eUserMsgSelection userSelec;
            //TO DO MaheshK : check if the businessFlow already mapped to Octane Test Suite
            if (!String.IsNullOrEmpty(businessFlow.ExternalID))
            {
                matchingTS = ((OctaneCore)ALMIntegration.Instance.AlmCore).GetTestSuiteById(businessFlow.ExternalID);
                if (matchingTS != null)
                {
                    //ask user if want to continute
                    userSelec = Reporter.ToUser(eUserMsgKey.BusinessFlowAlreadyMappedToTC, businessFlow.Name, matchingTS.Name);
                    if (userSelec == Amdocs.Ginger.Common.eUserMsgSelection.Cancel)
                    {
                        return(false);
                    }
                    else if (userSelec == Amdocs.Ginger.Common.eUserMsgSelection.No)
                    {
                        matchingTS         = null;
                        testPlanUploadPath = SelectALMTestPlanPath();
                        if (String.IsNullOrEmpty(testPlanUploadPath))
                        {
                            //no path to upload to
                            return(false);
                        }
                        //create upload path if checked to create separete folder
                        if (QCTestPlanFolderTreeItem.IsCreateBusinessFlowFolder)
                        {
                            try
                            {
                                string folderId = octaneCore.GetLastTestPlanIdFromPath(testPlanUploadPath).ToString();
                                folderId           = octaneCore.CreateApplicationModule(businessFlow.Name, businessFlow.Description, folderId);
                                testPlanUploadPath = folderId;
                            }
                            catch (Exception ex)
                            {
                                Reporter.ToLog(eLogLevel.ERROR, "Failed to get create folder for Test Plan with Octane REST API", ex);
                            }
                        }
                        else
                        {
                            testPlanUploadPath = octaneCore.GetLastTestPlanIdFromPath(testPlanUploadPath).ToString();
                        }
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(testPlanUploadPath))
                        {
                            testPlanUploadPath = matchingTS.ParentId;
                        }
                    }
                }
            }

            testLabUploadPath = testPlanUploadPath;
            bool performSave = false;

            //just to check if new TC needs to be created or update has to be done
            if (matchingTS == null)
            {
                matchingTC = null;
            }
            else
            {
                matchingTC = new QCTestCase();
            }
            //check if all of the business flow activities groups already exported to Octane and export the ones which not
            foreach (ActivitiesGroup ag in businessFlow.ActivitiesGroups)
            {
                ExportActivitiesGroupToALM(ag, testPlanUploadPath, performSave, businessFlow);
            }

            //upload the business flow
            Reporter.ToStatus(eStatusMsgKey.ExportItemToALM, null, businessFlow.Name);
            string res = string.Empty;

            ObservableList <ExternalItemFieldBase> allFields = new ObservableList <ExternalItemFieldBase>(WorkSpace.Instance.Solution.ExternalItemsFields);

            ALMIntegration.Instance.RefreshALMItemFields(allFields, true, null);

            ObservableList <ExternalItemFieldBase> testSetFieldsFields = CleanUnrelvantFields(allFields, "Test Suite");

            bool exportRes = ((OctaneCore)ALMIntegration.Instance.AlmCore).ExportBusinessFlow(businessFlow, matchingTS, testLabUploadPath, testSetFieldsFields, null, ref res);

            Reporter.HideStatusMessage();
            if (exportRes)
            {
                if (performSaveAfterExport)
                {
                    Reporter.ToStatus(eStatusMsgKey.SaveItem, null, businessFlow.Name, GingerDicser.GetTermResValue(eTermResKey.BusinessFlow));
                    WorkSpace.Instance.SolutionRepository.SaveRepositoryItem(businessFlow);
                    Reporter.HideStatusMessage();
                }
                if (almConectStyle != ALMIntegration.eALMConnectType.Auto)
                {
                    Reporter.ToUser(eUserMsgKey.ExportItemToALMSucceed);
                }
                return(true);
            }
            else
            if (almConectStyle != ALMIntegration.eALMConnectType.Auto)
            {
                Reporter.ToUser(eUserMsgKey.ExportItemToALMFailed, GingerDicser.GetTermResValue(eTermResKey.BusinessFlow), businessFlow.Name, res);
            }

            return(false);
        }
Esempio n. 11
0
 public bool ExportBusinessFlowToALM(BusinessFlow businessFlow, QCTestSet mappedTestSet, string uploadPath, ObservableList <ExternalItemFieldBase> testSetFields, ObservableList <ExternalItemFieldBase> testInstanceFields, ref string result)
 {
     return(ExportToQCRestAPI.ExportBusinessFlowToQC(businessFlow, mappedTestSet, uploadPath, testSetFields, testInstanceFields, ref result));
 }
Esempio n. 12
0
 public BusinessFlow ConvertQCTestSetToBF(QCTestSet testSet)
 {
     return(ImportFromQC.ConvertQCTestSetToBF(testSet));
 }
Esempio n. 13
0
 public QCTestSet ImportTestSetData(QCTestSet TS)
 {
     return(ImportFromQC.ImportTestSetData(TS));
 }