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

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?

teuthology/test/task/__init__.py

@@ -1,205 +0,0 @@
-from mock import patch, DEFAULT
-from pytest import raises
-
-from teuthology.config import FakeNamespace
-from teuthology.orchestra.cluster import Cluster
-from teuthology.orchestra.remote import Remote
-from teuthology.task import Task
-
-
-class TestTask(object):
-    klass = Task
-    task_name = 'task'
-
-    def setup(self):
-        self.ctx = FakeNamespace()
-        self.ctx.config = dict()
-        self.task_config = dict()
-
-    def test_overrides(self):
-        self.ctx.config['overrides'] = dict()
-        self.ctx.config['overrides'][self.task_name] = dict(
-            key_1='overridden',
-        )
-        self.task_config.update(dict(
-            key_1='default',
-            key_2='default',
-        ))
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                assert task.config['key_1'] == 'overridden'
-                assert task.config['key_2'] == 'default'
-
-    def test_hosts_no_filter(self):
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1'), ['role1'])
-        self.ctx.cluster.add(Remote('user@remote2'), ['role2'])
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task_hosts = list(task.cluster.remotes)
-                assert len(task_hosts) == 2
-                assert sorted(host.shortname for host in task_hosts) == \
-                    ['remote1', 'remote2']
-
-    def test_hosts_no_results(self):
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1'), ['role1'])
-        self.task_config.update(dict(
-            hosts=['role2'],
-        ))
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with raises(RuntimeError):
-                with self.klass(self.ctx, self.task_config):
-                    pass
-
-    def test_hosts_one_role(self):
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1'), ['role1'])
-        self.ctx.cluster.add(Remote('user@remote2'), ['role2'])
-        self.task_config.update(dict(
-            hosts=['role1'],
-        ))
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task_hosts = list(task.cluster.remotes)
-                assert len(task_hosts) == 1
-                assert task_hosts[0].shortname == 'remote1'
-
-    def test_hosts_two_roles(self):
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1'), ['role1'])
-        self.ctx.cluster.add(Remote('user@remote2'), ['role2'])
-        self.ctx.cluster.add(Remote('user@remote3'), ['role3'])
-        self.task_config.update(dict(
-            hosts=['role1', 'role3'],
-        ))
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task_hosts = list(task.cluster.remotes)
-                assert len(task_hosts) == 2
-                hostnames = [host.shortname for host in task_hosts]
-                assert sorted(hostnames) == ['remote1', 'remote3']
-
-    def test_hosts_two_hostnames(self):
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1.example.com'), ['role1'])
-        self.ctx.cluster.add(Remote('user@remote2.example.com'), ['role2'])
-        self.ctx.cluster.add(Remote('user@remote3.example.com'), ['role3'])
-        self.task_config.update(dict(
-            hosts=['remote1', 'remote2.example.com'],
-        ))
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task_hosts = list(task.cluster.remotes)
-                assert len(task_hosts) == 2
-                hostnames = [host.hostname for host in task_hosts]
-                assert sorted(hostnames) == ['remote1.example.com',
-                                             'remote2.example.com']
-
-    def test_hosts_one_role_one_hostname(self):
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1.example.com'), ['role1'])
-        self.ctx.cluster.add(Remote('user@remote2.example.com'), ['role2'])
-        self.ctx.cluster.add(Remote('user@remote3.example.com'), ['role3'])
-        self.task_config.update(dict(
-            hosts=['role1', 'remote2.example.com'],
-        ))
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task_hosts = list(task.cluster.remotes)
-                assert len(task_hosts) == 2
-                hostnames = [host.hostname for host in task_hosts]
-                assert sorted(hostnames) == ['remote1.example.com',
-                                             'remote2.example.com']
-
-    def test_setup_called(self):
-        with patch.multiple(
-            self.klass,
-            setup=DEFAULT,
-            begin=DEFAULT,
-            end=DEFAULT,
-            teardown=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task.setup.assert_called_once_with()
-
-    def test_begin_called(self):
-        with patch.multiple(
-            self.klass,
-            setup=DEFAULT,
-            begin=DEFAULT,
-            end=DEFAULT,
-            teardown=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                task.begin.assert_called_once_with()
-
-    def test_end_called(self):
-        self.task_config.update(dict())
-        with patch.multiple(
-            self.klass,
-            begin=DEFAULT,
-            end=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                pass
-            task.end.assert_called_once_with()
-
-    def test_teardown_called(self):
-        self.task_config.update(dict())
-        with patch.multiple(
-            self.klass,
-            setup=DEFAULT,
-            begin=DEFAULT,
-            end=DEFAULT,
-            teardown=DEFAULT,
-        ):
-            with self.klass(self.ctx, self.task_config) as task:
-                pass
-            task.teardown.assert_called_once_with()
-
-    def test_skip_teardown(self):
-        self.task_config.update(dict(
-            skip_teardown=True,
-        ))
-
-        def fake_teardown(self):
-            assert False
-
-        with patch.multiple(
-            self.klass,
-            setup=DEFAULT,
-            begin=DEFAULT,
-            end=DEFAULT,
-            teardown=fake_teardown,
-        ):
-            with self.klass(self.ctx, self.task_config):
-                pass