teuthology 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

teuthology/task/tests/__init__.py

@@ -1,170 +0,0 @@
-"""
-This task runs teuthology's unit tests and integration tests.
-It can run in one of two modes: "py" or "cli". The latter executes py.test in a
-separate process, whereas the former invokes it in the teuthology job's python
-process.
-If the running job has remotes available to it, it will attempt to run integration tests.
-Note that this requires running in "py" mode - the default.
-
-An example::
-
-    tasks
-      - tests:
-"""
-import logging
-import os
-import pathlib
-import pexpect
-import pytest
-
-from teuthology.job_status import set_status
-from teuthology.task import Task
-from teuthology.util.loggerfile import LoggerFile
-
-
-log = logging.getLogger(__name__)
-
-
-class TeuthologyContextPlugin(object):
-    def __init__(self, ctx, config):
-        self.ctx = ctx
-        self.config = config
-        self.failures = list()
-        self.stats = dict()
-
-    # this is pytest hook for generating tests with custom parameters
-    def pytest_generate_tests(self, metafunc):
-        # pass the teuthology ctx and config to each test method
-        if "ctx" in metafunc.fixturenames and \
-                "config" in metafunc.fixturenames:
-            metafunc.parametrize(["ctx", "config"], [(self.ctx, self.config),])
-
-    # log the outcome of each test
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_runtest_makereport(self, item: pytest.Item, call: pytest.CallInfo):
-        outcome = yield
-        report = outcome.get_result()
-        test_path = item.location[0]
-        line_no = item.location[1]
-        test_name = item.location[2]
-        name = f"{test_path}:{line_no}:{test_name}"
-        log_msg = f"{report.outcome.upper()} {name}"
-        outcome_str = report.outcome.lower()
-        self.stats.setdefault(outcome_str, 0)
-        self.stats[outcome_str] += 1
-        if outcome_str in ['passed', 'skipped']:
-            if call.when == 'call':
-                log.info(log_msg)
-            else:
-                log.info(f"----- {name} {call.when} -----")
-        else:
-            log_msg = f"{log_msg}:{call.when}"
-            if call.excinfo:
-                self.failures.append(name)
-                log_msg = f"{log_msg}: {call.excinfo.getrepr()}"
-            else:
-                self.failures.append(log_msg)
-            log.error(log_msg)
-
-        return
-
-
-# https://docs.pytest.org/en/stable/reference/exit-codes.html
-exit_codes = {
-    0: "All tests were collected and passed successfully",
-    1: "Tests were collected and run but some of the tests failed",
-    2: "Test execution was interrupted by the user",
-    3: "Internal error happened while executing tests",
-    4: "pytest command line usage error",
-    5: "No tests were collected",
-}
-
-
-class Tests(Task):
-    """
-    Use pytest to recurse through this directory, finding any tests
-    and then executing them with the teuthology ctx and config args.
-    Your tests must follow standard pytest conventions to be discovered.
-
-    If config["mode"] == "py", (the default), it will be run in the job's process.
-    If config["mode"] == "cli" py.test will be invoked as a subprocess.
-    """
-    base_args = ['-v', '--color=no']
-
-    def setup(self):
-        super().setup()
-        mode = self.config.get("mode", "py")
-        assert mode in ["py", "cli"], "mode must either be 'py' or 'cli'"
-        if mode == "cli":
-            # integration tests need ctx from this process, so we need to invoke
-            # pytest via python to be able to pass them
-            assert len(self.cluster.remotes) == 0, \
-                "Tests requiring remote nodes conflicts with CLI mode"
-        self.mode = mode
-        self.stats = dict()
-        self.orig_curdir = os.curdir
-
-    def begin(self):
-        super().begin()
-        try:
-            if self.mode == "py":
-                self.status, self.failures = self.run_py()
-            else:
-                self.status, self.failures = self.run_cli()
-        except Exception as e:
-            log.exception("Saw non-test failure!")
-            self.ctx.summary['failure_reason'] = str(e)
-            set_status(self.ctx.summary, "dead")
-
-    def end(self):
-        if os.curdir != self.orig_curdir:
-            os.chdir(self.orig_curdir)
-        if self.stats:
-            log.info(f"Stats: {self.stats}")
-        if self.status == 0:
-            log.info("OK. All tests passed!")
-            set_status(self.ctx.summary, "pass")
-        else:
-            status_msg = str(self.status)
-            if self.status in exit_codes:
-                status_msg = f"{status_msg}: {exit_codes[self.status]}"
-            log.error(f"FAIL (exit code {status_msg})")
-            if self.failures:
-                msg = f"{len(self.failures)} Failures: {self.failures}"
-                self.ctx.summary['failure_reason'] = msg
-                log.error(msg)
-            set_status(self.ctx.summary, "fail")
-        super().end()
-
-    def run_cli(self):
-        pytest_args = self.base_args + ['./teuthology/test', './scripts']
-        if len(self.cluster.remotes):
-            pytest_args.append('./teuthology/task/tests')
-        self.log.info(f"pytest args: {pytest_args}")
-        cwd = str(pathlib.Path(__file__).parents[3])
-        log.info(f"pytest cwd: {cwd}")
-        _, status = pexpect.run(
-            "py.test " + " ".join(pytest_args),
-            cwd=cwd,
-            withexitstatus=True,
-            timeout=None,
-            logfile=LoggerFile(self.log, logging.INFO),
-        )
-        return status, []
-
-    def run_py(self):
-        pytest_args = self.base_args + ['--pyargs', 'teuthology', 'scripts']
-        if len(self.cluster.remotes):
-            pytest_args.append(__name__)
-        self.log.info(f"pytest args: {pytest_args}")
-        context_plugin = TeuthologyContextPlugin(self.ctx, self.config)
-        # the cwd needs to change so that FakeArchive can find files in this repo
-        os.chdir(str(pathlib.Path(__file__).parents[3]))
-        status = pytest.main(
-            args=pytest_args,
-            plugins=[context_plugin],
-        )
-        self.stats = context_plugin.stats
-        return status, context_plugin.failures
-
-task = Tests

