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

teuthology/test/task/test_ceph_ansible.py

@@ -1,176 +0,0 @@
-from mock import patch, MagicMock
-from pytest import skip
-from teuthology.util.compat import PY3
-if PY3:
-    from io import StringIO as StringIO
-else:
-    from io import BytesIO as StringIO
-
-from teuthology.config import FakeNamespace
-from teuthology.orchestra.cluster import Cluster
-from teuthology.orchestra.remote import Remote
-from teuthology.task import ceph_ansible
-from teuthology.task.ceph_ansible import CephAnsible
-
-from teuthology.test.task import TestTask
-
-SKIP_IRRELEVANT = "Not relevant to this subclass"
-
-
-class TestCephAnsibleTask(TestTask):
-    klass = CephAnsible
-    task_name = 'ceph_ansible'
-
-    def setup(self):
-        self.ctx = FakeNamespace()
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1'), ['mon.0'])
-        self.ctx.cluster.add(Remote('user@remote2'), ['mds.0'])
-        self.ctx.cluster.add(Remote('user@remote3'), ['osd.0'])
-        self.ctx.summary = dict()
-        self.ctx.config = dict()
-        self.task_config = dict()
-        self.start_patchers()
-
-    def start_patchers(self):
-        m_fetch_repo = MagicMock()
-        m_fetch_repo.return_value = 'PATH'
-
-        def fake_get_scratch_devices(remote):
-            return ['/dev/%s' % remote.shortname]
-
-        self.patcher_get_scratch_devices = patch(
-            'teuthology.task.ceph_ansible.get_scratch_devices',
-            fake_get_scratch_devices,
-        )
-        self.patcher_get_scratch_devices.start()
-
-        self.patcher_teardown = patch(
-            'teuthology.task.ceph_ansible.CephAnsible.teardown',
-        )
-        self.patcher_teardown.start()
-
-        def fake_set_iface_and_cidr(self):
-            self._interface = 'eth0'
-            self._cidr = '172.21.0.0/20'
-
-        self.patcher_remote = patch.multiple(
-            Remote,
-            _set_iface_and_cidr=fake_set_iface_and_cidr,
-        )
-        self.patcher_remote.start()
-
-    def stop_patchers(self):
-        self.patcher_get_scratch_devices.stop()
-        self.patcher_remote.stop()
-        self.patcher_teardown.stop()
-
-    def test_playbook_none(self):
-        skip(SKIP_IRRELEVANT)
-
-    def test_inventory_none(self):
-        skip(SKIP_IRRELEVANT)
-
-    def test_inventory_path(self):
-        skip(SKIP_IRRELEVANT)
-
-    def test_inventory_etc(self):
-        skip(SKIP_IRRELEVANT)
-
-    def test_generate_hosts_file(self):
-        self.task_config.update(dict(
-            playbook=[],
-            vars=dict(
-                osd_auto_discovery=True,
-                monitor_interface='eth0',
-                radosgw_interface='eth0',
-                public_network='172.21.0.0/20',
-            ),
-        ))
-        task = self.klass(self.ctx, self.task_config)
-        hosts_file_path = '/my/hosts/file'
-        hosts_file_obj = StringIO()
-        hosts_file_obj.name = hosts_file_path
-        with patch.object(ceph_ansible, 'NamedTemporaryFile') as m_NTF:
-            m_NTF.return_value = hosts_file_obj
-            task.generate_hosts_file()
-            m_NTF.assert_called_once_with(prefix="teuth_ansible_hosts_",
-                                          mode='w+',
-                                          delete=False)
-        assert task.generated_inventory is True
-        assert task.inventory == hosts_file_path
-        hosts_file_obj.seek(0)
-        assert hosts_file_obj.read() == '\n'.join([
-            '[mdss]',
-            'remote2',
-            '',
-            '[mons]',
-            'remote1',
-            '',
-            '[osds]',
-            'remote3',
-        ])
-
-    def test_generate_hosts_file_with_devices(self):
-        self.task_config.update(dict(
-            playbook=[],
-            vars=dict(
-                monitor_interface='eth0',
-                radosgw_interface='eth0',
-                public_network='172.21.0.0/20',
-            ),
-        ))
-        task = self.klass(self.ctx, self.task_config)
-        hosts_file_path = '/my/hosts/file'
-        hosts_file_obj = StringIO()
-        hosts_file_obj.name = hosts_file_path
-        with patch.object(ceph_ansible, 'NamedTemporaryFile') as m_NTF:
-            m_NTF.return_value = hosts_file_obj
-            task.generate_hosts_file()
-            m_NTF.assert_called_once_with(prefix="teuth_ansible_hosts_",
-                                          mode='w+',
-                                          delete=False)
-        assert task.generated_inventory is True
-        assert task.inventory == hosts_file_path
-        hosts_file_obj.seek(0)
-        assert hosts_file_obj.read() == '\n'.join([
-            '[mdss]',
-            'remote2 devices=\'[]\'',
-            '',
-            '[mons]',
-            'remote1 devices=\'[]\'',
-            '',
-            '[osds]',
-            'remote3 devices=\'["/dev/remote3"]\'',
-        ])
-
-    def test_generate_hosts_file_with_network(self):
-        self.task_config.update(dict(
-            playbook=[],
-            vars=dict(
-                osd_auto_discovery=True,
-            ),
-        ))
-        task = self.klass(self.ctx, self.task_config)
-        hosts_file_path = '/my/hosts/file'
-        hosts_file_obj = StringIO()
-        hosts_file_obj.name = hosts_file_path
-        with patch.object(ceph_ansible, 'NamedTemporaryFile') as m_NTF:
-            m_NTF.return_value = hosts_file_obj
-            task.generate_hosts_file()
-            m_NTF.assert_called_once_with(prefix="teuth_ansible_hosts_",
-                                          mode='w+',
-                                          delete=False)
-        assert task.generated_inventory is True
-        assert task.inventory == hosts_file_path
-        hosts_file_obj.seek(0)
-        assert hosts_file_obj.read() == '\n'.join([
-            '[mdss]',
-            "remote2 monitor_interface='eth0' public_network='172.21.0.0/20' radosgw_interface='eth0'",
-            '',
-            '[mons]',
-            "remote1 monitor_interface='eth0' public_network='172.21.0.0/20' radosgw_interface='eth0'",
-            '',
-            '[osds]',
-            "remote3 monitor_interface='eth0' public_network='172.21.0.0/20' radosgw_interface='eth0'",
-        ])

