Examples with CerberusEventException org.cerberus.exception.CerberusEventException used on opensource projects

Example 31 with CerberusEventException

use of org.cerberus.exception.CerberusEventException in project cerberus-source by cerberustesting.

the class PropertyService method property_getFromDataLib.

private TestCaseExecutionData property_getFromDataLib(TestCaseExecutionData testCaseExecutionData, TestCaseExecution tCExecution, TestCaseStepActionExecution testCaseStepActionExecution, TestCaseCountryProperties testCaseCountryProperty, boolean forceRecalculation) {
    MessageEvent res = new MessageEvent(MessageEventEnum.PROPERTY_SUCCESS_GETFROMDATALIB);
    TestDataLib testDataLib;
    List<HashMap<String, String>> result = null;
    AnswerItem<String> answerDecode = new AnswerItem();
    // We get here the correct TestDataLib entry from the Value1 (name) that better match the context on system, environment and country.
    AnswerItem<TestDataLib> answer = testDataLibService.readByNameBySystemByEnvironmentByCountry(testCaseExecutionData.getValue1(), tCExecution.getApplicationObj().getSystem(), tCExecution.getEnvironmentData(), tCExecution.getCountry());
    if (answer.isCodeEquals(MessageEventEnum.DATA_OPERATION_OK.getCode()) && answer.getItem() != null) {
        testDataLib = (TestDataLib) answer.getItem();
        AnswerList serviceAnswer;
        // check if there are properties defined in the data specification
        try {
            if (testDataLib.getType().equals(TestDataLib.TYPE_SQL)) {
                // check if the script contains properties that neeed to be calculated
                answerDecode = variableService.decodeStringCompletly(testDataLib.getScript(), tCExecution, testCaseStepActionExecution, false);
                String decodedScript = (String) answerDecode.getItem();
                testDataLib.setScript(decodedScript);
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    testCaseExecutionData.setPropertyResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "SQL Script"));
                    testCaseExecutionData.setStopExecution(answerDecode.getResultMessage().isStopTest());
                    LOG.debug("Property interupted due to decode 'SQL Script'.");
                    return testCaseExecutionData;
                }
            }
        } catch (CerberusEventException cex) {
            LOG.error(cex.toString());
        }
        String decodedLength = null;
        // Here, we try to decode testCaseCountryProperty field `length` to get the value of property if needed
        try {
            answerDecode = variableService.decodeStringCompletly(testCaseCountryProperty.getLength(), tCExecution, testCaseStepActionExecution, false);
            decodedLength = (String) answerDecode.getItem();
            if (!(answerDecode.isCodeStringEquals("OK"))) {
                testCaseExecutionData.setPropertyResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "length"));
                testCaseExecutionData.setStopExecution(answerDecode.getResultMessage().isStopTest());
                LOG.debug("Property interupted due to decode 'Length field'.");
                return testCaseExecutionData;
            }
        } catch (CerberusEventException cex) {
            LOG.error(cex.toString());
        }
        // if we can, we set the value of testCaseExecutionData field `length` to the casted value
        if (decodedLength != null) {
            try {
                Integer.parseInt(decodedLength);
                testCaseExecutionData.setLength(decodedLength);
            } catch (NumberFormatException e) {
                LOG.error(e.toString());
                MessageEvent msg = new MessageEvent(MessageEventEnum.CASTING_OPERATION_FAILED);
                msg.setDescription(msg.getDescription().replace("%ERROR%", e.toString()));
                msg.setDescription(msg.getDescription().replace("%FIELD%", "field length"));
                testCaseExecutionData.setPropertyResultMessage(msg);
                testCaseExecutionData.setStopExecution(msg.isStopTest());
                return testCaseExecutionData;
            }
        }
        // we need to recalculate the result for the lib
        serviceAnswer = dataLibService.getFromDataLib(testDataLib, testCaseCountryProperty, tCExecution, testCaseExecutionData);
        testCaseExecutionData.setDataLib(testDataLib.getName());
        res = serviceAnswer.getResultMessage();
        // test data library returned by the service
        result = (List<HashMap<String, String>>) serviceAnswer.getDataList();
        if (result != null) {
            // Keeping raw data to testCaseExecutionData object.
            testCaseExecutionData.setDataLibRawData(result);
            // Value of testCaseExecutionData object takes the master subdata entry "".
            String value = (String) result.get(0).get("");
            if (value == null) {
                testCaseExecutionData.setValue(VALUE_NULL);
            } else {
                testCaseExecutionData.setValue(value);
                // Converting HashMap to json.
                String jsonText = "";
                JSONArray jsonResult = null;
                try {
                    jsonResult = dataLibService.convertToJSONObject(result);
                    jsonText = jsonResult.toString();
                } catch (JSONException ex) {
                    java.util.logging.Logger.getLogger(PropertyService.class.getName()).log(Level.SEVERE, null, ex);
                }
                testCaseExecutionData.setJsonResult(jsonText);
            }
            // Record result in filessytem.
            recorderService.recordTestDataLibProperty(tCExecution.getId(), testCaseCountryProperty.getProperty(), 1, result);
        }
        res.setDescription(res.getDescription().replace("%ENTRY%", testDataLib.getName()).replace("%ENTRYID%", String.valueOf(testDataLib.getTestDataLibID())));
    } else {
        // no TestDataLib found was returned
        // the library does not exist at all
        AnswerList nameExistsAnswer = testDataLibService.readNameListByName(testCaseExecutionData.getValue1(), 1, false);
        if (nameExistsAnswer.isCodeEquals(MessageEventEnum.DATA_OPERATION_OK.getCode()) && nameExistsAnswer.getTotalRows() > 0) {
            // if the library name exists but was not available or does not exist for the current specification but exists for other countries/environments/systems
            res = new MessageEvent(MessageEventEnum.PROPERTY_FAILED_GETFROMDATALIB_NOT_FOUND_ERROR);
            res.setDescription(res.getDescription().replace("%ITEM%", testCaseExecutionData.getValue1()).replace("%COUNTRY%", tCExecution.getCountryEnvironmentParameters().getCountry()).replace("%ENVIRONMENT%", tCExecution.getCountryEnvironmentParameters().getEnvironment()).replace("%SYSTEM%", tCExecution.getCountryEnvironmentParameters().getSystem()));
        } else {
            res = new MessageEvent(MessageEventEnum.PROPERTY_FAILED_GETFROMDATALIB_NOT_EXIST_ERROR);
            res.setDescription(res.getDescription().replace("%ITEM%", testCaseExecutionData.getValue1()));
        }
    }
    res.setDescription(res.getDescription().replace("%VALUE1%", testCaseExecutionData.getValue1()));
    testCaseExecutionData.setPropertyResultMessage(res);
    return testCaseExecutionData;
}