teuthology/task/tests/test_fetch_coredumps.py

@@ -1,116 +0,0 @@
-from teuthology.task.internal import fetch_binaries_for_coredumps
-from unittest.mock import patch, Mock
-import gzip
-import os
-
-class TestFetchCoreDumps(object):
-    class MockDecode(object):
-        def __init__(self, ret):
-            self.ret = ret
-            pass
-
-        def decode(self):
-            return self.ret
-
-    class MockPopen(object):
-        def __init__(self, ret):
-            self.ret = ret
-
-        def communicate(self, input=None):
-            return [TestFetchCoreDumps.MockDecode(self.ret)]
-
-    def setup_method(self):
-        self.the_function = fetch_binaries_for_coredumps
-        with gzip.open('file.gz', 'wb') as f:
-            f.write(b'Hello world!')
-        self.core_dump_path = "file.gz"
-        self.m_remote = Mock()
-        self.uncompressed_correct = self.MockPopen(
-            "ELF 64-bit LSB core file,"\
-            " x86-64, version 1 (SYSV), SVR4-style, from 'ceph_test_rados_api_io',"\
-            " real uid: 1194, effective uid: 1194, real gid: 1194,"\
-            " effective gid: 1194, execfn: '/usr/bin/ceph_test_rados_api_io', platform: 'x86_64'"
-        )
-        self.uncompressed_incorrect = self.MockPopen("ASCII text")
-        self.compressed_correct = self.MockPopen(
-            "gzip compressed data, was "\
-            "'correct.format.core', last modified: Wed Jun 29"\
-            " 19:55:29 2022, from Unix, original size modulo 2^32 3167080"
-        )
-
-        self.compressed_incorrect = self.MockPopen(
-            "gzip compressed data, was "\
-            "'incorrect.format.core', last modified: Wed Jun 29"\
-            " 19:56:56 2022, from Unix, original size modulo 2^32 11"
-        )
-
-    # Core is not compressed and file is in the correct format
-    @patch('teuthology.task.internal.subprocess.Popen')
-    @patch('teuthology.task.internal.os')
-    def test_uncompressed_correct_format(self, m_os, m_subproc_popen):
-        m_subproc_popen.side_effect = [
-                self.uncompressed_correct,
-                Exception("We shouldn't be hitting this!")
-            ]
-        m_os.path.join.return_value = self.core_dump_path
-        m_os.path.sep = self.core_dump_path
-        m_os.path.isdir.return_value = True
-        m_os.path.dirname.return_value = self.core_dump_path
-        m_os.path.exists.return_value = True
-        m_os.listdir.return_value = [self.core_dump_path]
-        self.the_function(None, self.m_remote)
-        assert self.m_remote.get_file.called
-
-    # Core is not compressed and file is in the wrong format
-    @patch('teuthology.task.internal.subprocess.Popen')
-    @patch('teuthology.task.internal.os')
-    def test_uncompressed_incorrect_format(self, m_os, m_subproc_popen):
-        m_subproc_popen.side_effect = [
-                self.uncompressed_incorrect,
-                Exception("We shouldn't be hitting this!")
-            ]
-        m_os.path.join.return_value = self.core_dump_path
-        m_os.path.sep = self.core_dump_path
-        m_os.path.isdir.return_value = True
-        m_os.path.dirname.return_value = self.core_dump_path
-        m_os.path.exists.return_value = True
-        m_os.listdir.return_value = [self.core_dump_path]
-        self.the_function(None, self.m_remote)
-        assert self.m_remote.get_file.called == False
-
-    # Core is compressed and file is in the correct format
-    @patch('teuthology.task.internal.subprocess.Popen')
-    @patch('teuthology.task.internal.os')
-    def test_compressed_correct_format(self, m_os, m_subproc_popen):
-        m_subproc_popen.side_effect = [
-                self.compressed_correct,
-                self.uncompressed_correct
-            ]
-        m_os.path.join.return_value = self.core_dump_path
-        m_os.path.sep = self.core_dump_path
-        m_os.path.isdir.return_value = True
-        m_os.path.dirname.return_value = self.core_dump_path
-        m_os.path.exists.return_value = True
-        m_os.listdir.return_value = [self.core_dump_path]
-        self.the_function(None, self.m_remote)
-        assert self.m_remote.get_file.called
-
-    # Core is compressed and file is in the wrong format
-    @patch('teuthology.task.internal.subprocess.Popen')
-    @patch('teuthology.task.internal.os')
-    def test_compressed_incorrect_format(self, m_os, m_subproc_popen):
-        m_subproc_popen.side_effect = [
-                self.compressed_incorrect,
-                self.uncompressed_incorrect
-            ]
-        m_os.path.join.return_value = self.core_dump_path
-        m_os.path.sep = self.core_dump_path
-        m_os.path.isdir.return_value = True
-        m_os.path.dirname.return_value = self.core_dump_path
-        m_os.path.exists.return_value = True
-        m_os.listdir.return_value = [self.core_dump_path]
-        self.the_function(None, self.m_remote)
-        assert self.m_remote.get_file.called == False
-
-    def teardown(self):
-        os.remove(self.core_dump_path)

