001package com.thed.zblast.util;
002
003import java.io.IOException;
004import java.util.*;
005import java.util.Map.Entry;
006import java.util.logging.Logger;
007import java.util.stream.Collectors;
008
009import com.thed.model.*;
010import org.apache.commons.beanutils.BeanUtils;
011import org.apache.commons.configuration.PropertiesConfiguration;
012import org.apache.commons.lang.StringUtils;
013
014import com.thed.util.Utils;
015import com.thed.util.ZeeConstants;
016import com.thed.util.ZephyrTestCaseUploader;
017import com.thed.zblast.launcher.ZblastLauncher;
018import com.thed.zblast.parser.JUnitResultParser;
019import com.thed.zblast.parser.model.TCRCatalogTreeTestcase;
020import com.thed.zblast.parser.model.TCRTestcase;
021import com.thed.zblast.parser.model.TestcaseModel;
022
023public class TestcaseUploader {
024        private ZephyrConfigModel zephyrData = null;
025        private static Logger logger = Logger.getLogger(ResultParser.class.getName());
026
027        private  TCRCatalogTreeDTO checkAndCreatePhase(AutomationJobDetail automationJobDetail) throws Exception {
028                TCRCatalogTreeDTO tree=null;
029                tree=isPhaseExists(automationJobDetail);
030                if(tree==null) {
031                        Thread.sleep(500);
032                        tree=isPhaseExists(automationJobDetail);
033                        if(tree==null) {
034                                tree=createPhase(automationJobDetail);
035                        }
036                }
037                return tree;
038
039        }
040
041        private TCRCatalogTreeDTO isPhaseExists(AutomationJobDetail automationJobDetail) throws Exception {
042                TCRCatalogTreeDTO tree = null;
043                List<TCRCatalogTreeDTO> testCaseTreesByCriteria;
044        if(automationJobDetail.getJobDetailTcrCatalogTreeId()!=null){
045            tree=RestUtil.getTreesByTreeId(automationJobDetail.getJobDetailTcrCatalogTreeId());
046        }else{
047            if(automationJobDetail.getTcrCatalogTreeId()!=null){
048                tree=RestUtil.getTreesByTreeId(automationJobDetail.getTcrCatalogTreeId());
049            }
050            if(tree==null){
051                try {
052                    testCaseTreesByCriteria = RestUtil.getTreesByReleaseId(automationJobDetail,"phase", 0);
053                    if (testCaseTreesByCriteria!=null && testCaseTreesByCriteria.size() > 0 ) {
054                        tree = testCaseTreesByCriteria.stream()
055                                .filter(t -> t.getName().equals(automationJobDetail.getPhaseName())).findFirst()
056                                .orElse(null);
057                    }
058                } catch (IOException e) {
059                    logger.severe("Exception while checking phase: "+e.getMessage());
060                    throw new Exception(e);
061                }
062            }
063        }
064                return tree;
065        }
066
067        private  TCRCatalogTreeDTO createPhase(AutomationJobDetail automationJobDetail) throws Exception {
068                TCRCatalogTreeDTO catelogTree = new TCRCatalogTreeDTO();
069                try {
070
071                catelogTree.setDescription(ZeeConstants.PACKAGE_FALSE_COMMENT);
072                catelogTree.setReleaseId(Long.valueOf(automationJobDetail.getReleaseId()));
073                catelogTree.setName(automationJobDetail.getPhaseName());
074                catelogTree.setType("Phase");
075                catelogTree=    RestUtil.createNode(catelogTree, "phase", 0L,null);
076                } catch (IOException e) {
077                        catelogTree=null;
078                        logger.severe("Exception while creating phase: "+e.getMessage());
079                        throw new Exception(e);
080                }
081                return catelogTree;
082        }
083
084        private List<TestcaseModel> parseAndGetTestcase(AutomationJobDetail automationJob, Long userId, Long scheduleId) throws Exception {
085                PropertiesConfiguration props = Utils.getZbotProperties();
086                String useGenericParser=props.getString("use_generic_parser");
087                Boolean isGenericParserUsed = Boolean.valueOf((useGenericParser==null)?"false":useGenericParser);
088
089                ZblastScriptExecutionResult executionResult = new ZblastScriptExecutionResult();
090                new ZblastLauncher().invoke(automationJob, executionResult);
091                List<TestcaseModel> testsFromTestSuiteList=null;
092
093                if ((executionResult.getTestSuite() == null || executionResult.getTestSuite().isEmpty())
094                                || (automationJob.isInvokeScript() && (automationJob.getScriptPath() != null &&
095                                automationJob.getScriptPath().isEmpty()    && !executionResult.isScriptExecutionSatus()))) {
096                        if (executionResult.getTestSuite() == null || executionResult.getTestSuite().isEmpty()) {
097                                RestUtil.updateStatus(scheduleId, ZeeConstants.ZBLAST_JOB_STATUS_SCRIPT_ERROR_FILE +" [ "+ automationJob.getAutomationFramework() +" ] ", automationJob, 0);
098                                return null;
099                        } else if (automationJob.isInvokeScript() && (automationJob.getScriptPath() != null &&
100                                        automationJob.getScriptPath().isEmpty() && !executionResult.isScriptExecutionSatus())) {
101                                RestUtil.updateStatus(scheduleId, ZeeConstants.ZBLAST_JOB_STATUS_SCRIPT_ERROR, automationJob, 0);
102                                return null;
103                        }
104                }
105
106                if(isGenericParserUsed){
107                        testsFromTestSuiteList = JUnitResultParser.getTestsFromTestSuiteListFromGenericParser(executionResult.getTestSuite(), automationJob);
108                }else{
109                        testsFromTestSuiteList = JUnitResultParser.getTestsFromTestSuiteList(executionResult.getTestSuite(), automationJob);
110                }
111
112
113
114                ZephyrTestCaseUploader uploader=new ZephyrTestCaseUploader();
115                zephyrData= uploader.initializeZephyrData(automationJob, Utils.getZbotProperties(), userId);
116                uploader.prepareZephyrTests(zephyrData, testsFromTestSuiteList, executionResult.getTestSuite(), automationJob.getCreatePackage());
117
118                return testsFromTestSuiteList;
119        }
120
121        public static String findPackageName(String testCaseNameWithPackage) {
122                String packageName = "";
123                if (StringUtils.isBlank(testCaseNameWithPackage)) {
124                        return packageName;
125                }
126                String[] split = testCaseNameWithPackage.split("\\.");
127                int splitCount = split.length;
128                for (int i = 0; i < split.length; i++) {
129                        if (splitCount > 1) {
130                                if (i == splitCount - 1)
131                                        break;
132                                packageName += split[i];
133                                packageName += ".";
134                        }
135                }
136                String removeEnd = StringUtils.removeEnd(packageName, ".");
137                return removeEnd;
138        }
139
140        private List<TCRCatalogTreeTestcase> checkAndCreateTestCases(AutomationJobDetail automationJobDetail,
141                        Long userId,TCRCatalogTreeDTO tcrTree) throws Exception {
142
143                List<TCRCatalogTreeTestcase> newTestcases = new ArrayList<TCRCatalogTreeTestcase>();
144                List<TCRCatalogTreeTestcase> ExistingTestcases = new ArrayList<TCRCatalogTreeTestcase>();
145                List<TCRCatalogTreeTestcase> savedList = new ArrayList<TCRCatalogTreeTestcase>();
146                List<TCRCatalogTreeTestcase> updateTagTestcases = new ArrayList<>();
147
148                TCRCatalogTreeTestcase treeTestcase = null;
149                TCRCatalogTreeDTO treeDto = null;
150                long testcaseTreeId = 0L;
151
152                try {
153                        Map<String, TCRCatalogTreeDTO> packageRepositoryStructureMap = null;
154                        packageRepositoryStructureMap = createPackageRepositoryStructure(zephyrData,tcrTree);
155                        TCRCatalogTree tree = new TCRCatalogTree();
156                    List<TestCaseResultModel> testcases = zephyrData.getTestcases();
157                        Map<Long,List<TCRCatalogTreeTestcase>> treeTestcasesMap=new HashMap<>();
158                        TCRCatalogTreeTestcase remoteRepositoryTreeTestcase=null;
159
160                        for(Entry<String, TCRCatalogTreeDTO> iterator: packageRepositoryStructureMap.entrySet()) {
161                                SearchResult results = RestUtil.searchtestcase(iterator.getValue().getId());
162                                List<TCRCatalogTreeTestcase> testCasesByCriteria = (List<TCRCatalogTreeTestcase>) (results.getResults().size() > 0? results.getResults(): new ArrayList());
163                                treeTestcasesMap.put(iterator.getValue().getId(), testCasesByCriteria);
164                        }
165
166                        Set<Long> existingTCRTestcaseIdSet = new HashSet<>();//set of tcrTestcaseId picked up for existing testcases to avoid picking same testcase due to duplicate testcase names
167
168                        HashMap<TCRTestcase, List<String>> testcaseSteps = new HashMap<>();
169                        for (Iterator<TestCaseResultModel> iterator = testcases.iterator(); iterator.hasNext();) {
170                                TestCaseResultModel testCaseWithStatus = iterator.next();
171                                TCRTestcase remoteTestcase = testCaseWithStatus.getTestcase();
172                                remoteTestcase.setTestSteps(testCaseWithStatus.getTestStep());
173                                treeTestcase = new TCRCatalogTreeTestcase();
174                                if (zephyrData.isCreatePackage()) {
175                                        treeDto = packageRepositoryStructureMap.get(findPackageName(remoteTestcase.getName()));
176                                        remoteTestcase.setName(remoteTestcase.getName().substring(
177                                                        remoteTestcase.getName().lastIndexOf(".") + 1, remoteTestcase.getName().length()));
178                                } else {
179                                        treeDto = packageRepositoryStructureMap.get("parentPhase");
180                                }
181                                BeanUtils.copyProperties(tree, treeDto);
182                                testcaseTreeId = tree.getId();
183
184                                List<TCRCatalogTreeTestcase> testCasesByCriteria = treeTestcasesMap.get(testcaseTreeId);
185                                if(!testCasesByCriteria.isEmpty()) {
186
187                                        remoteRepositoryTreeTestcase=testCasesByCriteria.stream().filter(tc->{
188
189                                                boolean isTestcaseNameNotEqualToRemoteTestcase = !tc.getTestcase().getName().equals(remoteTestcase.getName());
190                                                boolean isTCRTestcaseSetContainingTestcaseId = existingTCRTestcaseIdSet.contains(tc.getId());
191                                                if (isTestcaseNameNotEqualToRemoteTestcase || isTCRTestcaseSetContainingTestcaseId) {
192                                                        return false;
193                                                }
194
195                                                boolean iCheckSteps = Utils.getZbotProperties().getBoolean("checkSteps", false);
196                                                if (!iCheckSteps) {
197                                                        return true;
198                                                }
199
200                                                List<String> remoteSteps;
201
202                                                if (remoteTestcase.getTestSteps() != null) {
203                                                        remoteSteps = remoteTestcase.getTestSteps().getSteps().stream().map(TestStepDetail::getStep).collect(Collectors.toList());
204                                                } else {
205                                                        remoteSteps = null;
206                                                }
207
208                                                List<String> steps = getSteps(testcaseSteps, tc);
209                                                return steps.equals(remoteSteps);
210                                        }).findFirst().orElse(null);
211                                }
212                                if(remoteRepositoryTreeTestcase ==null ) {
213                                        remoteTestcase.setExecutionRequest(testCaseWithStatus.getExecutionRequest());
214                                        treeTestcase.setTestcase(remoteTestcase);
215                                        remoteTestcase.setReleaseId(tree.getReleaseId());
216                                        treeTestcase.setTcrCatalogTreeId(testcaseTreeId);
217                                        newTestcases.add(treeTestcase);
218
219                                }else {
220                                        existingTCRTestcaseIdSet.add(remoteRepositoryTreeTestcase.getId());
221
222                                        String parsedTag = StringUtils.isBlank(remoteTestcase.getTag()) ? remoteTestcase.getTag() : remoteTestcase.getTag().trim().replaceAll(" +", " ");
223                                        String existingTag = StringUtils.isBlank(remoteRepositoryTreeTestcase.getTestcase().getTag())
224                                                        ? remoteRepositoryTreeTestcase.getTestcase().getTag() : remoteRepositoryTreeTestcase.getTestcase().getTag().trim().replaceAll(" +", " ");
225                                        if((StringUtils.isNotBlank(parsedTag))
226                                                        && (StringUtils.isBlank(existingTag) || !Utils.getSet(existingTag, " ").containsAll(Utils.getSet(parsedTag, " ")))) {
227                                                //parsed tag is not null and is not equal to existing tag so update the tag
228                                                remoteRepositoryTreeTestcase.getTestcase().setTag(StringUtils.isNotBlank(existingTag)
229                                                                ? existingTag + " " + parsedTag
230                                                                : parsedTag);
231                                                updateTagTestcases.add(remoteRepositoryTreeTestcase);
232                                                continue;
233                                        }
234
235                                        remoteRepositoryTreeTestcase.getTestcase().setTestSteps(remoteTestcase.getTestSteps());
236
237                                        remoteRepositoryTreeTestcase.getTestcase().setExecutionRequest(testCaseWithStatus.getExecutionRequest());
238
239                    remoteRepositoryTreeTestcase.getTestcase().setReleaseId(tree.getReleaseId());
240                                        if (remoteRepositoryTreeTestcase.getOriginal())
241                                                continue;
242                                        Long releaseId = remoteRepositoryTreeTestcase.getReleaseId();
243                                        if (releaseId == zephyrData.getReleaseId()) {
244                                                ExistingTestcases.add(remoteRepositoryTreeTestcase);
245                                        }
246                                }
247                        }
248                        if (newTestcases.size() > 0) {
249                                for(int i=0;i<newTestcases.size();i+=ZeeConstants.BATCH_SIZE){
250                                        final List<TCRCatalogTreeTestcase> tcrCatalogTreeTestcases = i + ZeeConstants.BATCH_SIZE > newTestcases.size() ? RestUtil.saveBulkTestCases(newTestcases.subList(i, newTestcases.size()), automationJobDetail) :
251                                                        RestUtil.saveBulkTestCases(newTestcases.subList(i, i + ZeeConstants.BATCH_SIZE), automationJobDetail);
252                                        savedList.addAll(tcrCatalogTreeTestcases);
253                                }
254                        }
255                        if (ExistingTestcases.size() > 0) {
256                                savedList.addAll(ExistingTestcases);
257                        }
258
259                        if(!updateTagTestcases.isEmpty()) {
260                                savedList.addAll(updateTestcaseTags(updateTagTestcases));
261                        }
262
263                        }
264                        catch (Exception e) {
265                        logger.severe("error while posting testcases "+e.getMessage());
266                        throw new Exception(e);
267                        }
268                        return savedList;
269                }
270
271        private List<String> getSteps(HashMap<TCRTestcase, List<String>> testcaseSteps, TCRCatalogTreeTestcase tc) {
272                List<String> steps = testcaseSteps.get(tc.getTestcase());
273
274                if (steps == null) {
275                        try {
276                                TestStep stepsForTestcases = RestUtil.getStepsForTestcase(tc.getTestcase().getId());
277
278                                steps = stepsForTestcases
279                                                .getSteps()
280                                                .stream()
281                                                .map(TestStepDetail::getStep)
282                                                .collect(Collectors.toList());
283                        } catch (IOException e) {
284                                steps = Collections.emptyList();
285                        }
286
287                        testcaseSteps.put(tc.getTestcase(), steps);
288                }
289                return steps;
290        }
291
292        private List<TCRCatalogTreeTestcase> updateTestcaseTags(List<TCRCatalogTreeTestcase> tcrCatalogTreeTestcaseList) throws IOException {
293                List<TCRCatalogTreeTestcase> resultList = new ArrayList<>();
294                Map<Set<String>, List<TctTestcaseVersionParam>> tagTestcaseMap = new HashMap<>();
295                List<List<TCRCatalogTreeTestcase>> subLists = Utils.partition(tcrCatalogTreeTestcaseList, ZeeConstants.BATCH_SIZE);
296
297                for(List<TCRCatalogTreeTestcase> subList : subLists) {
298                        for (TCRCatalogTreeTestcase tcrCatalogTreeTestcase : subList) {
299                                Set<String> tagSet = new HashSet<>(Arrays.asList(tcrCatalogTreeTestcase.getTestcase().getTag().split(" ")));
300                                TctTestcaseVersionParam param = new TctTestcaseVersionParam(tcrCatalogTreeTestcase.getId(), tcrCatalogTreeTestcase.getTestcase().getId());
301                                if(tagTestcaseMap.containsKey(tagSet)) {
302                                        tagTestcaseMap.get(tagSet).add(param);
303                                } else {
304                                        tagTestcaseMap.put(tagSet, new ArrayList<>(Collections.singletonList(param)));
305                                }
306                        }
307                        resultList.addAll(updateTagsInTestcases(tagTestcaseMap));
308                }
309                return resultList;
310        }
311
312        private List<TCRCatalogTreeTestcase> updateTagsInTestcases(Map<Set<String>, List<TctTestcaseVersionParam>> tagTestcaseMap) throws IOException {
313                List<TestcaseBulkUpdateParam> paramList = new ArrayList<>();
314                for(Map.Entry<Set<String>, List<TctTestcaseVersionParam>> entry : tagTestcaseMap.entrySet()) {
315                        //extra space padding before tag data as the api is not handling this without space as expected and corrupts the tag data
316                        paramList.add(new TestcaseBulkUpdateParam(" " + String.join(" ", entry.getKey()), entry.getValue()));
317                }
318                return RestUtil.updateTestcases(paramList);
319        }
320
321        private Map<String, TCRCatalogTreeDTO> createPackageRepositoryStructure(ZephyrConfigModel zephyrData, TCRCatalogTreeDTO treeDTO)
322                        throws IOException {
323                long parentNodeId=0l;
324                Map<String, TCRCatalogTreeDTO> RemoteRepositoryTreeMap = new HashMap<>();
325                Map<Long, TCRCatalogTreeDTO> tempRemoteRepositoryTreeMap = new HashMap<>();
326                Map<String, TCRCatalogTreeDTO> allNodesMap = new HashMap<>();
327                RemoteRepositoryTreeMap.put("parentPhase", treeDTO);
328                tempRemoteRepositoryTreeMap.put(treeDTO.getId(),treeDTO);
329
330                if (!zephyrData.isCreatePackage())
331                        return RemoteRepositoryTreeMap;
332
333                Set<String> packageNames = zephyrData.getPackageNames();
334                Set<TCRCatalogTreeDTO> children = treeDTO.getCategories();
335
336                for (Iterator<String> iterator = packageNames.iterator(); iterator.hasNext();) {
337                        String packageName = iterator.next();
338                        parentNodeId=treeDTO.getId();
339                        String[] packageNameArray = packageName.split("\\.");
340                        TCRCatalogTreeDTO previousRepository = treeDTO;
341                        for (int i = 0; i < packageNameArray.length; i++) {
342                                TCRCatalogTreeDTO childDto = null;
343                                if (tempRemoteRepositoryTreeMap.containsKey(packageNameArray[i])) {
344                                        previousRepository = tempRemoteRepositoryTreeMap.get(packageNameArray[i]);
345                                        if(previousRepository.getId()!=null && previousRepository.getId().longValue()==parentNodeId){
346                                                parentNodeId=previousRepository.getId();
347                                                continue;
348                                        }else{
349                                                previousRepository=tempRemoteRepositoryTreeMap.get(parentNodeId);
350                                        }
351                                }
352                                String packgeName = packageNameArray[i];
353                                if (!children.isEmpty()) {
354                                        childDto = children.stream().filter(c -> c.getName().equals(packgeName)).findAny().orElse(null);
355                                        if (childDto != null) {
356                                                children = childDto.getCategories();
357                                                if(!children.isEmpty()){
358                                                        children.stream().forEach(node->allNodesMap.put(node.getName(),node));
359                                                }
360                                        }
361                                }else{
362                                        childDto=allNodesMap.get(packgeName);
363                                        if(childDto!=null && childDto.getParentId().longValue()==parentNodeId){
364                                                childDto.getCategories().stream().forEach(node->allNodesMap.put(node.getName(),node));
365                                        }else{
366                                                childDto=null;
367                                        }
368                                }
369
370                                TCRCatalogTreeDTO tree1 = childDto;
371                                if (tree1 == null) {
372                                        tree1 = new TCRCatalogTreeDTO();
373                                        tree1.setDescription("Phase created by ZBOT");
374                                        tree1.setReleaseId(zephyrData.getReleaseId());
375                                        tree1.setName(packageNameArray[i]);
376                                        tree1.setParentId(previousRepository.getId());
377                                        tree1.setParentName(previousRepository.getName());
378                                        tree1.setType("Module");
379                                        tree1 = RestUtil.createNode(tree1, "", previousRepository.getId(),tree1.getParentName());
380                                }
381                                tree1.setParentName(previousRepository.getParentName());
382                                allNodesMap.put(tree1.getName(),tree1);
383                                previousRepository = tree1;
384                                parentNodeId=previousRepository.getId();
385                                tempRemoteRepositoryTreeMap.put(tree1.getId(), tree1);
386                        }
387                        RemoteRepositoryTreeMap.put(packageName, previousRepository);
388                }
389                return RemoteRepositoryTreeMap;
390        }
391
392        public List<TCRCatalogTreeTestcase> uploadTestcases(AutomationJobDetail job, Long userId, Long scheduleId) throws Exception {
393                List<TestcaseModel> testcaseModelList=parseAndGetTestcase(job,userId,scheduleId);
394                if(testcaseModelList==null){
395                        throw new Exception("Parsing failed");
396                }
397                TCRCatalogTreeDTO tree=checkAndCreatePhase(job);
398                job.setTcrCatalogTreeId(tree.getId());
399                List<TCRCatalogTreeTestcase> testcaseList=checkAndCreateTestCases(job, userId,  tree);
400        mapRequirementToTestcase(testcaseModelList, testcaseList);
401        setExecutionRequestOnCreatedTestcases(testcaseModelList, testcaseList);
402                return testcaseList.stream().filter(testCase->testCase.getRevision()==0).collect(Collectors.toList());
403        }
404
405    private void mapRequirementToTestcase(List<TestcaseModel> testcaseModelList, List<TCRCatalogTreeTestcase> testcaseList) throws IOException {
406        List<MapTestcaseToRequirement> mapTestcaseToRequirements =new ArrayList<>();
407
408        for(TestcaseModel testcaseModel : testcaseModelList){
409            if(testcaseModel.getRequirements()!=null && testcaseModel.getRequirements().size() > 0){
410                for(TCRCatalogTreeTestcase tcrCatalogTreeTestcase : testcaseList){
411                    //UFT uses testcase name and other framework tc name so OR condiotion on both
412                    if(testcaseModel.getTcName().equals(tcrCatalogTreeTestcase.getTestcase().getName()) || testcaseModel.getTestcaseName().equals(tcrCatalogTreeTestcase.getTestcase().getName())){
413                        MapTestcaseToRequirement mapTestcaseToRequirement = new MapTestcaseToRequirement();
414                        Set<Long> requirementIds = new HashSet<>();
415                        Set<String> requirementAltIds = new HashSet<>();
416                        for(String parsedRequirement : testcaseModel.getRequirements()){
417                            try {
418                                if (parsedRequirement.startsWith("ID_")) {
419                                    String[] splitRequirement = parsedRequirement.split("_");
420                                    requirementIds.add(Long.parseLong(splitRequirement[1]));
421                                }
422                                if (parsedRequirement.startsWith("AltID_")) {
423                                    String[] splitRequirement = parsedRequirement.split("_");
424                                    requirementAltIds.add(splitRequirement[1]);
425                                }
426                            }catch(Exception ex){
427                                logger.info("Requiremetid format is not correct"+ parsedRequirement);
428                            }
429                        }
430                        mapTestcaseToRequirement.setTestcaseId(tcrCatalogTreeTestcase.getTestcase().getTestcaseId());
431                        mapTestcaseToRequirement.setReleaseId(tcrCatalogTreeTestcase.getTestcase().getReleaseId());
432                        mapTestcaseToRequirement.setRequirementId(requirementIds);
433                        mapTestcaseToRequirement.setRequirementAltId(requirementAltIds);
434                        mapTestcaseToRequirements.add(mapTestcaseToRequirement);
435                    }
436                }
437            }
438        }
439        if(mapTestcaseToRequirements!=null && mapTestcaseToRequirements.size()>0){
440            RestUtil.updateRequirement(mapTestcaseToRequirements);
441        }
442    }
443
444    private void setExecutionRequestOnCreatedTestcases(List<TestcaseModel> testcaseModelList, List<TCRCatalogTreeTestcase> testcaseList) {
445                outerLoop : for (TestcaseModel testcaseModel : testcaseModelList) {
446                        for(TCRCatalogTreeTestcase tcrCatalogTreeTestcase : testcaseList) {
447                                if((testcaseModel.getTcName().equals(tcrCatalogTreeTestcase.getTestcase().getName()) || testcaseModel.getTestcaseName().equals(tcrCatalogTreeTestcase.getTestcase().getName()))
448                                && tcrCatalogTreeTestcase.getTestcase().getExecutionRequest() == null) {
449                                        tcrCatalogTreeTestcase.getTestcase().setExecutionRequest(testcaseModel.getExecutionRequest());
450                                        continue outerLoop;
451                                }
452                        }
453                }
454        }
455
456        public ZephyrConfigModel getZephyrData() {
457                return zephyrData;
458        }
459
460
461
462}