Example 32 with CerberusEventException

use of org.cerberus.exception.CerberusEventException in project cerberus-source by cerberustesting.

the class PropertyService method property_executeSoapFromLib.

private TestCaseExecutionData property_executeSoapFromLib(TestCaseExecutionData testCaseExecutionData, TestCaseExecution tCExecution, TestCaseStepActionExecution testCaseStepActionExecution, TestCaseCountryProperties testCaseCountryProperty, boolean forceCalculation) {
    String result = null;
    AnswerItem<String> answerDecode = new AnswerItem();
    try {
        AppService appService = this.appServiceService.findAppServiceByKey(testCaseExecutionData.getValue1());
        if (appService != null) {
            String decodedEnveloppe = appService.getServiceRequest();
            String decodedServicePath = appService.getServicePath();
            String decodedMethod = appService.getOperation();
            String decodedAttachement = appService.getAttachementURL();
            if (appService.getServiceRequest().contains("%")) {
                answerDecode = variableService.decodeStringCompletly(appService.getServiceRequest(), tCExecution, testCaseStepActionExecution, false);
                decodedEnveloppe = (String) answerDecode.getItem();
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    testCaseExecutionData.setPropertyResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "SOAP Service Request"));
                    testCaseExecutionData.setStopExecution(answerDecode.getResultMessage().isStopTest());
                    LOG.debug("Property interupted due to decode 'SOAP Service Request' Error.");
                    return testCaseExecutionData;
                }
            }
            if (appService.getServicePath().contains("%")) {
                answerDecode = variableService.decodeStringCompletly(appService.getServicePath(), tCExecution, testCaseStepActionExecution, false);
                decodedServicePath = (String) answerDecode.getItem();
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    testCaseExecutionData.setPropertyResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "SOAP Service Path"));
                    testCaseExecutionData.setStopExecution(answerDecode.getResultMessage().isStopTest());
                    LOG.debug("Property interupted due to decode 'SOAP Service Path.");
                    return testCaseExecutionData;
                }
            }
            if (appService.getOperation().contains("%")) {
                answerDecode = variableService.decodeStringCompletly(appService.getOperation(), tCExecution, testCaseStepActionExecution, false);
                decodedMethod = (String) answerDecode.getItem();
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    testCaseExecutionData.setPropertyResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "SOAP Operation"));
                    testCaseExecutionData.setStopExecution(answerDecode.getResultMessage().isStopTest());
                    LOG.debug("Property interupted due to decode 'SOAP Operation.");
                    return testCaseExecutionData;
                }
            }
            if (appService.getAttachementURL().contains("%")) {
                answerDecode = variableService.decodeStringCompletly(appService.getAttachementURL(), tCExecution, testCaseStepActionExecution, false);
                decodedAttachement = (String) answerDecode.getItem();
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    testCaseExecutionData.setPropertyResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "SOAP Attachement URL"));
                    testCaseExecutionData.setStopExecution(answerDecode.getResultMessage().isStopTest());
                    LOG.debug("Property interupted due to decode 'SOAP Attachement URL.");
                    return testCaseExecutionData;
                }
            }
            // Call Soap and set LastSoapCall of the testCaseExecution.
            AnswerItem soapCall = soapService.callSOAP(decodedEnveloppe, decodedServicePath, decodedMethod, decodedAttachement, null, null, 60000, tCExecution.getApplicationObj().getSystem());
            AppService se1 = (AppService) soapCall.getItem();
            if (soapCall.isCodeEquals(200)) {
                // SOAPExecution lastSoapCalled = (SOAPExecution) tCExecution.getLastSOAPCalled().getItem();
                String xmlResponse = se1.getResponseHTTPBody();
                result = xmlUnitService.getFromXml(xmlResponse, appService.getAttachementURL());
            }
            if (result != null) {
                testCaseExecutionData.setValue(result);
                MessageEvent res = new MessageEvent(MessageEventEnum.PROPERTY_SUCCESS_SOAP);
                testCaseExecutionData.setPropertyResultMessage(res);
            } else {
                MessageEvent res = new MessageEvent(MessageEventEnum.PROPERTY_FAILED_SOAPFROMLIB_NODATA);
                testCaseExecutionData.setPropertyResultMessage(res);
            }
        }
    } catch (CerberusException exception) {
        LOG.error(exception.toString());
        MessageEvent res = new MessageEvent(MessageEventEnum.PROPERTY_FAILED_TESTDATA_PROPERTYDONOTEXIST);
        res.setDescription(res.getDescription().replace("%PROPERTY%", testCaseExecutionData.getValue1()));
        testCaseExecutionData.setPropertyResultMessage(res);
    } catch (CerberusEventException ex) {
        LOG.error(ex.toString());
        MessageEvent message = new MessageEvent(MessageEventEnum.ACTION_FAILED_CALLSOAP);
        message.setDescription(message.getDescription().replace("%SOAPNAME%", testCaseExecutionData.getValue1()));
        message.setDescription(message.getDescription().replace("%DESCRIPTION%", ex.getMessageError().getDescription()));
        testCaseExecutionData.setPropertyResultMessage(message);
    }
    return testCaseExecutionData;
}

