Examples with MessageGeneral org.cerberus.engine.entity.MessageGeneral used on opensource projects

Example 36 with MessageGeneral

use of org.cerberus.engine.entity.MessageGeneral in project cerberus-source by cerberustesting.

the class ExecutionCheckService method checkRunUAT.

private boolean checkRunUAT(TestCase tc, String env) {
    if (tc.getActiveUAT().equals("Y")) {
        return true;
    }
    message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RUNUAT_NOTDEFINED);
    message.setDescription(message.getDescription().replace("%ENV%", env));
    return false;
}

Example 37 with MessageGeneral

use of org.cerberus.engine.entity.MessageGeneral in project cerberus-source by cerberustesting.

the class ExecutionCheckService method checkMaintenanceTime.

private boolean checkMaintenanceTime(TestCaseExecution tCExecution) {
    if (tCExecution.getCountryEnvParam().isMaintenanceAct()) {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        String nowDate = sdf.format(new Date());
        try {
            long now = sdf.parse(nowDate).getTime();
            long startMaintenance = sdf.parse(nowDate).getTime();
            long endMaintenance = sdf.parse(nowDate).getTime();
            if (tCExecution.getCountryEnvParam() != null) {
                if (tCExecution.getCountryEnvParam().getMaintenanceStr() != null) {
                    startMaintenance = sdf.parse(tCExecution.getCountryEnvParam().getMaintenanceStr()).getTime();
                }
                if (tCExecution.getCountryEnvParam().getMaintenanceStr() != null) {
                    endMaintenance = sdf.parse(tCExecution.getCountryEnvParam().getMaintenanceEnd()).getTime();
                }
            }
            if (!(now >= startMaintenance && now <= endMaintenance)) {
                return true;
            }
        } catch (ParseException exception) {
            LOG.error("Error when parsing maintenance start and/or end." + tCExecution.getCountryEnvParam().getSystem() + tCExecution.getCountryEnvParam().getCountry() + tCExecution.getCountryEnvParam().getEnvironment() + " " + tCExecution.getCountryEnvParam().getMaintenanceStr() + tCExecution.getCountryEnvParam().getMaintenanceEnd() + exception.toString());
        } catch (Exception exception) {
            LOG.error("Error when parsing maintenance start and/or end." + tCExecution.getCountryEnvParam().getSystem() + tCExecution.getCountryEnvParam().getCountry() + tCExecution.getCountryEnvParam().getEnvironment() + " " + tCExecution.getCountryEnvParam().getMaintenanceStr() + tCExecution.getCountryEnvParam().getMaintenanceEnd() + exception.toString());
        }
        message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_ENVIRONMENT_UNDER_MAINTENANCE);
        message.resolveDescription("START", tCExecution.getCountryEnvParam().getMaintenanceStr()).resolveDescription("END", tCExecution.getCountryEnvParam().getMaintenanceEnd()).resolveDescription("SYSTEM", tCExecution.getCountryEnvParam().getSystem()).resolveDescription("COUNTRY", tCExecution.getCountryEnvParam().getCountry()).resolveDescription("ENV", tCExecution.getCountryEnvParam().getEnvironment());
        return false;
    }
    return true;
}

Example 38 with MessageGeneral

use of org.cerberus.engine.entity.MessageGeneral in project cerberus-source by cerberustesting.

the class ExecutionCheckService method checkTargetBuildRevision.

private boolean checkTargetBuildRevision(TestCaseExecution tCExecution) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Checking target build");
    }
    TestCase tc = tCExecution.getTestCaseObj();
    CountryEnvParam env = tCExecution.getCountryEnvParam();
    String tcSprint = ParameterParserUtil.parseStringParam(tc.getTargetBuild(), "");
    String tcRevision = ParameterParserUtil.parseStringParam(tc.getTargetRev(), "");
    String sprint = ParameterParserUtil.parseStringParam(env.getBuild(), "");
    String revision = ParameterParserUtil.parseStringParam(env.getRevision(), "");
    int dif = -1;
    if (!tcSprint.isEmpty() && sprint != null) {
        try {
            if (sprint.isEmpty()) {
                message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RANGE_ENVIRONMENT_BUILDREVISION_NOTDEFINED);
                return false;
            } else {
                dif = this.compareBuild(sprint, tcSprint, env.getSystem());
            }
            if (dif == 0) {
                if (!tcRevision.isEmpty() && revision != null) {
                    if (revision.isEmpty()) {
                        message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RANGE_ENVIRONMENT_BUILDREVISION_NOTDEFINED);
                        return false;
                    } else if (this.compareRevision(revision, tcRevision, env.getSystem()) < 0) {
                        message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TARGET_DIFFERENT);
                        return false;
                    }
                }
            } else if (dif < 0) {
                message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TARGET_DIFFERENT);
                return false;
            }
        } catch (NumberFormatException exception) {
            message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TARGET_WRONGFORMAT);
            return false;
        } catch (CerberusException ex) {
            message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RANGE_ENVIRONMENT_BUILDREVISION_BADLYDEFINED);
            return false;
        }
    }
    return true;
}

Example 39 with MessageGeneral

use of org.cerberus.engine.entity.MessageGeneral in project cerberus-source by cerberustesting.

the class ExecutionCheckService method checkTestActive.

private boolean checkTestActive(Test test) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Checking if test is active");
    }
    if (test.getActive().equals("Y")) {
        return true;
    }
    message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TEST_NOTACTIVE);
    message.setDescription(message.getDescription().replace("%TEST%", test.getTest()));
    return false;
}

Example 40 with MessageGeneral

use of org.cerberus.engine.entity.MessageGeneral 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;
}