teuthology/task/tests/test_locking.py

@@ -1,25 +0,0 @@
-import pytest
-
-
-class TestLocking(object):
-
-    def test_correct_os_type(self, ctx, config):
-        os_type = ctx.config.get("os_type")
-        if os_type is None:
-            pytest.skip('os_type was not defined')
-        for remote in ctx.cluster.remotes.keys():
-            assert remote.os.name == os_type
-
-    def test_correct_os_version(self, ctx, config):
-        os_version = ctx.config.get("os_version")
-        if os_version is None:
-            pytest.skip('os_version was not defined')
-        if ctx.config.get("os_type") == "debian":
-            pytest.skip('known issue with debian versions; see: issue #10878')
-        for remote in ctx.cluster.remotes.keys():
-            assert remote.inventory_info['os_version'] == os_version
-
-    def test_correct_machine_type(self, ctx, config):
-        machine_type = ctx.machine_type
-        for remote in ctx.cluster.remotes.keys():
-            assert remote.machine_type in machine_type

teuthology/task/tests/test_run.py

@@ -1,40 +0,0 @@
-import logging
-import pytest
-
-from io import StringIO
-
-from teuthology.exceptions import CommandFailedError
-
-log = logging.getLogger(__name__)
-
-
-class TestRun(object):
-    """
-    Tests to see if we can make remote procedure calls to the current cluster
-    """
-
-    def test_command_failed_label(self, ctx, config):
-        result = ""
-        try:
-            ctx.cluster.run(
-                args=["python3", "-c", "assert False"],
-                label="working as expected, nothing to see here"
-            )
-        except CommandFailedError as e:
-            result = str(e)
-
-        assert "working as expected" in result
-
-    def test_command_failed_no_label(self, ctx, config):
-        with pytest.raises(CommandFailedError):
-            ctx.cluster.run(
-                args=["python3", "-c", "assert False"],
-            )
-
-    def test_command_success(self, ctx, config):
-        result = StringIO()
-        ctx.cluster.run(
-            args=["python3", "-c", "print('hi')"],
-            stdout=result
-        )
-        assert result.getvalue().strip() == "hi"