Example 33 with CerberusEventException

use of org.cerberus.exception.CerberusEventException in project cerberus-source by cerberustesting.

the class ExecutionRunService method executeTestCase.

@Override
public TestCaseExecution executeTestCase(TestCaseExecution tCExecution) throws CerberusException {
    long runID = tCExecution.getId();
    String logPrefix = runID + " - ";
    /**
     * Feeding Build Rev of main Application system to
     * testcaseexecutionsysver table. Only if execution is not manual.
     */
    try {
        if (!(tCExecution.isManualURL())) {
            /**
             * Insert SystemVersion in Database
             */
            TestCaseExecutionSysVer myExeSysVer = null;
            try {
                LOG.debug(logPrefix + "Registering Main System Version.");
                myExeSysVer = factoryTestCaseExecutionSysVer.create(runID, tCExecution.getApplicationObj().getSystem(), tCExecution.getBuild(), tCExecution.getRevision());
                testCaseExecutionSysVerService.insertTestCaseExecutionSysVer(myExeSysVer);
            } catch (CerberusException ex) {
                LOG.error(logPrefix + ex.getMessage());
            }
            LOG.debug(logPrefix + "Main System Version Registered.");
            /**
             * For all Linked environment, we also keep track on the
             * build/rev information inside testcaseexecutionsysver table.
             */
            LOG.debug(logPrefix + "Registering Linked System Version.");
            try {
                List<CountryEnvLink> ceLink = null;
                ceLink = countryEnvLinkService.convert(countryEnvLinkService.readByVarious(tCExecution.getApplicationObj().getSystem(), tCExecution.getCountry(), tCExecution.getEnvironment()));
                for (CountryEnvLink myCeLink : ceLink) {
                    LOG.debug(logPrefix + "Linked environment found : " + myCeLink.getSystemLink() + myCeLink.getCountryLink() + myCeLink.getEnvironmentLink());
                    CountryEnvParam mycountEnvParam;
                    try {
                        mycountEnvParam = this.countryEnvParamService.convert(this.countryEnvParamService.readByKey(myCeLink.getSystemLink(), myCeLink.getCountryLink(), myCeLink.getEnvironmentLink()));
                        myExeSysVer = factoryTestCaseExecutionSysVer.create(runID, myCeLink.getSystemLink(), mycountEnvParam.getBuild(), mycountEnvParam.getRevision());
                        testCaseExecutionSysVerService.insertTestCaseExecutionSysVer(myExeSysVer);
                    } catch (CerberusException ex) {
                        // Referencial Integrity link between countryEnvLink and CountryEnvParam table should secure that exception to never happen.
                        LOG.error(logPrefix + ex.getMessage());
                        throw new CerberusException(ex.getMessageError());
                    }
                }
            } catch (CerberusException ex) {
                LOG.debug(logPrefix + "No Linked environment found.");
            }
            LOG.debug(logPrefix + "Linked System Version Registered.");
        }
        /**
         * Get used SeleniumCapabilities (empty if application is not GUI)
         */
        LOG.debug(logPrefix + "Getting Selenium capabitities for GUI applications.");
        if (tCExecution.getApplicationObj().getType().equalsIgnoreCase(Application.TYPE_GUI)) {
            try {
                Capabilities caps = this.seleniumServerService.getUsedCapabilities(tCExecution.getSession());
                tCExecution.setBrowserFullVersion(caps.getBrowserName() + " " + caps.getVersion() + " " + caps.getPlatform().toString());
                tCExecution.setVersion(caps.getVersion());
                tCExecution.setPlatform(caps.getPlatform().toString());
            } catch (Exception ex) {
                LOG.error(logPrefix + "Exception on selenium getting Used Capabilities :" + ex.toString());
            }
            LOG.debug(logPrefix + "Selenium capabitities loaded.");
        } else {
            // If Selenium is not needed, the selenium and browser info is set to empty.
            tCExecution.setSeleniumIP("");
            tCExecution.setSeleniumPort("");
            tCExecution.setBrowser("");
            tCExecution.setVersion("");
            tCExecution.setPlatform("");
            tCExecution.setRobotDecli("");
            LOG.debug(logPrefix + "No Selenium capabitities loaded because application not GUI : " + tCExecution.getApplicationObj().getType());
        }
        tCExecution.setRobotDecli(tCExecution.getRobotDecli().replace("%BROWSER%", tCExecution.getBrowser()));
        tCExecution.setRobotDecli(tCExecution.getRobotDecli().replace("%BROWSERVERSION%", tCExecution.getVersion()));
        tCExecution.setRobotDecli(tCExecution.getRobotDecli().replace("%PLATFORM%", tCExecution.getPlatform()));
        /**
         * Load PreTestCase information and set PreTCase to the
         * TestCaseExecution object
         */
        tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_LOADINGDETAILEDDATA));
        LOG.debug(logPrefix + "Loading Pre-testcases.");
        List<TestCase> preTests = testCaseService.findTestCaseActiveByCriteria("Pre Testing", tCExecution.getTestCaseObj().getApplication(), tCExecution.getCountry());
        tCExecution.setPreTestCaseList(preTests);
        if (!(preTests == null)) {
            LOG.debug(logPrefix + "Loaded PreTest List. " + tCExecution.getPreTestCaseList().size() + " found.");
        }
        LOG.debug(logPrefix + "Pre-testcases Loaded.");
        /**
         * Load Main TestCase with Step dependencies (Actions/Control)
         */
        LOG.debug(logPrefix + "Loading all Steps information of Main testcase.");
        List<TestCaseStep> testCaseStepList;
        testCaseStepList = this.loadTestCaseService.loadTestCaseStep(tCExecution.getTestCaseObj());
        tCExecution.getTestCaseObj().setTestCaseStep(testCaseStepList);
        LOG.debug(logPrefix + "Steps information of Main testcase Loaded : " + tCExecution.getTestCaseObj().getTestCaseStep().size() + " Step(s) found.");
        /**
         * Load Pre TestCase with Step dependencies (Actions/Control)
         */
        LOG.debug(logPrefix + "Loading all Steps information (Actions & Controls) of all Pre-testcase.");
        List<TestCaseStep> preTestCaseStepList = new ArrayList<TestCaseStep>();
        List<TestCase> preTestCase = new ArrayList<TestCase>();
        for (TestCase myTCase : tCExecution.getPreTestCaseList()) {
            myTCase.setTestCaseStep(this.loadTestCaseService.loadTestCaseStep(myTCase));
            preTestCaseStepList.addAll(myTCase.getTestCaseStep());
            preTestCase.add(myTCase);
            LOG.debug(logPrefix + "Pre testcase : " + myTCase.getTest() + "-" + myTCase.getTestCase() + " Loaded With " + myTCase.getTestCaseStep().size() + " Step(s) found.");
        }
        tCExecution.setPreTestCaseList(preTestCase);
        LOG.debug(logPrefix + "All Steps information (Actions & Controls) of all Pre-testcase Loaded.");
        /**
         * Load All properties of the testcase
         */
        LOG.debug(logPrefix + "Loading all Properties.");
        List<TestCaseCountryProperties> tcProperties = new ArrayList();
        try {
            tcProperties = testCaseCountryPropertiesService.findAllWithDependencies(tCExecution.getTest(), tCExecution.getTestCase(), tCExecution.getCountry());
            tCExecution.setTestCaseCountryPropertyList(tcProperties);
        } catch (CerberusException ex) {
            LOG.warn("Exception getting all the properties : " + ex);
        }
        if (LOG.isDebugEnabled()) {
            LOG.debug(logPrefix + "All Properties Loaded. " + tcProperties.size() + " property(ies) found : " + tcProperties);
        }
        /**
         * Start Execution of the steps/Actions/controls Iterate Steps.
         * mainExecutionTestCaseStepList will contain the list of steps to
         * execute for both pretest and test. This is where we schedule the
         * execution of the steps using mainExecutionTestCaseStepList
         * object.
         */
        LOG.debug(logPrefix + "Starting the execution with step iteration.");
        List<TestCaseStep> mainExecutionTestCaseStepList;
        mainExecutionTestCaseStepList = new ArrayList<TestCaseStep>();
        mainExecutionTestCaseStepList.addAll(preTestCaseStepList);
        mainExecutionTestCaseStepList.addAll(testCaseStepList);
        /**
         * Initialize the global TestCaseExecution Data List.
         */
        // 
        tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTEXECUTING));
        try {
            testCaseExecutionService.updateTCExecution(tCExecution);
        } catch (CerberusException ex) {
            LOG.warn(ex);
        }
        // Websocket --> we refresh the corresponding Detail Execution pages attached to this execution.
        if (tCExecution.isCerberus_featureflipping_activatewebsocketpush()) {
            TestCaseExecutionEndPoint.getInstance().send(tCExecution, true);
        }
        // Evaluate the condition at the step level.
        AnswerItem<Boolean> conditionAnswerTc;
        AnswerItem<String> answerDecode = new AnswerItem();
        boolean conditionDecodeError = false;
        /**
         * If execution is not manual, evaluate the condition at the step
         * level
         */
        if (!tCExecution.getManualExecution().equals("Y")) {
            try {
                answerDecode = variableService.decodeStringCompletly(tCExecution.getConditionVal1(), tCExecution, null, false);
                tCExecution.setConditionVal1((String) answerDecode.getItem());
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITIONDECODE).resolveDescription("MES", answerDecode.getMessageDescription()).resolveDescription("FIELD", "TestCase Condition Value1"));
                    tCExecution.setEnd(new Date().getTime());
                    LOG.debug("TestCase interupted due to decode 'TestCase Condition Value1' Error.");
                    conditionDecodeError = true;
                }
            } catch (CerberusEventException cex) {
                LOG.warn(cex);
            }
            try {
                answerDecode = variableService.decodeStringCompletly(tCExecution.getConditionVal2(), tCExecution, null, false);
                tCExecution.setConditionVal2((String) answerDecode.getItem());
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITIONDECODE).resolveDescription("MES", answerDecode.getMessageDescription()).resolveDescription("FIELD", "TestCase Condition Value2"));
                    tCExecution.setEnd(new Date().getTime());
                    LOG.debug("TestCase interupted due to decode 'TestCase Condition Value2' Error.");
                    conditionDecodeError = true;
                }
            } catch (CerberusEventException cex) {
                LOG.warn(cex);
            }
        }
        if (!conditionDecodeError) {
            conditionAnswerTc = this.conditionService.evaluateCondition(tCExecution.getConditionOper(), tCExecution.getConditionVal1(), tCExecution.getConditionVal2(), tCExecution);
            boolean execute_TestCase = (boolean) conditionAnswerTc.getItem();
            if (execute_TestCase || tCExecution.getManualExecution().equals("Y")) {
                for (TestCaseStep testCaseStep : mainExecutionTestCaseStepList) {
                    // init the index of the step in case we loop.
                    int step_index = 1;
                    boolean execute_Next_Step = false;
                    TestCaseStepExecution testCaseStepExecution;
                    int maxloop = parameterService.getParameterIntegerByKey("cerberus_loopstep_max", tCExecution.getApplicationObj().getSystem(), 20);
                    do {
                        /**
                         * Start Execution of TestCaseStep
                         */
                        LOG.debug("Start execution of testcasestep");
                        long startStep = new Date().getTime();
                        /**
                         * Create and Register TestCaseStepExecution
                         */
                        MessageEvent stepMess = new MessageEvent(MessageEventEnum.STEP_PENDING).resolveDescription("STEP", String.valueOf(testCaseStep.getSort())).resolveDescription("STEPINDEX", String.valueOf(step_index));
                        testCaseStepExecution = factoryTestCaseStepExecution.create(runID, testCaseStep.getTest(), testCaseStep.getTestCase(), testCaseStep.getStep(), step_index, testCaseStep.getSort(), testCaseStep.getLoop(), testCaseStep.getConditionOper(), testCaseStep.getConditionVal1(), testCaseStep.getConditionVal2(), testCaseStep.getConditionVal1(), testCaseStep.getConditionVal2(), null, startStep, 0, startStep, 0, new BigDecimal("0"), null, stepMess, testCaseStep, tCExecution, testCaseStep.getUseStep(), testCaseStep.getUseStepTest(), testCaseStep.getUseStepTestCase(), testCaseStep.getUseStepStep(), testCaseStep.getDescription());
                        testCaseStepExecution.setLoop(testCaseStep.getLoop());
                        testCaseStepExecutionService.insertTestCaseStepExecution(testCaseStepExecution);
                        testCaseStepExecution.setExecutionResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTSTARTED));
                        /**
                         * We populate the TestCaseStep inside the execution
                         * List
                         */
                        tCExecution.addTestCaseStepExecutionList(testCaseStepExecution);
                        // determine if step is executed (execute_Step) and if we trigger a new step execution after (execute_Next_Step)
                        boolean execute_Step = true;
                        boolean conditionStepDecodeError = false;
                        boolean conditionStepError = false;
                        AnswerItem<Boolean> conditionAnswer = new AnswerItem<>(new MessageEvent(MessageEventEnum.CONDITIONEVAL_FAILED_UNKNOWNCONDITION));
                        if (testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_ONCEIFCONDITIONFALSE) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_ONCEIFCONDITIONTRUE) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_WHILECONDITIONFALSEDO) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_WHILECONDITIONTRUEDO) || testCaseStepExecution.getLoop().equals("") || step_index > 1) {
                            // Decode Conditionvalue1 and Conditionvalue2 and Evaluate the condition at the Step level.
                            try {
                                answerDecode = variableService.decodeStringCompletly(testCaseStepExecution.getConditionVal1(), tCExecution, null, false);
                                testCaseStepExecution.setConditionVal1((String) answerDecode.getItem());
                                if (!(answerDecode.isCodeStringEquals("OK"))) {
                                    testCaseStepExecution.setExecutionResultMessage(new MessageGeneral(answerDecode.getResultMessage().getMessage()));
                                    testCaseStepExecution.setStepResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value1"));
                                    testCaseStepExecution.setReturnMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value1").getDescription());
                                    testCaseStepExecution.setReturnCode(answerDecode.getResultMessage().getCodeString());
                                    testCaseStepExecution.setStopExecution(answerDecode.getResultMessage().isStopTest());
                                    testCaseStepExecution.setEnd(new Date().getTime());
                                    LOG.debug("Step interupted due to decode 'Step Condition Value1' Error.");
                                    conditionStepDecodeError = true;
                                }
                            } catch (CerberusEventException cex) {
                                LOG.warn(cex);
                            }
                            if (!conditionStepDecodeError) {
                                try {
                                    answerDecode = variableService.decodeStringCompletly(testCaseStepExecution.getConditionVal2(), tCExecution, null, false);
                                    testCaseStepExecution.setConditionVal2((String) answerDecode.getItem());
                                    if (!(answerDecode.isCodeStringEquals("OK"))) {
                                        testCaseStepExecution.setExecutionResultMessage(new MessageGeneral(answerDecode.getResultMessage().getMessage()));
                                        testCaseStepExecution.setStepResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value2"));
                                        testCaseStepExecution.setReturnMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value2").getDescription());
                                        testCaseStepExecution.setReturnCode(answerDecode.getResultMessage().getCodeString());
                                        testCaseStepExecution.setStopExecution(answerDecode.getResultMessage().isStopTest());
                                        testCaseStepExecution.setEnd(new Date().getTime());
                                        LOG.debug("Step interupted due to decode 'Step Condition Value2' Error.");
                                        conditionStepDecodeError = true;
                                    }
                                } catch (CerberusEventException cex) {
                                    LOG.warn(cex);
                                }
                            }
                            if (!(conditionStepDecodeError)) {
                                conditionAnswer = this.conditionService.evaluateCondition(testCaseStepExecution.getConditionOper(), testCaseStepExecution.getConditionVal1(), testCaseStepExecution.getConditionVal2(), tCExecution);
                                execute_Step = (boolean) conditionAnswer.getItem();
                                if (conditionAnswer.getResultMessage().getMessage().getCodeString().equals("PE")) {
                                    // There were no error when performing the condition evaluation.
                                    switch(testCaseStepExecution.getLoop()) {
                                        case TestCaseStep.LOOP_ONCEIFCONDITIONFALSE:
                                            execute_Step = !execute_Step;
                                            execute_Next_Step = false;
                                            break;
                                        case TestCaseStep.LOOP_ONCEIFCONDITIONTRUE:
                                        case "":
                                            execute_Next_Step = false;
                                            break;
                                        case TestCaseStep.LOOP_WHILECONDITIONFALSEDO:
                                        case TestCaseStep.LOOP_DOWHILECONDITIONFALSE:
                                            execute_Step = !execute_Step;
                                            execute_Next_Step = execute_Step;
                                            break;
                                        case TestCaseStep.LOOP_WHILECONDITIONTRUEDO:
                                        case TestCaseStep.LOOP_DOWHILECONDITIONTRUE:
                                            execute_Next_Step = execute_Step;
                                            break;
                                        default:
                                            execute_Next_Step = false;
                                    }
                                } else {
                                    // Error when performing the condition evaluation. We force no execution (false)
                                    MessageGeneral mes = new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITION);
                                    mes.setDescription(mes.getDescription().replace("%AREA%", "step ").replace("%COND%", testCaseStepExecution.getConditionOper()).replace("%MES%", conditionAnswer.getResultMessage().getDescription()));
                                    tCExecution.setResultMessage(mes);
                                    testCaseStepExecution.setExecutionResultMessage(mes);
                                    testCaseStepExecution.setStepResultMessage(new MessageEvent(MessageEventEnum.CONDITION_TESTCASESTEP_FAILED).resolveDescription("AREA", "").resolveDescription("COND", testCaseStepExecution.getConditionOper()).resolveDescription("MESSAGE", conditionAnswer.getResultMessage().getDescription()));
                                    testCaseStepExecution.setEnd(new Date().getTime());
                                    LOG.debug("Step interupted due to condition error.");
                                    conditionStepError = true;
                                    execute_Next_Step = false;
                                    execute_Step = false;
                                }
                            } else {
                                // If anything wrong with the decode --> we stop here with decode message in the action result.
                                tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITIONDECODE).resolveDescription("AREA", "Step ").resolveDescription("MES", answerDecode.getMessageDescription()));
                                tCExecution.setEnd(new Date().getTime());
                                LOG.debug("TestCase interupted due to decode Condition Error.");
                                // There was an error on decode so we stop everything.
                                execute_Next_Step = false;
                                execute_Step = false;
                            }
                        } else if (testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_DOWHILECONDITIONFALSE) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_DOWHILECONDITIONTRUE)) {
                            // First Step execution for LOOP_DOWHILECONDITIONTRUE and LOOP_DOWHILECONDITIONFALSE --> We force the step execution and activate the next step execution.
                            execute_Step = true;
                            execute_Next_Step = true;
                        } else {
                            // First Step execution for Unknown Loop --> We force the step execution only once (default behaviour).
                            execute_Step = true;
                            execute_Next_Step = false;
                            conditionAnswer.setResultMessage(new MessageEvent(MessageEventEnum.CONDITIONEVAL_FAILED_UNKNOWNCONDITION));
                        }
                        /**
                         * Execute Step
                         */
                        LOG.debug(logPrefix + "Executing step : " + testCaseStepExecution.getTest() + " - " + testCaseStepExecution.getTestCase() + " - Step " + testCaseStepExecution.getStep() + " - Index " + testCaseStepExecution.getStep());
                        if (execute_Step) {
                            /**
                             * We execute the step
                             */
                            testCaseStepExecution = this.executeStep(testCaseStepExecution, tCExecution);
                            /**
                             * Updating Execution Result Message only if
                             * execution result message of the step is not
                             * PE or OK.
                             */
                            if ((!(testCaseStepExecution.getExecutionResultMessage().equals(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTSTARTED)))) && (!(testCaseStepExecution.getExecutionResultMessage().equals(new MessageGeneral(MessageGeneralEnum.EXECUTION_OK))))) {
                                tCExecution.setResultMessage(testCaseStepExecution.getExecutionResultMessage());
                            }
                            if (testCaseStepExecution.getStepResultMessage().equals(new MessageEvent(MessageEventEnum.STEP_PENDING))) {
                                testCaseStepExecution.setStepResultMessage(new MessageEvent(MessageEventEnum.STEP_SUCCESS));
                            }
                            testCaseStepExecutionService.updateTestCaseStepExecution(testCaseStepExecution);
                            if (testCaseStepExecution.isStopExecution()) {
                                break;
                            }
                        } else // We don't execute the step and record a generic execution.
                        if ((!conditionStepDecodeError) && (!conditionStepError)) {
                            /**
                             * Register Step in database
                             */
                            LOG.debug("Registering Step : " + testCaseStepExecution.getStep());
                            // We change the Step message only if the Step is not executed due to condition.
                            MessageEvent stepMes = new MessageEvent(MessageEventEnum.CONDITION_TESTCASESTEP_NOTEXECUTED);
                            testCaseStepExecution.setStepResultMessage(stepMes);
                            testCaseStepExecution.setReturnMessage(testCaseStepExecution.getReturnMessage().replace("%COND%", testCaseStepExecution.getConditionOper()).replace("%LOOP%", testCaseStepExecution.getLoop()).replace("%MESSAGE%", conditionAnswer.getResultMessage().getDescription()));
                            testCaseStepExecution.setEnd(new Date().getTime());
                            this.testCaseStepExecutionService.updateTestCaseStepExecution(testCaseStepExecution);
                            LOG.debug("Registered Step");
                        } else {
                            // Not executed because decode error or failed condition.
                            testCaseStepExecution.setEnd(new Date().getTime());
                            testCaseStepExecution.setStopExecution(true);
                            this.testCaseStepExecutionService.updateTestCaseStepExecution(testCaseStepExecution);
                            LOG.debug("Registered Step");
                        }
                        /**
                         * Log TestCaseStepExecution
                         */
                        if (tCExecution.getVerbose() > 0) {
                            LOG.info(testCaseStepExecution.toJson(false, true));
                        }
                        // Websocket --> we refresh the corresponding Detail Execution pages attached to this execution.
                        if (tCExecution.isCerberus_featureflipping_activatewebsocketpush()) {
                            TestCaseExecutionEndPoint.getInstance().send(tCExecution, false);
                        }
                        step_index++;
                    } while (execute_Next_Step && step_index <= maxloop);
                    if (testCaseStepExecution.isStopExecution()) {
                        break;
                    }
                }
                /**
                 * If at that time the execution is still PE, we move it to
                 * OK. It means that no issue were met.
                 */
                if ((tCExecution.getResultMessage() == null) || (tCExecution.getResultMessage().equals(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTSTARTED)))) {
                    tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_OK));
                }
                /**
                 * We record Selenium log at the end of the execution.
                 */
                try {
                    tCExecution.addFileList(recorderService.recordSeleniumLog(tCExecution));
                } catch (Exception ex) {
                    LOG.error(logPrefix + "Exception Getting Selenium Logs " + tCExecution.getId() + " Exception :" + ex.toString());
                }
            } else {
                // We don't execute the testcase linked with condition.
                MessageGeneral mes;
                /**
                 * Update Execution status from condition
                 */
                if (conditionAnswerTc.getResultMessage().getMessage().getCodeString().equals("PE")) {
                    mes = new MessageGeneral(MessageGeneralEnum.EXECUTION_NA_CONDITION);
                } else {
                    mes = new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITION);
                }
                mes.setDescription(mes.getDescription().replace("%COND%", tCExecution.getConditionOper()).replace("%MES%", conditionAnswerTc.getResultMessage().getDescription()));
                tCExecution.setResultMessage(mes);
            }
        }
    } catch (Exception ex) {
        /**
         * If an exception is found, set the execution to FA and print the
         * exception
         */
        tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA));
        tCExecution.setControlMessage(tCExecution.getControlMessage() + " Exception: " + ex);
        LOG.error(logPrefix + "Exception found Executing Test " + tCExecution.getId() + " Exception :" + ex.toString());
    } finally {
        /**
         * We stop the server session here (selenium for ex.).
         */
        try {
            tCExecution = this.stopTestCase(tCExecution);
        } catch (Exception ex) {
            LOG.error(logPrefix + "Exception Stopping Test " + tCExecution.getId() + " Exception :" + ex.toString());
        }
        /**
         * Log Execution
         */
        LOG.info(tCExecution.toJson(false));
        /**
         * Clean memory
         */
        try {
            executionUUID.removeExecutionUUID(tCExecution.getExecutionUUID());
            LOG.debug("Clean ExecutionUUID");
        } catch (Exception ex) {
            LOG.error("Exception cleaning Memory: " + ex.toString());
        }
        /**
         * Log execution is finished
         */
        LOG.info("Execution Finished : UUID=" + tCExecution.getExecutionUUID() + "__ID=" + tCExecution.getId() + "__RC=" + tCExecution.getControlStatus() + "__" + "TestName=" + tCExecution.getEnvironment() + "." + tCExecution.getCountry() + "." + tCExecution.getBuild() + "." + tCExecution.getRevision() + "." + tCExecution.getTest() + "_" + tCExecution.getTestCase() + "_" + tCExecution.getTestCaseObj().getDescription().replace(".", ""));
        /**
         * Updating queue to done status only for execution from queue
         */
        if (tCExecution.getQueueID() != 0) {
            executionQueueService.updateToDone(tCExecution.getQueueID(), "", runID);
        }
        /**
         * Retry management, in case the result is not (OK or NE), we
         * execute the job again reducing the retry to 1.
         */
        if (tCExecution.getNumberOfRetries() > 0 && !tCExecution.getResultMessage().getCodeString().equals("OK") && !tCExecution.getResultMessage().getCodeString().equals("NE")) {
            TestCaseExecutionQueue newExeQueue = new TestCaseExecutionQueue();
            if (tCExecution.getQueueID() > 0) {
                // If QueueId exist, we try to get the original execution queue.
                try {
                    newExeQueue = executionQueueService.convert(executionQueueService.readByKey(tCExecution.getQueueID()));
                } catch (Exception e) {
                    // Unfortunatly the execution no longuer exist so we pick initial value.
                    newExeQueue = tCExecution.getTestCaseExecutionQueue();
                }
            } else {
                // Initial Execution does not come from the queue so we pick the value created at the beginning of the execution.
                newExeQueue = tCExecution.getTestCaseExecutionQueue();
            }
            // Forcing init value for that new queue execution : exeid=0, no debugflag and State = QUEUED
            int newRetry = tCExecution.getNumberOfRetries() - 1;
            newExeQueue.setId(0);
            newExeQueue.setDebugFlag("N");
            if (newRetry <= 0) {
                newExeQueue.setComment("Added from Retry. Last attempt to go.");
            } else {
                newExeQueue.setComment("Added from Retry. Still " + newRetry + " attempt(s) to go.");
            }
            newExeQueue.setState(TestCaseExecutionQueue.State.QUEUED);
            newExeQueue.setRetries(newRetry);
            // Insert execution to the Queue.
            executionQueueService.create(newExeQueue);
        }
        /**
         * After every execution finished, <br>
         * if the execution has a tag that has a campaign associated  <br>
         * and no more executions are in the queue, <br>
         * we trigger : <br>
         * 1/ The update of the EndExeQueue of the tag <br>
         * 2/ We notify the Distribution List with execution report status
         */
        try {
            if (!StringUtil.isNullOrEmpty(tCExecution.getTag())) {
                Tag currentTag = tagService.convert(tagService.readByKey(tCExecution.getTag()));
                if ((currentTag != null)) {
                    if (currentTag.getDateEndQueue().before(Timestamp.valueOf("1980-01-01 01:01:01.000000001"))) {
                        AnswerList answerListQueue = new AnswerList();
                        answerListQueue = executionQueueService.readQueueOpen(tCExecution.getTag());
                        if (answerListQueue.isCodeEquals(MessageEventEnum.DATA_OPERATION_OK.getCode()) && (answerListQueue.getDataList().isEmpty())) {
                            LOG.debug("No More executions in (queue) on tag : " + tCExecution.getTag() + " - " + answerListQueue.getDataList().size() + " " + answerListQueue.getMessageCodeString() + " - ");
                            tagService.updateDateEndQueue(tCExecution.getTag(), new Timestamp(new Date().getTime()));
                            if (!StringUtil.isNullOrEmpty(currentTag.getCampaign())) {
                                // We get the campaig here and potencially send the notification.
                                emailService.generateAndSendNotifyEndTagExecution(tCExecution.getTag(), currentTag.getCampaign());
                            }
                        } else {
                            LOG.debug("Still executions in queue on tag : " + tCExecution.getTag() + " - " + answerListQueue.getDataList().size() + " " + answerListQueue.getMessageCodeString());
                        }
                    } else {
                        LOG.debug("Tag is already flaged with recent timstamp. " + currentTag.getDateEndQueue());
                    }
                }
            }
        } catch (Exception e) {
            LOG.error(e);
        }
        // 
        // After every execution finished we try to trigger more from the queue;-).
        executionThreadPoolService.executeNextInQueueAsynchroneously(false);
    }
    return tCExecution;
}

