def signal_test_case(self, params):
try:
data = handle_testcase(params)
if "test_case_id" in data:
# Replace invalid characters in test_case_id with '_'.
data["test_case_id"] = self._replace_invalid_url_characters(
data["test_case_id"])
# get the fixup from the pattern_dict
res = self.signal_match.match(data,
fixupdict=self.pattern.fixupdict())
except (JobError, TestError) as exc:
self.logger.error(str(exc))
return True
p_res = self.get_namespace_data(action='test',
label=self.signal_director.test_uuid,
key='results')
if not p_res:
p_res = OrderedDict()
self.set_namespace_data(action='test',
label=self.signal_director.test_uuid,
key='results',
value=p_res)
# prevent losing data in the update
# FIXME: support parameters and retries
if res["test_case_id"] in p_res:
raise JobError("Duplicate test_case_id in results: %s",
res["test_case_id"])
# turn the result dict inside out to get the unique
# test_case_id/testset_name as key and result as value
res_data = {
'definition': self.definition,
'case': res["test_case_id"],
'result': res["result"]
}
# check for measurements
if 'measurement' in res:
try:
measurement = decimal.Decimal(res['measurement'])
except decimal.InvalidOperation:
raise TestError("Invalid measurement %s", res['measurement'])
res_data['measurement'] = measurement
if 'units' in res:
res_data['units'] = res['units']
if self.testset_name:
res_data['set'] = self.testset_name
self.report[res['test_case_id']] = {
'set': self.testset_name,
'result': res['result']
}
else:
self.report[res['test_case_id']] = res['result']
# Send the results back
self.logger.results(res_data) # pylint: disable=no-member
def check_patterns(self, event, test_connection):
"""
Defines the base set of pattern responses.
Stores the results of testcases inside the TestAction
Call from subclasses before checking subclass-specific events.
"""
ret_val = False
if event == "exit":
self.logger.info("ok: lava_test_shell seems to have completed")
elif event == "eof":
self.logger.warning("err: lava_test_shell connection dropped")
self.errors = "lava_test_shell connection dropped"
elif event == "timeout":
# if target.is_booted():
# target.reset_boot()
self.logger.warning("err: lava_test_shell has timed out")
self.errors = "lava_test_shell has timed out"
elif event == "signal":
name, params = test_connection.match.groups()
self.logger.debug("Received signal: <%s> %s" % (name, params))
params = params.split()
if name == "STARTRUN":
self.signal_director.test_uuid = params[1]
self.suite = params[0]
self.logger.debug("Starting test suite: %s" % self.suite)
# self._handle_testrun(params)
elif name == "TESTCASE":
data = handle_testcase(params)
res = self.match.match(data) # FIXME: rename!
self.logger.debug("res: %s data: %s" % (res, data))
p_res = self.data["test"][self.signal_director.test_uuid].setdefault("results", OrderedDict())
# prevent losing data in the update
# FIXME: support parameters and retries
if res["test_case_id"] in p_res:
raise JobError("Duplicate test_case_id in results: %s", res["test_case_id"])
# turn the result dict inside out to get the unique test_case_id as key and result as value
self.logger.results({"testsuite": self.suite, res["test_case_id"]: res["result"]})
self.report.update({res["test_case_id"]: res["result"]})
try:
self.signal_director.signal(name, params)
except KeyboardInterrupt:
raise KeyboardInterrupt
# force output in case there was none but minimal content to increase speed.
test_connection.sendline("#")
ret_val = True
elif event == "test_case":
match = test_connection.match
if match is pexpect.TIMEOUT:
# if target.is_booted():
# target.reset_boot()
self.logger.warning("err: lava_test_shell has timed out (test_case)")
else:
res = self.match.match(match.groupdict()) # FIXME: rename!
self.logger.debug("outer_loop_result: %s" % res)
# self.data["test"][self.signal_director.test_uuid].setdefault("results", {})
# self.data["test"][self.signal_director.test_uuid]["results"].update({
# {res["test_case_id"]: res}
# })
ret_val = True
return ret_val
def check_patterns(self, event, test_connection, check_char): # pylint: disable=too-many-locals
"""
Defines the base set of pattern responses.
Stores the results of testcases inside the TestAction
Call from subclasses before checking subclass-specific events.
"""
ret_val = False
if event == "exit":
self.logger.info("ok: lava_test_shell seems to have completed")
self.testset_name = None
elif event == "eof":
self.logger.warning("err: lava_test_shell connection dropped")
self.errors = "lava_test_shell connection dropped"
self.testset_name = None
elif event == "timeout":
self.logger.warning("err: lava_test_shell has timed out")
self.errors = "lava_test_shell has timed out"
self.testset_name = None
elif event == "signal":
name, params = test_connection.match.groups()
self.logger.debug("Received signal: <%s> %s" % (name, params))
params = params.split()
if name == "STARTRUN":
self.signal_director.test_uuid = params[1]
self.definition = params[0]
uuid = params[1]
self.start = time.time()
self.logger.debug("Starting test definition: %s" % self.definition)
self.logger.info("Starting test lava.%s (%s)", self.definition, uuid)
self.start = time.time()
# set the pattern for this run from pattern_dict
testdef_index = self.get_common_data('test-definition', 'testdef_index')
uuid_list = self.get_common_data('repo-action', 'uuid-list')
for key, value in testdef_index.items():
if self.definition == "%s_%s" % (key, value):
pattern = self.job.context['test'][uuid_list[key]]['testdef_pattern']['pattern']
fixup = self.job.context['test'][uuid_list[key]]['testdef_pattern']['fixupdict']
self.patterns.update({'test_case_result': re.compile(pattern, re.M)})
self.pattern.update(pattern, fixup)
self.logger.info("Enabling test definition pattern %r" % pattern)
self.logger.results({
"definition": "lava",
"case": self.definition,
"uuid": uuid,
# The test is marked as failed and updated to "pass" when finished.
# If something goes wrong then it will stay to "fail".
"result": "fail"
})
elif name == "ENDRUN":
self.definition = params[0]
uuid = params[1]
# remove the pattern for this run from pattern_dict
self._reset_patterns()
self.logger.info("Ending use of test pattern.")
self.logger.info("Ending test lava.%s (%s), duration %.02f",
self.definition, uuid,
time.time() - self.start)
self.logger.results({
"definition": "lava",
"case": self.definition,
"uuid": uuid,
"duration": "%.02f" % (time.time() - self.start),
"result": "pass"
})
self.start = None
elif name == "TESTCASE":
data = handle_testcase(params)
# get the fixup from the pattern_dict
res = self.signal_match.match(data, fixupdict=self.pattern.fixupdict())
p_res = self.data["test"][
self.signal_director.test_uuid
].setdefault("results", OrderedDict())
# prevent losing data in the update
# FIXME: support parameters and retries
if res["test_case_id"] in p_res:
raise JobError(
"Duplicate test_case_id in results: %s",
res["test_case_id"])
# check for measurements
calc = {}
if 'measurement' in res:
calc['measurement'] = res['measurement']
if 'measurement' in res and 'units' in res:
calc['units'] = res['units']
# turn the result dict inside out to get the unique
# test_case_id/testset_name as key and result as value
if self.testset_name:
res_data = {
'definition': self.definition,
'case': res["test_case_id"],
'set': self.testset_name,
'result': res["result"]
}
res_data.update(calc)
self.logger.results(res_data)
self.report.update({
"set": self.testset_name,
"case": res["test_case_id"],
"result": res["result"]})
else:
res_data = {
'definition': self.definition,
'case': res["test_case_id"],
'result': res["result"]}
res_data.update(calc)
self.logger.results(res_data)
self.report.update({
res["test_case_id"]: res["result"]
})
elif name == "TESTSET":
action = params.pop(0)
if action == "START":
name = "testset_" + action.lower()
try:
self.testset_name = params[0]
except IndexError:
raise JobError("Test set declared without a name")
self.logger.info("Starting test_set %s", self.testset_name)
elif action == "STOP":
self.logger.info("Closing test_set %s", self.testset_name)
self.testset_name = None
name = "testset_" + action.lower()
try:
self.signal_director.signal(name, params)
except KeyboardInterrupt:
raise KeyboardInterrupt
ret_val = True
elif event == "test_case":
match = test_connection.match
if match is pexpect.TIMEOUT:
self.logger.warning("err: lava_test_shell has timed out (test_case)")
else:
res = self.signal_match.match(match.groupdict())
self.logger.debug("outer_loop_result: %s" % res)
ret_val = True
elif event == 'test_case_result':
res = test_connection.match.groupdict()
if res:
# FIXME: make this a function
# check for measurements
calc = {}
if 'measurement' in res:
calc['measurement'] = res['measurement']
if 'measurement' in res and 'units' in res:
calc['units'] = res['units']
res_data = {
'definition': self.definition,
'case': res["test_case_id"],
'result': res["result"]}
res_data.update(calc)
self.logger.results(res_data)
self.report.update({
res["test_case_id"]: res["result"]
})
ret_val = True
return ret_val
def check_patterns(self, event, test_connection):
"""
Defines the base set of pattern responses.
Stores the results of testcases inside the TestAction
Call from subclasses before checking subclass-specific events.
"""
ret_val = False
if event == "exit":
self.logger.info("ok: lava_test_shell seems to have completed")
elif event == "eof":
self.logger.warning("err: lava_test_shell connection dropped")
self.errors = "lava_test_shell connection dropped"
elif event == "timeout":
# if target.is_booted():
# target.reset_boot()
self.logger.warning("err: lava_test_shell has timed out")
self.errors = "lava_test_shell has timed out"
elif event == "signal":
name, params = test_connection.match.groups()
self.logger.debug("Received signal: <%s> %s" % (name, params))
params = params.split()
if name == "STARTRUN":
self.signal_director.test_uuid = params[1]
self.suite = params[0]
self.logger.debug("Starting test suite: %s" % self.suite)
# self._handle_testrun(params)
elif name == "TESTCASE":
data = handle_testcase(params)
res = self.match.match(data) # FIXME: rename!
self.logger.debug("res: %s data: %s" % (res, data))
p_res = self.data["test"][
self.signal_director.test_uuid].setdefault(
"results", OrderedDict())
# prevent losing data in the update
# FIXME: support parameters and retries
if res["test_case_id"] in p_res:
raise JobError("Duplicate test_case_id in results: %s",
res["test_case_id"])
# turn the result dict inside out to get the unique test_case_id as key and result as value
self.logger.results({
'testsuite': self.suite,
res["test_case_id"]: res["result"]
})
self.report.update({res["test_case_id"]: res["result"]})
try:
self.signal_director.signal(name, params)
except KeyboardInterrupt:
raise KeyboardInterrupt
# force output in case there was none but minimal content to increase speed.
test_connection.sendline("#")
ret_val = True
elif event == "test_case":
match = test_connection.match
if match is pexpect.TIMEOUT:
# if target.is_booted():
# target.reset_boot()
self.logger.warning(
"err: lava_test_shell has timed out (test_case)")
else:
res = self.match.match(match.groupdict()) # FIXME: rename!
self.logger.debug("outer_loop_result: %s" % res)
# self.data["test"][self.signal_director.test_uuid].setdefault("results", {})
# self.data["test"][self.signal_director.test_uuid]["results"].update({
# {res["test_case_id"]: res}
# })
ret_val = True
return ret_val
def check_patterns(self, event, test_connection, check_char): # pylint: disable=too-many-locals
"""
Defines the base set of pattern responses.
Stores the results of testcases inside the TestAction
Call from subclasses before checking subclass-specific events.
"""
ret_val = False
if event == "exit":
self.logger.info("ok: lava_test_shell seems to have completed")
self.testset_name = None
elif event == "eof":
self.logger.warning("err: lava_test_shell connection dropped")
self.errors = "lava_test_shell connection dropped"
self.testset_name = None
elif event == "timeout":
self.logger.warning("err: lava_test_shell has timed out")
self.errors = "lava_test_shell has timed out"
self.testset_name = None
elif event == "signal":
name, params = test_connection.match.groups()
self.logger.debug("Received signal: <%s> %s" % (name, params))
params = params.split()
if name == "STARTRUN":
self.signal_director.test_uuid = params[1]
self.definition = params[0]
uuid = params[1]
self.start = time.time()
self.logger.info("Starting test lava.%s (%s)", self.definition, uuid)
# set the pattern for this run from pattern_dict
testdef_index = self.get_common_data('test-definition', 'testdef_index')
uuid_list = self.get_common_data('repo-action', 'uuid-list')
for key, value in testdef_index.items():
if self.definition == "%s_%s" % (key, value):
pattern = self.job.context['test'][uuid_list[key]]['testdef_pattern']['pattern']
fixup = self.job.context['test'][uuid_list[key]]['testdef_pattern']['fixupdict']
self.patterns.update({'test_case_result': re.compile(pattern, re.M)})
self.pattern.update(pattern, fixup)
self.logger.info("Enabling test definition pattern %r" % pattern)
self.logger.results({
"definition": "lava",
"case": self.definition,
"uuid": uuid,
# The test is marked as failed and updated to "pass" when finished.
# If something goes wrong then it will stay to "fail".
"result": "fail"
})
elif name == "ENDRUN":
self.definition = params[0]
uuid = params[1]
# remove the pattern for this run from pattern_dict
self._reset_patterns()
# catch error in ENDRUN being handled without STARTRUN
if not self.start:
self.start = time.time()
self.logger.info("Ending use of test pattern.")
self.logger.info("Ending test lava.%s (%s), duration %.02f",
self.definition, uuid,
time.time() - self.start)
self.logger.results({
"definition": "lava",
"case": self.definition,
"uuid": uuid,
"duration": "%.02f" % (time.time() - self.start),
"result": "pass"
})
self.start = None
elif name == "TESTCASE":
try:
data = handle_testcase(params)
# get the fixup from the pattern_dict
res = self.signal_match.match(data, fixupdict=self.pattern.fixupdict())
except (JobError, TestError) as exc:
self.logger.error(str(exc))
return True
p_res = self.data["test"][
self.signal_director.test_uuid
].setdefault("results", OrderedDict())
# prevent losing data in the update
# FIXME: support parameters and retries
if res["test_case_id"] in p_res:
raise JobError(
"Duplicate test_case_id in results: %s",
res["test_case_id"])
# turn the result dict inside out to get the unique
# test_case_id/testset_name as key and result as value
res_data = {
'definition': self.definition,
'case': res["test_case_id"],
'result': res["result"]
}
# check for measurements
if 'measurement' in res:
res_data['measurement'] = res['measurement']
if 'units' in res:
res_data['units'] = res['units']
if self.testset_name:
res_data['set'] = self.testset_name
self.report[res['test_case_id']] = {
'set': self.testset_name,
'result': res['result']
}
else:
self.report[res['test_case_id']] = res['result']
# Send the results back
self.logger.results(res_data)
elif name == "TESTSET":
action = params.pop(0)
if action == "START":
name = "testset_" + action.lower()
try:
self.testset_name = params[0]
except IndexError:
raise JobError("Test set declared without a name")
self.logger.info("Starting test_set %s", self.testset_name)
elif action == "STOP":
self.logger.info("Closing test_set %s", self.testset_name)
self.testset_name = None
name = "testset_" + action.lower()
try:
self.signal_director.signal(name, params)
except KeyboardInterrupt:
raise KeyboardInterrupt
ret_val = True
elif event == "test_case":
match = test_connection.match
if match is pexpect.TIMEOUT:
self.logger.warning("err: lava_test_shell has timed out (test_case)")
else:
res = self.signal_match.match(match.groupdict())
self.logger.debug("outer_loop_result: %s" % res)
ret_val = True
elif event == 'test_case_result':
res = test_connection.match.groupdict()
if res:
res_data = {
'definition': self.definition,
'case': res["test_case_id"],
'result': res["result"]
}
# check for measurements
if 'measurement' in res:
res_data['measurement'] = res['measurement']
if 'units' in res:
res_data['units'] = res['units']
self.logger.results(res_data)
self.report[res["test_case_id"]] = res["result"]
ret_val = True
return ret_val
