def test_simple_using_main(self):
mytest = script.TemporaryScript("simple_using_main.py",
AVOCADO_TEST_SIMPLE_USING_MAIN,
'avocado_simpletest_functional')
mytest.save()
os.chdir(basedir)
# job should be able to finish under 5 seconds. If this fails, it's
# possible that we hit the "simple test fork bomb" bug
cmd_line = ("%s run --sysinfo=off --job-results-dir '%s' -- '%s'" %
(AVOCADO, self.tmpdir, mytest))
self._run_with_timeout(cmd_line, 5)
def test_load_tagged_nested(self):
avocado_nested_test = script.TemporaryScript('nested.py',
AVOCADO_TEST_NESTED_TAGGED,
'avocado_loader_unittest',
DEFAULT_NON_EXEC_MODE)
avocado_nested_test.save()
test_class, test_parameters = (
self.loader.discover(avocado_nested_test.path, loader.ALL)[0])
results = self.loader.discover(avocado_nested_test.path, loader.ALL)
self.assertTrue(test_class == test.NotATest)
avocado_nested_test.remove()
def test_python_unittest(self):
disabled_test = script.TemporaryScript("disabled.py",
AVOCADO_TEST_OK_DISABLED,
mode=DEFAULT_NON_EXEC_MODE)
python_unittest = script.TemporaryScript("python_unittest.py",
PYTHON_UNITTEST)
disabled_test.save()
python_unittest.save()
tests = self.loader.discover(disabled_test.path)
self.assertEqual(tests, [])
tests = self.loader.discover(python_unittest.path)
exp = [(test.PythonUnittest, {
"name": "python_unittest.SampleTest.test",
"tags": {
"flattag": None,
"foo": {"bar"}
},
"test_dir": os.path.dirname(python_unittest.path)
})]
self.assertEqual(tests, exp)
def test_py_simple_test(self):
with script.TemporaryScript(
'simpletest.py', PY_SIMPLE_TEST,
'avocado_loader_unittest') as avocado_simple_test:
test_class, test_parameters = (self.loader.discover(
avocado_simple_test.path, loader.DiscoverMode.ALL)[0])
self.assertTrue(test_class == test.SimpleTest)
test_parameters['name'] = TestID(0, test_parameters['name'])
test_parameters['base_logdir'] = self.tmpdir.name
tc = test_class(**test_parameters)
tc.run_avocado()
def test_filter_tags_include_empty(self):
with script.TemporaryScript('passtest.py',
AVOCADO_TEST_OK,
'avocado_loader_unittest',
DEFAULT_NON_EXEC_MODE) as test_script:
this_loader = loader.FileLoader(None, {})
test_suite = this_loader.discover(test_script.path,
loader.DiscoverMode.ALL)
self.assertEqual([], loader.filter_test_tags(test_suite, [], False, False))
self.assertEqual(test_suite,
loader.filter_test_tags(test_suite, [], True, False))
def test_py_simple_test_notexec(self):
avocado_simple_test = script.TemporaryScript(
'simpletest.py',
PY_SIMPLE_TEST,
'avocado_loader_unittest',
mode=DEFAULT_NON_EXEC_MODE)
avocado_simple_test.save()
test_class, _ = self.loader.discover(avocado_simple_test.path,
loader.DiscoverMode.ALL)[0]
self.assertTrue(test_class == loader.NotATest)
avocado_simple_test.remove()
def test_not_exec(self):
with script.TemporaryScript(
"exec-test.sh",
"#!/bin/sh\ntrue",
"test_resolver_exec_test",
mode=DEFAULT_NON_EXEC_MODE,
) as exec_test:
res = ExecTestResolver().resolve(exec_test.path)
self.assertEqual(res.reference, exec_test.path)
self.assertEqual(res.result,
resolver.ReferenceResolutionResult.NOTFOUND)
self.assertEqual(len(res.resolutions), 0)
def setUp(self):
self.tmpdir = tempfile.mkdtemp(prefix='avocado_' + __name__)
self.pass_script = script.TemporaryScript(
'avocado_pass.sh', PASS_SCRIPT_CONTENTS,
'avocado_simpletest_unittest')
self.pass_script.save()
self.fail_script = script.TemporaryScript(
'avocado_fail.sh', FAIL_SCRIPT_CONTENTS,
'avocado_simpletest_unittest')
self.fail_script.save()
self.tst_instance_pass = test.SimpleTest(name=test.TestName(
1, self.pass_script.path),
base_logdir=self.tmpdir)
self.tst_instance_pass.run_avocado()
self.tst_instance_fail = test.SimpleTest(name=test.TestName(
1, self.fail_script.path),
base_logdir=self.tmpdir)
self.tst_instance_fail.run_avocado()
def test_load_not_a_test_exec(self):
avocado_not_a_test = script.TemporaryScript('notatest.py', NOT_A_TEST,
'avocado_loader_unittest')
avocado_not_a_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_not_a_test.path, True)[0])
self.assertTrue(test_class == test.SimpleTest, test_class)
tc = test_class(**test_parameters)
# The test can't be executed (no shebang), raising an OSError
# (OSError: [Errno 8] Exec format error)
self.assertRaises(OSError, tc.test)
avocado_not_a_test.remove()
def test_load_multiple_imports(self):
avocado_multiple_imp_test = script.TemporaryScript(
"multipleimports.py",
AVOCADO_TEST_MULTIPLE_IMPORTS,
"avocado_loader_unittest",
)
avocado_multiple_imp_test.save()
test_class, _ = self.loader.discover(
avocado_multiple_imp_test.path, loader.DiscoverMode.ALL
)[0]
self.assertTrue(test_class == "Second", test_class)
avocado_multiple_imp_test.remove()
def test_load_buggy_not_exec(self):
avocado_buggy_test = script.TemporaryScript('buggytest.py',
AVOCADO_TEST_BUGGY,
'avocado_loader_unittest',
mode=0664)
avocado_buggy_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_buggy_test.path, True)[0])
self.assertTrue(test_class == test.BuggyTest, test_class)
tc = test_class(**test_parameters)
self.assertRaises(ImportError, tc.test)
avocado_buggy_test.remove()
def test_load_not_a_test(self):
avocado_not_a_test = script.TemporaryScript('notatest.py',
NOT_A_TEST,
'avocado_loader_unittest',
mode=0664)
avocado_not_a_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_not_a_test.path, True)[0])
self.assertTrue(test_class == test.NotATest, test_class)
tc = test_class(**test_parameters)
self.assertRaises(exceptions.NotATestError, tc.test)
avocado_not_a_test.remove()
def test_list_raising_exception(self):
with script.TemporaryScript("test.py", AVOCADO_TEST_OK) as avocado_test:
with unittest.mock.patch(
"avocado.core.loader.safeloader.find_avocado_tests"
) as _mock:
_mock.side_effect = BaseException()
tests = self.loader.discover(avocado_test.path, loader.DiscoverMode.ALL)
self.assertEqual(
tests[0][1]["name"],
f"{avocado_test.path}: Not an INSTRUMENTED "
f"(avocado.Test based) test",
)
def test_load_inherited(self):
avocado_base_test = script.TemporaryScript('base.py',
AVOCADO_BASE_CLASS_TEST,
'avocado_loader_unittest')
avocado_base_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_base_test.path, True)[0])
self.assertTrue(
str(test_class) == "<class 'base.MyBaseTest'>", str(test_class))
avocado_inherited_test = script.TemporaryScript(
'inherited.py', AVOCADO_INHERITED_CLASS_TEST,
'avocado_loader_unittest')
avocado_inherited_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_inherited_test.path, True)[0])
self.assertTrue(
str(test_class) == "<class 'inherited.MyInheritedTest'>",
str(test_class))
avocado_base_test.remove()
avocado_inherited_test.remove()
def test_runner_test_with_local_imports(self):
mylib = script.TemporaryScript('mylib.py', HELLO_LIB_CONTENTS,
'avocado_simpletest_functional')
mylib.save()
mytest = script.Script(
os.path.join(os.path.dirname(mylib.path), 'test_local_imports.py'),
LOCAL_IMPORT_TEST_CONTENTS)
os.chdir(basedir)
mytest.save()
cmd_line = ("./scripts/avocado run --sysinfo=off --job-results-dir %s "
"%s" % (self.tmpdir, mytest))
process.run(cmd_line)
def test_load_simple_not_exec(self):
simple_test = script.TemporaryScript('simpletest.sh',
SIMPLE_TEST,
'avocado_loader_unittest',
mode=0664)
simple_test.save()
test_class, test_parameters = (self.loader.discover(
simple_test.path, True)[0])
self.assertTrue(test_class == test.NotATest, test_class)
tc = test_class(**test_parameters)
self.assertRaises(exceptions.NotATestError, tc.test)
simple_test.remove()
def test_pass(self):
avocado_pass_test = script.TemporaryScript('passtest.py',
AVOCADO_TEST_OK,
'avocado_loader_test')
avocado_pass_test.save()
cmd_line = './scripts/avocado run --job-results-dir %s --sysinfo=off %s' % (
self.tmpdir, avocado_pass_test.path)
result = process.run(cmd_line, ignore_status=True)
expected_rc = 0
self.assertEqual(
result.exit_status, expected_rc,
"Avocado did not return rc %d:\n%s" % (expected_rc, result))
def test_py_simple_test(self):
avocado_simple_test = script.TemporaryScript(
'simpletest.py', PY_SIMPLE_TEST, 'avocado_loader_unittest')
avocado_simple_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_simple_test.path, loader.ALL)[0])
self.assertTrue(test_class == test.SimpleTest)
test_parameters['name'] = test.TestName(0, test_parameters['name'])
test_parameters['base_logdir'] = self.tmpdir
tc = test_class(**test_parameters)
tc.run_avocado()
avocado_simple_test.remove()
def setUp(self):
prefix = temp_dir_prefix(__name__, self, 'setUp')
self.tmpdir = tempfile.TemporaryDirectory(prefix=prefix)
content = b"#!/bin/sh\n"
content += b"echo \"" + STDOUT + b"\"\n"
content += b"echo \"" + STDERR + b"\" >&2\n"
self.output_script = script.TemporaryScript(
'output_check.sh',
content,
'avocado_output_check_functional',
open_mode='wb')
self.output_script.save()
def test_py_simple_test_notexec(self):
avocado_simple_test = script.TemporaryScript('simpletest.py',
PY_SIMPLE_TEST,
'avocado_loader_unittest',
mode=0664)
avocado_simple_test.save()
test_class, test_parameters = (
self.loader.discover_test(params={'id': avocado_simple_test.path}))
self.assertTrue(test_class == test.NotATest)
tc = test_class(**test_parameters)
self.assertRaises(exceptions.NotATestError, tc.action)
avocado_simple_test.remove()
def setUp(self):
prefix = temp_dir_prefix(__name__, self, 'setUp')
self.tmpdir = tempfile.TemporaryDirectory(prefix=prefix)
self.original_pypath = os.environ.get('PYTHONPATH')
if self.original_pypath is not None:
os.environ['PYTHONPATH'] = '%s:%s' % (BASEDIR,
self.original_pypath)
else:
os.environ['PYTHONPATH'] = '%s' % BASEDIR
self.unittest_script_good = script.TemporaryScript(
'unittest_good.py', UNITTEST_GOOD % self.tmpdir.name,
'avocado_as_unittest_functional')
self.unittest_script_good.save()
self.unittest_script_fail = script.TemporaryScript(
'unittest_fail.py', UNITTEST_FAIL % self.tmpdir.name,
'avocado_as_unittest_functional')
self.unittest_script_fail.save()
self.unittest_script_error = script.TemporaryScript(
'unittest_error.py', UNITTEST_ERROR % self.tmpdir.name,
'avocado_as_unittest_functional')
self.unittest_script_error.save()
def test_load_tagged_nested(self):
avocado_nested_test = script.TemporaryScript(
"nested.py",
AVOCADO_TEST_NESTED_TAGGED,
"avocado_loader_unittest",
DEFAULT_NON_EXEC_MODE,
)
avocado_nested_test.save()
test_class, _ = self.loader.discover(
avocado_nested_test.path, loader.DiscoverMode.ALL
)[0]
self.assertTrue(test_class == loader.NotATest)
avocado_nested_test.remove()
def test_load_pass(self):
avocado_pass_test = script.TemporaryScript('passtest.py',
AVOCADO_TEST_OK,
'avocado_loader_unittest')
avocado_pass_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_pass_test.path, True)[0])
self.assertTrue(
str(test_class) == "<class 'passtest.PassTest'>", str(test_class))
self.assertTrue(issubclass(test_class, test.Test))
tc = test_class(**test_parameters)
tc.test()
avocado_pass_test.remove()
def test_load_pass_disable(self):
avocado_pass_test = script.TemporaryScript(
"disable.py",
AVOCADO_TEST_OK_DISABLED,
"avocado_loader_unittest",
DEFAULT_NON_EXEC_MODE,
)
avocado_pass_test.save()
test_class, _ = self.loader.discover(
avocado_pass_test.path, loader.DiscoverMode.ALL
)[0]
self.assertTrue(test_class == loader.NotATest)
avocado_pass_test.remove()
def test_exec_test(self):
with script.TemporaryScript('exec-test.sh', "#!/bin/sh\ntrue",
'test_resolver_exec_test') as exec_test:
res = ExecTestResolver().resolve(exec_test.path)
self.assertEqual(res.reference, exec_test.path)
self.assertEqual(res.result, resolver.ReferenceResolutionResult.SUCCESS)
self.assertEqual(len(res.resolutions), 1)
resolution = res.resolutions[0]
self.assertEqual(resolution.kind, 'exec-test')
self.assertEqual(resolution.uri, exec_test.path)
self.assertEqual(resolution.args, ())
self.assertEqual(resolution.kwargs, {})
self.assertEqual(resolution.tags, None)
def setUp(self):
self.pass_script = script.TemporaryScript(
'avocado_pass.sh',
PASS_SCRIPT_CONTENTS,
'avocado_simpletest_unittest')
self.pass_script.save()
self.fail_script = script.TemporaryScript(
'avocado_fail.sh',
FAIL_SCRIPT_CONTENTS,
'avocado_simpletest_unittest')
self.fail_script.save()
self.tst_instance_pass = test.SimpleTest(
path=self.pass_script.path,
base_logdir=os.path.dirname(self.pass_script.path))
self.tst_instance_pass.run_avocado()
self.tst_instance_fail = test.SimpleTest(
path=self.fail_script.path,
base_logdir=os.path.dirname(self.fail_script.path))
self.tst_instance_fail.run_avocado()
def test_load_simple_not_exec(self):
simple_test = script.TemporaryScript('simpletest.sh', SIMPLE_TEST,
'avocado_loader_unittest',
mode=DEFAULT_NON_EXEC_MODE)
simple_test.save()
test_class, test_parameters = (
self.loader.discover(simple_test.path, loader.ALL)[0])
self.assertTrue(test_class == test.NotATest, test_class)
test_parameters['name'] = test.TestName(0, test_parameters['name'])
test_parameters['base_logdir'] = self.tmpdir
tc = test_class(**test_parameters)
self.assertRaises(exceptions.NotATestError, tc.test)
simple_test.remove()
def test_load_not_a_test(self):
avocado_not_a_test = script.TemporaryScript('notatest.py', NOT_A_TEST,
'avocado_loader_test')
avocado_not_a_test.save()
cmd_line = (
'./scripts/avocado run --job-results-dir %s --sysinfo=off %s' %
(self.tmpdir, avocado_not_a_test.path))
result = process.run(cmd_line, ignore_status=True)
expected_rc = 1
self.assertEqual(
result.exit_status, expected_rc,
"Avocado did not return rc %d:\n%s" % (expected_rc, result))
avocado_not_a_test.remove()
def test_buggy_not_exec(self):
avocado_buggy_test = script.TemporaryScript('buggytest.py',
AVOCADO_TEST_BUGGY,
'avocado_loader_test',
mode=0664)
avocado_buggy_test.save()
cmd_line = './scripts/avocado run --sysinfo=off %s' % avocado_buggy_test.path
result = process.run(cmd_line, ignore_status=True)
expected_rc = 1
self.assertEqual(
result.exit_status, expected_rc,
"Avocado did not return rc %d:\n%s" % (expected_rc, result))
avocado_buggy_test.remove()
def test_py_simple_test_notexec(self):
avocado_simple_test = script.TemporaryScript(
'simpletest.py',
PY_SIMPLE_TEST,
'avocado_loader_unittest',
mode=DEFAULT_NON_EXEC_MODE)
avocado_simple_test.save()
test_class, test_parameters = (self.loader.discover(
avocado_simple_test.path, True)[0])
self.assertTrue(test_class == test.NotATest)
tc = test_class(**test_parameters)
self.assertRaises(exceptions.NotATestError, tc.test)
avocado_simple_test.remove()
