def set_up(self):
UseCaseBase.set_up(self)
if self.__setup_script is not None:
result, full_path = self.__get_script_path(self.__setup_script)
if result == Global.FAILURE:
return Global.FAILURE, "Cannot find %s" % self.__setup_script
self.__setup_script = full_path
result, full_path = self.__get_script_path(self.__run_script)
if result == Global.FAILURE:
return Global.FAILURE, "Cannot find %s" % self.__run_script
self.__run_script = full_path
if self.__teardown_script is not None:
result, full_path = self.__get_script_path(self.__teardown_script)
if result == Global.FAILURE:
return Global.FAILURE, "Cannot find %s" % self.__teardown_script
self.__teardown_script = full_path
if self.__finalize_script is not None:
result, full_path = self.__get_script_path(self.__finalize_script)
if result == Global.FAILURE:
return Global.FAILURE, "Cannot find %s" % self.__finalize_script
self.__finalize_script = full_path
verdict = Global.SUCCESS
message = "Success"
if self.__setup_script is not None:
verdict, message = self.__exec_script(self.__setup_script)
return verdict, message
def __init__(self, tc_conf, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_conf, global_config)
# Get TC Parameters
self._step = self._tc_parameters.get_param_value("STEP", "RUNTEST")
self._return_code = self._tc_parameters.get_param_value(
"RETURN_CODE", Verdict.PASS)
# Update return code for retro-compatibility
self._return_code = self._return_code.replace("SUCCESS", Verdict.PASS)
self._return_code = self._return_code.replace("FAILURE", Verdict.FAIL)
self._comment = self._tc_parameters.get_param_value(
"COMMENT", "No Comment")
self._duration = int(self._tc_parameters.get_param_value(
"DURATION", 0))
self._init_exception = self._tc_parameters.get_param_value(
"INIT_EXCEPTION", False, "str_to_bool")
if self._init_exception is True:
raise AcsConfigException(
AcsConfigException.PROHIBITIVE_BEHAVIOR,
"Exception raised according to TC param 'INIT_EXCEPTION'")
# Clear existing queue to avoid unexpected behavior
if not Dummy.returns_code.empty():
with Dummy.returns_code.mutex:
Dummy.returns_code.queue.clear()
if not Dummy.steps.empty():
with Dummy.steps.mutex:
Dummy.steps.queue.clear()
# Fill the FIFO queue taking into account the b2b iteration number
for _i in range(self.get_b2b_iteration()):
for code in self._return_code.split(";"):
if code.strip() == "RANDOM":
code = random.choice(Verdict2Global.map.keys())
Dummy.returns_code.put(code.strip())
for step in self._step.split(";"):
if step.strip() == "RANDOM":
step = random.choice(["SETUP", "RUNTEST", "TEARDOWN"])
Dummy.steps.put(step.strip())
# Get return code and step only if queue is not empty.
# By default verdict = PASS, step = RUNTEST
self._current_verdict = Verdict.PASS
self._current_step = "RUNTEST"
if not Dummy.returns_code.empty():
self._current_verdict = Dummy.returns_code.get()
if not Dummy.steps.empty():
self._current_step = Dummy.steps.get()
def finalize(self):
UseCaseBase.finalize(self)
verdict = Global.SUCCESS
message = "Success"
if self.__finalize_script is not None:
verdict, message = self.__exec_script(self.__finalize_script)
return verdict, message
def tear_down(self):
UseCaseBase.tear_down(self)
verdict = Global.SUCCESS
message = "Success"
if self.__teardown_script is not None:
verdict, message = self.__exec_script(self.__teardown_script)
return verdict, message
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._global_config = global_config
self._run_from_tc_directory = self._tc_parameters.get_param_value("RUN_FROM_TCDIRECTORY", default_value="False",
default_cast_type="str_to_bool")
def run_test(self):
UseCaseBase.run_test(self)
if self.__run_script is not None:
verdict, message = self.__exec_script(self.__run_script)
else:
verdict = Global.FAILURE
message = "No script to run !"
return verdict, message
def tear_down(self):
"""
Execute the test
"""
UseCaseBase.tear_down(self)
time.sleep(self._duration)
verdict = self.__get_step_verdict("TEARDOWN")
return_code = Verdict2Global.map[verdict]
comment = "(TEARDOWN) " + self._comment
return return_code, comment
def run_test(self):
"""
Execute the test
"""
UseCaseBase.run_test(self)
time.sleep(self._duration)
verdict = self.__get_step_verdict("RUNTEST")
return_code = Verdict2Global.map[verdict]
comment = "(RUNTEST) " + self._comment
return return_code, comment
def set_up(self):
"""
Execute the test
"""
UseCaseBase.set_up(self)
time.sleep(self._duration)
verdict = self.__get_step_verdict("SETUP")
return_code = Verdict2Global.map[verdict]
comment = "(SETUP) " + self._comment
return return_code, comment
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self.__setup_script = self._tc_parameters.get_param_value("SETUP_SCRIPT_PATH")
self.__run_script = self._tc_parameters.get_param_value("SCRIPT_PATH")
self.__teardown_script = self._tc_parameters.get_param_value("TEAR_DOWN_SCRIPT_PATH")
self.__finalize_script = self._tc_parameters.get_param_value("FINALIZE_SCRIPT_PATH")
self.__verdict = None
self.__message = None
self.__tc_report = SecondaryTestReport(self._device.get_report_tree().get_report_path())
def initialize(self):
"""
Process the **<Initialize>** section of the XML file and execute defined test steps.
"""
UseCaseBase.initialize(self)
verdict, msg = Global.SUCCESS, ""
# Export all ACS Global parameters as an JSON object into ACS_GLOBAL_PARAMETERS
# environment variable so that user can access them from inside the
# script that is being executed
device_cfg_dict = self._global_conf.benchConfig.get_dict()
dc_l = len(self._global_conf.deviceConfig)
for x in range(1, dc_l + 1):
device_cfg_dict['PHONE%s' % x] = self._global_conf.deviceConfig['PHONE%s' % x]
device_cfg_dict['PHONE1']['serialNumber'] = self._device.retrieve_serial_number()
os.environ['ACS_GLOBAL_PARAMETERS'] = json.dumps(device_cfg_dict)
return verdict, msg
def __init__(self, tc_conf, global_config):
"""
Constructor
"""
UCBase.__init__(self, tc_conf, global_config)
def tear_down(self):
UseCaseBase.tear_down(self)
return self.__run_cmds("TEAR_DOWN_CMD", "TEAR_DOWN_TIMEOUT",
"TEAR_DOWN_EXPECT_RESULT")
def run_test(self):
UseCaseBase.run_test(self)
return self.__run_cmds("RUN_CMD", "RUN_TIMEOUT", "RUN_EXPECT_RESULT")
def set_up(self):
UseCaseBase.set_up(self)
return self.__run_cmds("SETUP_CMD", "SETUP_TIMEOUT",
"SETUP_EXPECT_RESULT")