teuthology/test/task/test_console_log.py

@@ -1,88 +0,0 @@
-import os
-
-from mock import patch
-
-from teuthology.config import FakeNamespace
-from teuthology.config import config as teuth_config
-from teuthology.orchestra.cluster import Cluster
-from teuthology.orchestra.remote import Remote
-from teuthology.task.console_log import ConsoleLog
-
-from teuthology.test.task import TestTask
-
-
-class TestConsoleLog(TestTask):
-    klass = ConsoleLog
-    task_name = 'console_log'
-
-    def setup(self):
-        teuth_config.ipmi_domain = 'ipmi.domain'
-        teuth_config.ipmi_user = 'ipmi_user'
-        teuth_config.ipmi_password = 'ipmi_pass'
-        self.ctx = FakeNamespace()
-        self.ctx.cluster = Cluster()
-        self.ctx.cluster.add(Remote('user@remote1'), ['role1'])
-        self.ctx.cluster.add(Remote('user@remote2'), ['role2'])
-        self.ctx.config = dict()
-        self.ctx.archive = '/fake/path'
-        self.task_config = dict()
-        self.start_patchers()
-
-    def start_patchers(self):
-        self.patchers = dict()
-        self.patchers['makedirs'] = patch(
-            'teuthology.task.console_log.os.makedirs',
-        )
-        self.patchers['is_vm'] = patch(
-            'teuthology.lock.query.is_vm',
-        )
-        self.patchers['is_vm'].return_value = False
-        self.patchers['get_status'] = patch(
-            'teuthology.lock.query.get_status',
-        )
-        self.mocks = dict()
-        for name, patcher in self.patchers.items():
-            self.mocks[name] = patcher.start()
-        self.mocks['is_vm'].return_value = False
-
-    def teardown(self):
-        for patcher in self.patchers.values():
-            patcher.stop()
-
-    def test_enabled(self):
-        task = self.klass(self.ctx, self.task_config)
-        assert task.enabled is True
-
-    def test_disabled_noarchive(self):
-        self.ctx.archive = None
-        task = self.klass(self.ctx, self.task_config)
-        assert task.enabled is False
-
-    def test_has_ipmi_credentials(self):
-        for remote in self.ctx.cluster.remotes.keys():
-            remote.console.has_ipmi_credentials = False
-            remote.console.has_conserver = False
-        task = self.klass(self.ctx, self.task_config)
-        assert len(task.cluster.remotes.keys()) == 0
-
-    def test_remotes(self):
-        with self.klass(self.ctx, self.task_config) as task:
-            assert len(task.cluster.remotes) == len(self.ctx.cluster.remotes)
-
-    @patch('teuthology.orchestra.console.PhysicalConsole')
-    def test_begin(self, m_pconsole):
-        with self.klass(self.ctx, self.task_config) as task:
-            assert len(task.processes) == len(self.ctx.cluster.remotes)
-            for remote in task.cluster.remotes.keys():
-                dest_path = os.path.join(
-                    self.ctx.archive, '%s.log' % remote.shortname)
-                assert remote.console.spawn_sol_log.called_once_with(
-                    dest_path=dest_path)
-
-    @patch('teuthology.orchestra.console.PhysicalConsole')
-    def test_end(self, m_pconsole):
-        with self.klass(self.ctx, self.task_config) as task:
-            pass
-        for proc in task.processes.values():
-            assert proc.terminate.called_once_with()
-            assert proc.kill.called_once_with()

