teuthology 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

teuthology/orchestra/test/test_run.py

@@ -1,286 +0,0 @@
-from io import BytesIO
-
-import paramiko
-import socket
-
-from mock import MagicMock, patch
-from pytest import raises
-
-from teuthology.orchestra import run
-from teuthology.exceptions import (CommandCrashedError, CommandFailedError,
-                                   ConnectionLostError)
-
-def set_buffer_contents(buf, contents):
-    buf.seek(0)
-    if isinstance(contents, bytes):
-        buf.write(contents)
-    elif isinstance(contents, (list, tuple)):
-        buf.writelines(contents)
-    elif isinstance(contents, str):
-        buf.write(contents.encode())
-    else:
-        raise TypeError(
-            "%s is a %s; should be a byte string, list or tuple" % (
-                contents, type(contents)
-            )
-        )
-    buf.seek(0)
-
-
-class TestRun(object):
-    def setup(self):
-        self.start_patchers()
-
-    def teardown(self):
-        self.stop_patchers()
-
-    def start_patchers(self):
-        self.m_remote_process = MagicMock(wraps=run.RemoteProcess)
-        self.patcher_remote_proc = patch(
-            'teuthology.orchestra.run.RemoteProcess',
-            self.m_remote_process,
-        )
-        self.m_channel = MagicMock(spec=paramiko.Channel)()
-        """
-        self.m_channelfile = MagicMock(wraps=paramiko.ChannelFile)
-        self.m_stdin_buf = self.m_channelfile(self.m_channel())
-        self.m_stdout_buf = self.m_channelfile(self.m_channel())
-        self.m_stderr_buf = self.m_channelfile(self.m_channel())
-        """
-        class M_ChannelFile(BytesIO):
-            channel = MagicMock(spec=paramiko.Channel)()
-
-        self.m_channelfile = M_ChannelFile
-        self.m_stdin_buf = self.m_channelfile()
-        self.m_stdout_buf = self.m_channelfile()
-        self.m_stderr_buf = self.m_channelfile()
-        self.m_ssh = MagicMock()
-        self.m_ssh.exec_command.return_value = (
-            self.m_stdin_buf,
-            self.m_stdout_buf,
-            self.m_stderr_buf,
-        )
-        self.m_transport = MagicMock()
-        self.m_transport.getpeername.return_value = ('name', 22)
-        self.m_ssh.get_transport.return_value = self.m_transport
-        self.patcher_ssh = patch(
-            'teuthology.orchestra.connection.paramiko.SSHClient',
-            self.m_ssh,
-        )
-        self.patcher_ssh.start()
-        # Tests must start this if they wish to use it
-        # self.patcher_remote_proc.start()
-
-    def stop_patchers(self):
-        # If this patcher wasn't started, it's ok
-        try:
-            self.patcher_remote_proc.stop()
-        except RuntimeError:
-            pass
-        self.patcher_ssh.stop()
-
-    def test_exitstatus(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 0
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo', 'bar baz'],
-        )
-        assert proc.exitstatus == 0
-
-    def test_run_cwd(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 0
-        run.run(
-            client=self.m_ssh,
-            args=['foo_bar_baz'],
-            cwd='/cwd/test',
-        )
-        self.m_ssh.exec_command.assert_called_with('(cd /cwd/test && exec foo_bar_baz)')
-
-    def test_capture_stdout(self):
-        output = 'foo\nbar'
-        set_buffer_contents(self.m_stdout_buf, output)
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 0
-        stdout = BytesIO()
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo', 'bar baz'],
-            stdout=stdout,
-        )
-        assert proc.stdout is stdout
-        assert proc.stdout.read().decode() == output
-        assert proc.stdout.getvalue().decode() == output
-
-    def test_capture_stderr_newline(self):
-        output = 'foo\nbar\n'
-        set_buffer_contents(self.m_stderr_buf, output)
-        self.m_stderr_buf.channel.recv_exit_status.return_value = 0
-        stderr = BytesIO()
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo', 'bar baz'],
-            stderr=stderr,
-        )
-        assert proc.stderr is stderr
-        assert proc.stderr.read().decode() == output
-        assert proc.stderr.getvalue().decode() == output
-
-    def test_status_bad(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 42
-        with raises(CommandFailedError) as exc:
-            run.run(
-                client=self.m_ssh,
-                args=['foo'],
-            )
-        assert str(exc.value) == "Command failed on name with status 42: 'foo'"
-
-    def test_status_bad_nocheck(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 42
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            check_status=False,
-        )
-        assert proc.exitstatus == 42
-
-    def test_status_crash(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = -1
-        with raises(CommandCrashedError) as exc:
-            run.run(
-                client=self.m_ssh,
-                args=['foo'],
-            )
-        assert str(exc.value) == "Command crashed: 'foo'"
-
-    def test_status_crash_nocheck(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = -1
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            check_status=False,
-        )
-        assert proc.exitstatus == -1
-
-    def test_status_lost(self):
-        m_transport = MagicMock()
-        m_transport.getpeername.return_value = ('name', 22)
-        m_transport.is_active.return_value = False
-        self.m_stdout_buf.channel.recv_exit_status.return_value = -1
-        self.m_ssh.get_transport.return_value = m_transport
-        with raises(ConnectionLostError) as exc:
-            run.run(
-                client=self.m_ssh,
-                args=['foo'],
-            )
-        assert str(exc.value) == "SSH connection to name was lost: 'foo'"
-
-    def test_status_lost_socket(self):
-        m_transport = MagicMock()
-        m_transport.getpeername.side_effect = socket.error
-        self.m_ssh.get_transport.return_value = m_transport
-        with raises(ConnectionLostError) as exc:
-            run.run(
-                client=self.m_ssh,
-                args=['foo'],
-            )
-        assert str(exc.value) == "SSH connection was lost: 'foo'"
-
-    def test_status_lost_nocheck(self):
-        m_transport = MagicMock()
-        m_transport.getpeername.return_value = ('name', 22)
-        m_transport.is_active.return_value = False
-        self.m_stdout_buf.channel.recv_exit_status.return_value = -1
-        self.m_ssh.get_transport.return_value = m_transport
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            check_status=False,
-        )
-        assert proc.exitstatus == -1
-
-    def test_status_bad_nowait(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 42
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            wait=False,
-        )
-        with raises(CommandFailedError) as exc:
-            proc.wait()
-        assert proc.returncode == 42
-        assert str(exc.value) == "Command failed on name with status 42: 'foo'"
-
-    def test_stdin_pipe(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 0
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            stdin=run.PIPE,
-            wait=False
-        )
-        assert proc.poll() == 0
-        code = proc.wait()
-        assert code == 0
-        assert proc.exitstatus == 0
-
-    def test_stdout_pipe(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 0
-        lines = [b'one\n', b'two', b'']
-        set_buffer_contents(self.m_stdout_buf, lines)
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            stdout=run.PIPE,
-            wait=False
-        )
-        assert proc.poll() == 0
-        assert proc.stdout.readline() == lines[0]
-        assert proc.stdout.readline() == lines[1]
-        assert proc.stdout.readline() == lines[2]
-        code = proc.wait()
-        assert code == 0
-        assert proc.exitstatus == 0
-
-    def test_stderr_pipe(self):
-        self.m_stdout_buf.channel.recv_exit_status.return_value = 0
-        lines = [b'one\n', b'two', b'']
-        set_buffer_contents(self.m_stderr_buf, lines)
-        proc = run.run(
-            client=self.m_ssh,
-            args=['foo'],
-            stderr=run.PIPE,
-            wait=False
-        )
-        assert proc.poll() == 0
-        assert proc.stderr.readline() == lines[0]
-        assert proc.stderr.readline() == lines[1]
-        assert proc.stderr.readline() == lines[2]
-        code = proc.wait()
-        assert code == 0
-        assert proc.exitstatus == 0
-
-    def test_copy_and_close(self):
-        run.copy_and_close(None, MagicMock())
-        run.copy_and_close('', MagicMock())
-        run.copy_and_close(b'', MagicMock())
-
-
-class TestQuote(object):
-    def test_quote_simple(self):
-        got = run.quote(['a b', ' c', 'd e '])
-        assert got == "'a b' ' c' 'd e '"
-
-    def test_quote_and_quote(self):
-        got = run.quote(['echo', 'this && is embedded', '&&',
-                         'that was standalone'])
-        assert got == "echo 'this && is embedded' '&&' 'that was standalone'"
-
-    def test_quote_and_raw(self):
-        got = run.quote(['true', run.Raw('&&'), 'echo', 'yay'])
-        assert got == "true && echo yay"
-
-
-class TestRaw(object):
-    def test_eq(self):
-        str_ = "I am a raw something or other"
-        raw = run.Raw(str_)
-        assert raw == run.Raw(str_)

teuthology/orchestra/test/test_systemd.py

@@ -1,54 +0,0 @@
-import argparse
-import os
-
-from logging import debug
-from teuthology import misc
-from teuthology.orchestra import cluster
-from teuthology.orchestra.run import quote
-from teuthology.orchestra.daemon.group import DaemonGroup
-import subprocess
-
-
-class FakeRemote(object):
-    pass
-
-
-def test_pid():
-    ctx = argparse.Namespace()
-    ctx.daemons = DaemonGroup(use_systemd=True)
-    remote = FakeRemote()
-
-    ps_ef_output_path = os.path.join(
-        os.path.dirname(__file__),
-        "files/daemon-systemdstate-pid-ps-ef.output"
-    )
-
-    # patching ps -ef command output using a file
-    def sh(args):
-        args[0:2] = ["cat", ps_ef_output_path]
-        debug(args)
-        return subprocess.getoutput(quote(args))
-
-    remote.sh = sh
-    remote.init_system = 'systemd'
-    remote.shortname = 'host1'
-
-    ctx.cluster = cluster.Cluster(
-        remotes=[
-            (remote, ['rgw.0', 'mon.a', 'mgr.a', 'mds.a', 'osd.0'])
-        ],
-    )
-
-    for remote, roles in ctx.cluster.remotes.items():
-        for role in roles:
-            _, rol, id_ = misc.split_role(role)
-            if any(rol.startswith(x) for x in ['mon', 'mgr', 'mds']):
-                ctx.daemons.register_daemon(remote, rol, remote.shortname)
-            else:
-                ctx.daemons.register_daemon(remote, rol, id_)
-
-    for _, daemons in ctx.daemons.daemons.items():
-        for daemon in daemons.values():
-            pid = daemon.pid
-            debug(pid)
-            assert pid

teuthology/orchestra/test/util.py

@@ -1,12 +0,0 @@
-def assert_raises(excClass, callableObj, *args, **kwargs):
-    """
-    Like unittest.TestCase.assertRaises, but returns the exception.
-    """
-    try:
-        callableObj(*args, **kwargs)
-    except excClass as e:
-        return e
-    else:
-        if hasattr(excClass,'__name__'): excName = excClass.__name__
-        else: excName = str(excClass)
-        raise AssertionError("%s not raised" % excName)

teuthology/task/tests/__init__.py

@@ -1,110 +0,0 @@
-"""
-This task is used to integration test teuthology. Including this
-task in your yaml config will execute pytest which finds any tests in
-the current directory.  Each test that is discovered will be passed the
-teuthology ctx and config args that each teuthology task usually gets.
-This allows the tests to operate against the cluster.
-
-An example::
-
-    tasks
-      - tests:
-
-"""
-import logging
-import pytest
-
-
-log = logging.getLogger(__name__)
-
-
-@pytest.fixture
-def ctx():
-    return {}
-
-
-@pytest.fixture
-def config():
-    return []
-
-
-class TeuthologyContextPlugin(object):
-    def __init__(self, ctx, config):
-        self.ctx = ctx
-        self.config = config
-        self.failures = list()
-
-    # 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
-        metafunc.parametrize(["ctx", "config"], [(self.ctx, self.config),])
-
-    @pytest.mark.trylast
-    def pytest_configure(self, config):
-        # removes the default pytest TerminalReporter
-        # this fixes failures with scheduled jobs; when run by a worker
-        # there is no terminal to report to and pytest dies
-        standard_reporter = config.pluginmanager.getplugin('terminalreporter')
-        config.pluginmanager.unregister(standard_reporter)
-        log.info("removing pytest terminal reporter")
-
-    # log the outcome of each test
-    def pytest_runtest_makereport(self, __multicall__, item, call):
-        report = __multicall__.execute()
-
-        # after the test has been called, get it's report and log it
-        if call.when == 'call':
-            # item.location[0] is a slash delimeted path to the test file
-            # being ran. We only want the portion after teuthology.task.tests
-            test_path = item.location[0].replace("/", ".").split(".")
-            test_path = ".".join(test_path[4:-1])
-            # removes the string '[ctx0, config0]' after the test name
-            test_name = item.location[2].split("[")[0]
-            name = "{path}:{name}".format(path=test_path, name=test_name)
-            if report.passed:
-                log.info("{name} Passed".format(name=name))
-            elif report.skipped:
-                log.info("{name} {info}".format(
-                    name=name,
-                    info=call.excinfo.exconly()
-                ))
-            else:
-                # TODO: figure out a way to log the traceback
-                log.error("{name} Failed:\n {info}".format(
-                    name=name,
-                    info=call.excinfo.exconly()
-                ))
-                failure = "{name}: {err}".format(
-                    name=name,
-                    err=call.excinfo.exconly().replace("\n", "")
-                )
-                self.failures.append(failure)
-                self.ctx.summary['failure_reason'] = self.failures
-
-        return report
-
-
-def task(ctx, config):
-    """
-    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.
-    """
-    try:
-        status = pytest.main(
-            args=[
-                '-q',
-                '--pyargs', __name__
-            ],
-            plugins=[TeuthologyContextPlugin(ctx, config)]
-        )
-    except Exception:
-        log.exception("Saw failure running pytest")
-        ctx.summary["status"] = "dead"
-    else:
-        if status == 0:
-            log.info("OK. All tests passed!")
-            ctx.summary["status"] = "pass"
-        else:
-            log.error("FAIL. Saw test failures...")
-            ctx.summary["status"] = "fail"

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 StringIO 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=["python", "-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=["python", "-c", "assert False"],
-            )
-
-    def test_command_success(self, ctx, config):
-        result = StringIO()
-        ctx.cluster.run(
-            args=["python", "-c", "print('hi')"],
-            stdout=result
-        )
-        assert result.getvalue().strip() == "hi"

teuthology/test/fake_archive.py

@@ -1,107 +0,0 @@
-import os
-import shutil
-import yaml
-import random
-
-
-class FakeArchive(object):
-    def __init__(self, archive_base="./test_archive"):
-        self.archive_base = archive_base
-
-    def get_random_metadata(self, run_name, job_id=None, hung=False):
-        """
-        Generate a random info dict for a fake job. If 'hung' is not True, also
-        generate a summary dict.
-
-        :param run_name:   Run name e.g. 'test_foo'
-        :param job_id: Job ID e.g. '12345'
-        :param hung:   Simulate a hung job e.g. don't return a summary.yaml
-        :return:       A dict with keys 'job_id', 'info' and possibly
-                       'summary', with corresponding values
-        """
-        rand = random.Random()
-
-        description = 'description for job with id %s' % job_id
-        owner = 'job@owner'
-        duration = rand.randint(1, 36000)
-        pid = rand.randint(1000, 99999)
-        job_id = rand.randint(1, 99999)
-
-        info = {
-            'description': description,
-            'job_id': job_id,
-            'run_name': run_name,
-            'owner': owner,
-            'pid': pid,
-        }
-
-        metadata = {
-            'info': info,
-            'job_id': job_id,
-        }
-
-        if not hung:
-            success = True if rand.randint(0, 1) != 1 else False
-
-            summary = {
-                'description': description,
-                'duration': duration,
-                'owner': owner,
-                'success': success,
-            }
-
-            if not success:
-                summary['failure_reason'] = 'Failure reason!'
-            metadata['summary'] = summary
-
-        return metadata
-
-    def setup(self):
-        if os.path.exists(self.archive_base):
-            shutil.rmtree(self.archive_base)
-        os.mkdir(self.archive_base)
-
-    def teardown(self):
-        shutil.rmtree(self.archive_base)
-
-    def populate_archive(self, run_name, jobs):
-        run_archive_dir = os.path.join(self.archive_base, run_name)
-        os.mkdir(run_archive_dir)
-        for job in jobs:
-            archive_dir = os.path.join(run_archive_dir, str(job['job_id']))
-            os.mkdir(archive_dir)
-
-            with open(os.path.join(archive_dir, 'info.yaml'), 'w') as yfile:
-                yaml.safe_dump(job['info'], yfile)
-
-            if 'summary' in job:
-                summary_path = os.path.join(archive_dir, 'summary.yaml')
-                with open(summary_path, 'w') as yfile:
-                    yaml.safe_dump(job['summary'], yfile)
-
-    def create_fake_run(self, run_name, job_count, yaml_path, num_hung=0):
-        """
-        Creates a fake run using run_name. Uses the YAML specified for each
-        job's config.yaml
-
-        Returns a list of job_ids
-        """
-        assert os.path.exists(yaml_path)
-        assert job_count > 0
-        jobs = []
-        made_hung = 0
-        for i in range(job_count):
-            if made_hung < num_hung:
-                jobs.append(self.get_random_metadata(run_name, hung=True))
-                made_hung += 1
-            else:
-                jobs.append(self.get_random_metadata(run_name, hung=False))
-            #job_config = yaml.safe_load(yaml_path)
-        self.populate_archive(run_name, jobs)
-        for job in jobs:
-            job_id = job['job_id']
-            job_yaml_path = os.path.join(self.archive_base, run_name,
-                                         str(job_id), 'config.yaml')
-            shutil.copyfile(yaml_path, job_yaml_path)
-        return jobs
-