teuthology 1.0.0__py3-none-any.whl → 1.2.0__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/sentry.py

@@ -1,18 +0,0 @@
-import logging
-from raven import Client
-from teuthology.config import config
-
-log = logging.getLogger(__name__)
-
-client = None
-
-
-def get_client():
-    global client
-    if client:
-        return client
-
-    dsn = config.sentry_dsn
-    if dsn:
-        client = Client(dsn=dsn)
-        return client

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
-

teuthology/test/fake_fs.py

@@ -1,92 +0,0 @@
-from io import BytesIO
-from contextlib import closing
-
-
-try:
-     FileNotFoundError, NotADirectoryError
-except NameError:
-     FileNotFoundError = NotADirectoryError = OSError
-
-
-def make_fake_fstools(fake_filesystem):
-    """
-    Build fake versions of os.listdir(), os.isfile(), etc. for use in
-    unit tests
-
-    An example fake_filesystem value:
-        >>> fake_fs = {\
-            'a_directory': {\
-                'another_directory': {\
-                    'empty_file': None,\
-                    'another_empty_file': None,\
-                },\
-                'random_file': None,\
-                'yet_another_directory': {\
-                    'empty_directory': {},\
-                },\
-                'file_with_contents': 'data',\
-            },\
-        }
-        >>> fake_listdir, fake_isfile, _, _ = \
-                make_fake_fstools(fake_fs)
-        >>> fake_listdir('a_directory/yet_another_directory')
-        ['empty_directory']
-        >>> fake_isfile('a_directory/yet_another_directory')
-        False
-
-    :param fake_filesystem: A dict representing a filesystem
-    """
-    assert isinstance(fake_filesystem, dict)
-
-    def fake_listdir(path, fsdict=False):
-        if fsdict is False:
-            fsdict = fake_filesystem
-
-        remainder = path.strip('/') + '/'
-        subdict = fsdict
-        while '/' in remainder:
-            next_dir, remainder = remainder.split('/', 1)
-            if next_dir not in subdict:
-                raise FileNotFoundError(
-                    '[Errno 2] No such file or directory: %s' % next_dir)
-            subdict = subdict.get(next_dir)
-            if not isinstance(subdict, dict):
-                raise NotADirectoryError('[Errno 20] Not a directory: %s' % next_dir)
-            if subdict and not remainder:
-                return list(subdict)
-        return []
-
-    def fake_isfile(path, fsdict=False):
-        if fsdict is False:
-            fsdict = fake_filesystem
-
-        components = path.strip('/').split('/')
-        subdict = fsdict
-        for component in components:
-            if component not in subdict:
-                raise FileNotFoundError(
-                    '[Errno 2] No such file or directory: %s' % component)
-            subdict = subdict.get(component)
-        return subdict is None or isinstance(subdict, str)
-
-    def fake_isdir(path, fsdict=False):
-        return not fake_isfile(path)
-
-    def fake_exists(path, fsdict=False):
-        return fake_isfile(path, fsdict) or fake_isdir(path, fsdict)
-
-    def fake_open(path, mode=None, buffering=None):
-        components = path.strip('/').split('/')
-        subdict = fake_filesystem
-        for component in components:
-            if component not in subdict:
-                raise IOError(
-                    '[Errno 2] No such file or directory: %s' % component)
-            subdict = subdict.get(component)
-        if isinstance(subdict, dict):
-            raise IOError('[Errno 21] Is a directory: %s' % path)
-        elif subdict is None:
-            return closing(BytesIO(b''))
-        return closing(BytesIO(subdict.encode()))
-
-    return fake_exists, fake_listdir, fake_isfile, fake_isdir, fake_open

teuthology/test/integration/test_suite.py

@@ -1,86 +0,0 @@
-import os
-import requests
-from pytest import raises, skip
-
-from teuthology.config import config
-from teuthology import suite
-
-
-class TestSuiteOnline(object):
-    def setup(self):
-        if 'TEST_ONLINE' not in os.environ:
-            skip("To run these sets, set the environment variable TEST_ONLINE")
-
-    def test_ceph_hash_simple(self):
-        resp = requests.get(
-            'https://api.github.com/repos/ceph/ceph/git/refs/heads/master')
-        ref_hash = resp.json()['object']['sha']
-        assert suite.get_hash('ceph') == ref_hash
-
-    def test_kernel_hash_saya(self):
-        # We don't currently have these packages.
-        assert suite.get_hash('kernel', 'master', 'basic', 'saya') is None
-
-    def test_all_master_branches(self):
-        # Don't attempt to send email
-        config.results_email = None
-        job_config = suite.create_initial_config('suite', 'master',
-                                                 'master', 'master', 'testing',
-                                                 'basic', 'centos', 'plana')
-        assert ((job_config.branch, job_config.teuthology_branch,
-                 job_config.suite_branch) == ('master', 'master', 'master'))
-
-    def test_config_bogus_kernel_branch(self):
-        # Don't attempt to send email
-        config.results_email = None
-        with raises(suite.ScheduleFailError):
-            suite.create_initial_config('s', None, 'master', 't',
-                                        'bogus_kernel_branch', 'f', 'd', 'm')
-
-    def test_config_bogus_kernel_flavor(self):
-        # Don't attempt to send email
-        config.results_email = None
-        with raises(suite.ScheduleFailError):
-            suite.create_initial_config('s', None, 'master', 't', 'k',
-                                        'bogus_kernel_flavor', 'd', 'm')
-
-    def test_config_bogus_ceph_branch(self):
-        # Don't attempt to send email
-        config.results_email = None
-        with raises(suite.ScheduleFailError):
-            suite.create_initial_config('s', None, 'bogus_ceph_branch', 't',
-                                        'k', 'f', 'd', 'm')
-
-    def test_config_bogus_suite_branch(self):
-        # Don't attempt to send email
-        config.results_email = None
-        with raises(suite.ScheduleFailError):
-            suite.create_initial_config('s', 'bogus_suite_branch', 'master',
-                                        't', 'k', 'f', 'd', 'm')
-
-    def test_config_bogus_teuthology_branch(self):
-        # Don't attempt to send email
-        config.results_email = None
-        with raises(suite.ScheduleFailError):
-            suite.create_initial_config('s', None, 'master',
-                                        'bogus_teuth_branch', 'k', 'f', 'd',
-                                        'm')
-
-    def test_config_substitution(self):
-        # Don't attempt to send email
-        config.results_email = None
-        job_config = suite.create_initial_config('MY_SUITE', 'master',
-                                                 'master', 'master', 'testing',
-                                                 'basic', 'centos', 'plana')
-        assert job_config['suite'] == 'MY_SUITE'
-
-    def test_config_kernel_section(self):
-        # Don't attempt to send email
-        config.results_email = None
-        job_config = suite.create_initial_config('MY_SUITE', 'master',
-                                                 'master', 'master', 'testing',
-                                                 'basic', 'centos', 'plana')
-        assert job_config['kernel']['kdb'] is True
-
-
-# maybe use notario for the above?