def _add_step_entry(self, entry, event):
report_node_data = self.report.get(event.location)
if not report_node_data:
raise ProgrammingError("Cannot find location %s in the report" % event.location)
step = self._lookup_step(report_node_data.steps, event.step)
if step.end_time:
raise ProgrammingError("Cannot update step '%s', it is already ended" % step.description)
step.entries.append(entry)
def wrapper(klass):
if not inspect.isclass(klass):
raise ProgrammingError(
"%s is not a class (suite decorator can only be used on a class)"
% klass)
md = get_metadata(klass)
if md.dependencies:
raise ProgrammingError(
"'depends_on' can not be used on a suite class")
md.is_suite = True
md.rank = rank if rank is not None else get_metadata_next_rank()
md.name = name or klass.__name__
md.description = description
return klass
def _unserialize_step_data(xml):
step = Step(xml.attrib["description"])
step.start_time = _unserialize_datetime(xml.attrib["start-time"])
step.end_time = _unserialize_datetime(
xml.attrib["end-time"]) if "end-time" in xml.attrib else None
for xml_entry in xml:
if xml_entry.tag == "log":
entry = Log(xml_entry.attrib["level"], xml_entry.text,
_unserialize_datetime(xml_entry.attrib["time"]))
elif xml_entry.tag == "attachment":
entry = Attachment(xml_entry.attrib["description"], xml_entry.text,
_unserialize_bool(xml_entry.attrib["as-image"]),
_unserialize_datetime(xml_entry.attrib["time"]))
elif xml_entry.tag == "url":
entry = Url(xml_entry.attrib["description"], xml_entry.text,
_unserialize_datetime(xml_entry.attrib["time"]))
elif xml_entry.tag == "check":
entry = Check(xml_entry.attrib["description"],
_unserialize_outcome(xml_entry.attrib["outcome"]),
xml_entry.text,
_unserialize_datetime(xml_entry.attrib["time"]))
else:
raise ProgrammingError("Unknown tag '%s' for step" % xml_entry.tag)
step.entries.append(entry)
return step
def _unserialize_bool(value):
if value == "true":
return True
elif value == "false":
return False
else:
raise ProgrammingError("Invalid boolean representation: '%s'" % value)
def wrapper(obj):
md = get_metadata(obj)
if md.is_suite:
raise ProgrammingError(
"'depends_on' can not be used on a suite class")
md.dependencies.extend(deps)
return obj
def _get_rule_application(self, on_test, on_suite):
if on_test is None and on_suite is None:
return True, False
if not on_test and not on_suite:
raise ProgrammingError(
"either on_test or on_suite need to be True")
return bool(on_test), bool(on_suite)
def wrapper(func):
if scope not in SCOPE_LEVELS.keys():
raise ProgrammingError(
"Invalid fixture scope '%s' in fixture function '%s'" %
(scope, func.__name__))
setattr(func, "_lccfixtureinfo", FixtureInfo(names, scope))
return func
def _lookup_step(steps, step):
if step is None:
return steps[-1]
else:
try:
return next(s for s in reversed(steps) if s.description == step)
except StopIteration:
raise ProgrammingError("Cannot find step '%s'" % step)
def _unserialize_outcome(value):
if value == OUTCOME_SUCCESS:
return True
elif value == OUTCOME_FAILURE:
return False
elif value == OUTCOME_NOT_AVAILABLE:
return None
else:
raise ProgrammingError("Unknown value '%s' for outcome" % value)
def get_fixture(name):
"""
Return the corresponding fixture value. Only fixtures whose scope is session_prerun can be retrieved.
"""
global _scheduled_fixtures
if not _scheduled_fixtures:
raise ProgrammingError("Fixture cache has not yet been initialized")
if not _scheduled_fixtures.has_fixture(name):
raise ProgrammingError(
"Fixture '%s' either does not exist or don't have a prerun_session scope"
% name)
try:
return _scheduled_fixtures.get_fixture_result(name)
except AssertionError as excp:
raise ProgrammingError(str(excp))
def get_fixture_result(self, name):
if name in self._fixtures:
assert name in self._results, "Cannot get fixture '%s' result, it has not been previously executed" % name
return self._results[name].get()
elif self._parent_scheduled_fixtures:
return self._parent_scheduled_fixtures.get_fixture_result(name)
else:
raise ProgrammingError(
"Cannot find fixture named '%s' in scheduled fixtures" % name)
def _get_actual_for_dict_operation(in_):
if in_ is not None:
return in_
else:
context = ThisDict.get_current_context()
if not context:
raise ProgrammingError(
"Actual dict must be set either using in_ argument or using 'with this_dict(...)' statement"
)
return context.actual
def get_callable_args(cb):
if not inspect.isroutine(cb):
try:
cb = getattr(cb, "__call__")
except AttributeError:
raise ProgrammingError("%s is not something that can be called" %
cb)
spec = inspect.getfullargspec(cb) if six.PY3 else inspect.getargspec(cb)
args_start = 1 if inspect.ismethod(cb) else 0
return spec.args[args_start:]
def wrapper(func):
if not inspect.isfunction(func):
raise ProgrammingError(
"%s is not a function (test decorator can only be used on a function)"
% func)
md = get_metadata(func)
md.is_test = True
md.rank = get_metadata_next_rank()
md.name = name or func.__name__
md.description = description
return func
def load_suite_from_class(class_):
try:
md = class_._lccmetadata
except AttributeError:
raise InvalidSuiteError()
try:
suite_obj = class_()
except UserError as e:
raise e # propagate UserError
except Exception:
raise ProgrammingError("Got an unexpected error while instantiating suite class '%s':%s" % (
class_.__name__, serialize_current_exception()
))
ensure_node_is_visible(suite_obj, md)
suite = Suite(suite_obj, md.name, md.description)
suite.tags.extend(md.tags)
suite.properties.update(md.properties)
suite.links.extend(md.links)
suite.rank = md.rank
suite.disabled = md.disabled
for hook_name in SUITE_HOOKS:
if hasattr(suite_obj, hook_name):
suite.add_hook(hook_name, getattr(suite_obj, hook_name))
for test in load_tests_from_methods(get_test_methods_from_class(suite_obj)):
suite.add_test(test)
for test in get_generated_tests(suite_obj):
suite.add_test(test)
for sub_suite in load_suites_from_classes(get_sub_suites_from_class(suite_obj)):
suite.add_suite(sub_suite)
return suite
def save(self):
if not self.is_bound():
raise ProgrammingError("Cannot save unbound report")
save_report(self.path, self, self.backend)
def save_report(filename, report, backend):
if not backend.get_capabilities() & CAPABILITY_SAVE_REPORT:
raise ProgrammingError(
"Reporting backend '%s' does not support save operation" %
backend.name)
backend.save_report(filename, report)
def run_project(project, cli_args):
nb_threads = get_nb_threads(cli_args)
if nb_threads > 1 and not project.is_threaded():
raise LemonCheesecakeException("Project does not support multi-threading")
suites = get_suites_from_project(project, cli_args)
# Build fixture registry
fixture_registry = build_fixture_registry(project, cli_args)
fixture_registry.check_fixtures_in_suites(suites)
# Set active reporting backends
available_reporting_backends = {
backend.name: backend for backend in
filter_reporting_backends_by_capabilities(
project.get_all_reporting_backends(), CAPABILITY_REPORTING_SESSION
)
}
active_reporting_backends = set()
for backend_name in cli_args.reporting + cli_args.enable_reporting:
try:
active_reporting_backends.add(available_reporting_backends[backend_name])
except KeyError:
raise LemonCheesecakeException("Unknown reporting backend '%s'" % backend_name)
for backend_name in cli_args.disable_reporting:
try:
active_reporting_backends.discard(available_reporting_backends[backend_name])
except KeyError:
raise LemonCheesecakeException("Unknown reporting backend '%s'" % backend_name)
# Get report save mode
report_saving_strategy = get_report_saving_strategy(cli_args)
# Create report dir
if cli_args.report_dir:
report_dir = cli_args.report_dir
try:
os.mkdir(report_dir)
except Exception as e:
return LemonCheesecakeException("Cannot create report directory: %s" % e)
else:
try:
report_dir = project.create_report_dir()
except UserError as e:
raise e
except Exception:
raise LemonCheesecakeException(
"Got an unexpected exception while creating report directory:%s" % \
serialize_current_exception(show_stacktrace=True)
)
# Handle before run hook
try:
project.run_pre_session_hook(cli_args, report_dir)
except UserError as e:
raise e
except Exception:
raise ProgrammingError(
"Got an unexpected exception while running the pre-session hook:%s" % \
serialize_current_exception(show_stacktrace=True)
)
# Initialize event manager
event_manager = initialize_event_manager(
suites, active_reporting_backends, report_dir, report_saving_strategy, nb_threads
)
event_manager.add_listener(project)
# Run tests
is_successful = run_suites(
suites, fixture_registry, event_manager,
force_disabled=cli_args.force_disabled, stop_on_failure=cli_args.stop_on_failure,
nb_threads=nb_threads
)
# Handle after run hook
try:
project.run_post_session_hook(cli_args, report_dir)
except UserError as e:
raise e
except Exception:
raise ProgrammingError(
"Got an unexpected exception while running the post-session hook:%s" % \
serialize_current_exception(show_stacktrace=True)
)
if cli_args.exit_error_on_failure:
return 0 if is_successful else 1
else:
return 0