teuthology/test/task/test_install.py

@@ -1,337 +0,0 @@
-import os
-import pytest
-import yaml
-
-from mock import patch, Mock
-
-from teuthology.task import install
-
-
-class TestInstall(object):
-
-    def _get_default_package_list(self, project='ceph', debug=False):
-        path = os.path.join(
-            os.path.dirname(__file__),
-            '..', '..', 'task', 'install', 'packages.yaml',
-        )
-        pkgs = yaml.safe_load(open(path))[project]
-        if not debug:
-            pkgs['deb'] = [p for p in pkgs['deb']
-                                        if not p.endswith('-dbg')]
-            pkgs['rpm'] = [p for p in pkgs['rpm']
-                                        if not p.endswith('-debuginfo')]
-        return pkgs
-
-    def test_get_package_list_debug(self):
-        default_pkgs = self._get_default_package_list(debug=True)
-        default_pkgs['rpm'].sort()
-        default_pkgs['deb'].sort()
-        config = dict(debuginfo=True)
-        result = install.get_package_list(ctx=None, config=config)
-        result['rpm'].sort()
-        result['deb'].sort()
-        assert result == default_pkgs
-
-    def test_get_package_list_no_debug(self):
-        default_pkgs = self._get_default_package_list(debug=False)
-        default_pkgs['rpm'].sort()
-        default_pkgs['deb'].sort()
-        config = dict(debuginfo=False)
-        result = install.get_package_list(ctx=None, config=config)
-        result['rpm'].sort()
-        result['deb'].sort()
-        assert result == default_pkgs
-
-    def test_get_package_list_custom_rpm(self):
-        default_pkgs = self._get_default_package_list(debug=False)
-        default_pkgs['rpm'].sort()
-        default_pkgs['deb'].sort()
-        rpms = ['rpm1', 'rpm2', 'rpm2-debuginfo']
-        config = dict(packages=dict(rpm=rpms))
-        result = install.get_package_list(ctx=None, config=config)
-        result['rpm'].sort()
-        result['deb'].sort()
-        assert result['rpm'] == ['rpm1', 'rpm2']
-        assert result['deb'] == default_pkgs['deb']
-
-    @patch("teuthology.task.install._get_builder_project")
-    @patch("teuthology.task.install.packaging.get_package_version")
-    def test_get_upgrade_version(self, m_get_package_version,
-                                         m_gitbuilder_project):
-        gb = Mock()
-        gb.version = "11.0.0"
-        gb.project = "ceph"
-        m_gitbuilder_project.return_value = gb
-        m_get_package_version.return_value = "11.0.0"
-        install.get_upgrade_version(Mock(), Mock(), Mock())
-
-    @patch("teuthology.task.install._get_builder_project")
-    @patch("teuthology.task.install.packaging.get_package_version")
-    def test_verify_ceph_version_success(self, m_get_package_version,
-                                         m_gitbuilder_project):
-        gb = Mock()
-        gb.version = "0.89.0"
-        gb.project = "ceph"
-        m_gitbuilder_project.return_value = gb
-        m_get_package_version.return_value = "0.89.0"
-        config = dict()
-        install.verify_package_version(Mock(), config, Mock())
-
-    @patch("teuthology.task.install._get_builder_project")
-    @patch("teuthology.task.install.packaging.get_package_version")
-    def test_verify_ceph_version_failed(self, m_get_package_version,
-                                        m_gitbuilder_project):
-        gb = Mock()
-        gb.version = "0.89.0"
-        gb.project = "ceph"
-        m_gitbuilder_project.return_value = gb
-        m_get_package_version.return_value = "0.89.1"
-        config = dict()
-        with pytest.raises(RuntimeError):
-            install.verify_package_version(Mock(), config, Mock())
-
-    @patch("teuthology.task.install._get_builder_project")
-    @patch("teuthology.task.install.packaging.get_package_version")
-    def test_skip_when_using_ceph_deploy(self, m_get_package_version,
-                                         m_gitbuilder_project):
-        gb = Mock()
-        gb.version = "0.89.0"
-        gb.project = "ceph"
-        m_gitbuilder_project.return_value = gb
-        # ceph isn't installed because ceph-deploy would install it
-        m_get_package_version.return_value = None
-        config = dict()
-        config['extras'] = True
-        install.verify_package_version(Mock(), config, Mock())
-
-    def test_get_flavor_default(self):
-        config = dict()
-        assert install.get_flavor(config) == 'basic'
-
-    def test_get_flavor_simple(self):
-        config = dict(
-            flavor='notcmalloc'
-        )
-        assert install.get_flavor(config) == 'notcmalloc'
-
-    def test_get_flavor_valgrind(self):
-        config = dict(
-            valgrind=True
-        )
-        assert install.get_flavor(config) == 'notcmalloc'
-
-    def test_upgrade_is_downgrade(self):
-        assert_ok_vals = [
-            ('9.0.0', '10.0.0'),
-            ('10.2.2-63-g8542898-1trusty', '10.2.2-64-gabcdef1-1trusty'),
-            ('11.0.0-918.g13c13c7', '11.0.0-2165.gabcdef1')
-        ]
-        for t in assert_ok_vals:
-            assert install._upgrade_is_downgrade(t[0], t[1]) == False
-
-    @patch("teuthology.packaging.get_package_version")
-    @patch("teuthology.misc.get_system_type")
-    @patch("teuthology.task.install.verify_package_version")
-    @patch("teuthology.task.install.get_upgrade_version")
-    def test_upgrade_common(self,
-                            m_get_upgrade_version,
-                            m_verify_package_version,
-                            m_get_system_type,
-                            m_get_package_version):
-        expected_system_type = 'deb'
-        def make_remote():
-            remote = Mock()
-            remote.arch = 'x86_64'
-            remote.os = Mock()
-            remote.os.name = 'ubuntu'
-            remote.os.version = '14.04'
-            remote.os.codename = 'trusty'
-            remote.system_type = expected_system_type
-            return remote
-        ctx = Mock()
-        class cluster:
-            remote1 = make_remote()
-            remote2 = make_remote()
-            remotes = {
-                remote1: ['client.0'],
-                remote2: ['mon.a','osd.0'],
-            }
-            def only(self, role):
-                result = Mock()
-                if role in ('client.0',):
-                    result.remotes = { cluster.remote1: None }
-                if role in ('osd.0', 'mon.a'):
-                    result.remotes = { cluster.remote2: None }
-                return result
-        ctx.cluster = cluster()
-        config = {
-            'client.0': {
-                'sha1': 'expectedsha1',
-            },
-        }
-        ctx.config = {
-            'roles': [ ['client.0'], ['mon.a','osd.0'] ],
-            'tasks': [
-                {
-                    'install.upgrade': config,
-                },
-            ],
-        }
-        m_get_upgrade_version.return_value = "11.0.0"
-        m_get_package_version.return_value = "10.2.4"
-        m_get_system_type.return_value = "deb"
-        def upgrade(ctx, node, remote, pkgs, system_type):
-            assert system_type == expected_system_type
-        assert install.upgrade_common(ctx, config, upgrade) == 1
-        expected_config = {
-            'project': 'ceph',
-            'sha1': 'expectedsha1',
-        }
-        m_verify_package_version.assert_called_with(ctx,
-                                                    expected_config,
-                                                    cluster.remote1)
-    def test_upgrade_remote_to_config(self):
-        expected_system_type = 'deb'
-        def make_remote():
-            remote = Mock()
-            remote.arch = 'x86_64'
-            remote.os = Mock()
-            remote.os.name = 'ubuntu'
-            remote.os.version = '14.04'
-            remote.os.codename = 'trusty'
-            remote.system_type = expected_system_type
-            return remote
-        ctx = Mock()
-        class cluster:
-            remote1 = make_remote()
-            remote2 = make_remote()
-            remotes = {
-                remote1: ['client.0'],
-                remote2: ['mon.a','osd.0'],
-            }
-            def only(self, role):
-                result = Mock()
-                if role in ('client.0',):
-                    result.remotes = { cluster.remote1: None }
-                elif role in ('osd.0', 'mon.a'):
-                    result.remotes = { cluster.remote2: None }
-                else:
-                    result.remotes = None
-                return result
-        ctx.cluster = cluster()
-        ctx.config = {
-            'roles': [ ['client.0'], ['mon.a','osd.0'] ],
-        }
-
-        # nothing -> nothing
-        assert install.upgrade_remote_to_config(ctx, {}) == {}
-
-        # select the remote for the osd.0 role
-        # the 'ignored' role does not exist and is ignored
-        # the remote for mon.a is the same as for osd.0 and
-        # is silently ignored (actually it could be the other
-        # way around, depending on how the keys are hashed)
-        config = {
-            'osd.0': {
-                'sha1': 'expectedsha1',
-            },
-            'ignored': None,
-            'mon.a': {
-                'sha1': 'expectedsha1',
-            },
-        }
-        expected_config = {
-            cluster.remote2: {
-                'project': 'ceph',
-                'sha1': 'expectedsha1',
-            },
-        }
-        assert install.upgrade_remote_to_config(ctx, config) == expected_config
-
-        # select all nodes, regardless
-        config = {
-            'all': {
-                'sha1': 'expectedsha1',
-            },
-        }
-        expected_config = {
-            cluster.remote1: {
-                'project': 'ceph',
-                'sha1': 'expectedsha1',
-            },
-            cluster.remote2: {
-                'project': 'ceph',
-                'sha1': 'expectedsha1',
-            },
-        }
-        assert install.upgrade_remote_to_config(ctx, config) == expected_config
-
-        # verify that install overrides are used as default
-        # values for the upgrade task, not as override
-        ctx.config['overrides'] = {
-            'install': {
-                'ceph': {
-                    'sha1': 'overridesha1',
-                    'tag': 'overridetag',
-                    'branch': 'overridebranch',
-                },
-            },
-        }
-        config = {
-            'client.0': {
-                'sha1': 'expectedsha1',
-            },
-            'osd.0': {
-            },
-        }
-        expected_config = {
-            cluster.remote1: {
-                'project': 'ceph',
-                'sha1': 'expectedsha1',
-            },
-            cluster.remote2: {
-                'project': 'ceph',
-                'sha1': 'overridesha1',
-                'tag': 'overridetag',
-                'branch': 'overridebranch',
-            },
-        }
-        assert install.upgrade_remote_to_config(ctx, config) == expected_config
-
-
-    @patch("teuthology.task.install.packaging.get_package_version")
-    @patch("teuthology.task.install.redhat.set_deb_repo")
-    def test_rh_install_deb_pkgs(self, m_set_rh_deb_repo, m_get_pkg_version):
-        ctx = Mock()
-        remote = Mock()
-        version = '1.3.2'
-        rh_ds_yaml = dict()
-        rh_ds_yaml = {
-            'versions': {'deb': {'mapped': {'1.3.2': '0.94.5'}}},
-            'pkgs': {'deb': ['pkg1', 'pkg2']},
-            'extra_system_packages': {'deb': ['es_pkg1', 'es_pkg2']},
-            'extra_packages': {'deb': ['e_pkg1', 'e_pkg2']},
-        }
-        m_get_pkg_version.return_value = "0.94.5"
-        install.redhat.install_deb_pkgs(ctx, remote, version, rh_ds_yaml)
-
-    @patch("teuthology.task.install.packaging.get_package_version")
-    def test_rh_install_pkgs(self, m_get_pkg_version):
-        ctx = Mock()
-        remote = Mock()
-        version = '1.3.2'
-        rh_ds_yaml = dict()
-        rh_ds_yaml = {
-            'versions': {'rpm': {'mapped': {'1.3.2': '0.94.5',
-                                            '1.3.1': '0.94.3'}}},
-            'pkgs': {'rpm': ['pkg1', 'pkg2']},
-            'extra_system_packages': {'rpm': ['es_pkg1', 'es_pkg2']},
-            'extra_packages': {'rpm': ['e_pkg1', 'e_pkg2']},
-        }
-
-        m_get_pkg_version.return_value = "0.94.5"
-        install.redhat.install_pkgs(ctx, remote, version, rh_ds_yaml)
-        version = '1.3.1'
-        with pytest.raises(RuntimeError) as e:
-            install.redhat.install_pkgs(ctx, remote, version, rh_ds_yaml)
-        assert "Version check failed" in str(e)