Example 34 with CerberusEventException

use of org.cerberus.exception.CerberusEventException in project cerberus-source by cerberustesting.

the class IdentifierService method checkSelectOptionsIdentifier.

@Override
public void checkSelectOptionsIdentifier(String identifier) throws CerberusEventException {
    String[] selectOptionAttributes = { "label", "value", "index", "regexLabel", "regexValue", "regexIndex" };
    if (!Arrays.asList(selectOptionAttributes).contains(identifier)) {
        MessageEvent message = new MessageEvent(MessageEventEnum.ACTION_FAILED_UNKOWN_IDENTIFIER_SELENIUM_SELECT);
        message.setDescription(message.getDescription().replace("%IDENTIFIER%", identifier));
        throw new CerberusEventException(message);
    }
}

Example 35 with CerberusEventException

use of org.cerberus.exception.CerberusEventException in project cerberus-source by cerberustesting.

the class IdentifierService method checkWebElementIdentifier.

@Override
public void checkWebElementIdentifier(String identifier) throws CerberusEventException {
    String[] selectOptionAttributes = { "id", "name", "class", "css", "xpath", "link", "data-cerberus", "coord", "picture" };
    if (!Arrays.asList(selectOptionAttributes).contains(identifier)) {
        MessageEvent message = new MessageEvent(MessageEventEnum.ACTION_FAILED_UNKOWN_IDENTIFIER_SELENIUM);
        message.setDescription(message.getDescription().replace("%IDENTIFIER%", identifier));
        throw new CerberusEventException(message);
    }
}