teuthology/test/task/test_internal.py

@@ -1,57 +0,0 @@
-from teuthology.config import FakeNamespace
-from teuthology.task import internal
-
-
-class TestInternal(object):
-    def setup(self):
-        self.ctx = FakeNamespace()
-        self.ctx.config = dict()
-
-    def test_buildpackages_prep(self):
-        #
-        # no buildpackages nor install tasks
-        #
-        self.ctx.config = { 'tasks': [] }
-        assert internal.buildpackages_prep(self.ctx,
-                                           self.ctx.config) == internal.BUILDPACKAGES_NOTHING
-        #
-        # make the buildpackages tasks the first to run
-        #
-        self.ctx.config = {
-            'tasks': [ { 'atask': None },
-                       { 'internal.buildpackages_prep': None },
-                       { 'btask': None },
-                       { 'install': None },
-                       { 'buildpackages': None } ],
-        }
-        assert internal.buildpackages_prep(self.ctx,
-                                           self.ctx.config) == internal.BUILDPACKAGES_FIRST
-        assert self.ctx.config == {
-            'tasks': [ { 'atask': None },
-                       { 'internal.buildpackages_prep': None },
-                       { 'buildpackages': None },
-                       { 'btask': None },
-                       { 'install': None } ],
-        }
-        #
-        # the buildpackages task already the first task to run
-        #
-        assert internal.buildpackages_prep(self.ctx,
-                                           self.ctx.config) == internal.BUILDPACKAGES_OK
-        #
-        # no buildpackages task
-        #
-        self.ctx.config = {
-            'tasks': [ { 'install': None } ],
-        }
-        assert internal.buildpackages_prep(self.ctx,
-                                           self.ctx.config) == internal.BUILDPACKAGES_NOTHING
-        #
-        # no install task: the buildpackages task must be removed
-        #
-        self.ctx.config = {
-            'tasks': [ { 'buildpackages': None } ],
-        }
-        assert internal.buildpackages_prep(self.ctx,
-                                           self.ctx.config) == internal.BUILDPACKAGES_REMOVED
-        assert self.ctx.config == {'tasks': []}