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

teuthology/orchestra/test/integration/test_integration.py

@@ -1,94 +0,0 @@
-from teuthology.orchestra import monkey
-monkey.patch_all()
-
-from io import StringIO
-
-import os
-from teuthology.orchestra import connection, remote, run
-from teuthology.orchestra.test.util import assert_raises
-from teuthology.exceptions import CommandCrashedError, ConnectionLostError
-
-from pytest import skip
-
-HOST = None
-
-
-class TestIntegration():
-    def setup(self):
-        try:
-            host = os.environ['ORCHESTRA_TEST_HOST']
-        except KeyError:
-            skip('To run integration tests, set environment ' +
-                 'variable ORCHESTRA_TEST_HOST to user@host to use.')
-        global HOST
-        HOST = host
-
-    def test_crash(self):
-        ssh = connection.connect(HOST)
-        e = assert_raises(
-            CommandCrashedError,
-            run.run,
-            client=ssh,
-            args=['sh', '-c', 'kill -ABRT $$'],
-            )
-        assert e.command == "sh -c 'kill -ABRT $$'"
-        assert str(e) == "Command crashed: \"sh -c 'kill -ABRT $$'\""
-
-    def test_lost(self):
-        ssh = connection.connect(HOST)
-        e = assert_raises(
-            ConnectionLostError,
-            run.run,
-            client=ssh,
-            args=['sh', '-c', 'kill -ABRT $PPID'],
-            name=HOST,
-            )
-        assert e.command == "sh -c 'kill -ABRT $PPID'"
-        assert str(e) == \
-            "SSH connection to {host} was lost: ".format(host=HOST) + \
-            "\"sh -c 'kill -ABRT $PPID'\""
-
-    def test_pipe(self):
-        ssh = connection.connect(HOST)
-        r = run.run(
-            client=ssh,
-            args=['cat'],
-            stdin=run.PIPE,
-            stdout=StringIO(),
-            wait=False,
-            )
-        assert r.stdout.getvalue() == ''
-        r.stdin.write('foo\n')
-        r.stdin.write('bar\n')
-        r.stdin.close()
-
-        r.wait()
-        got = r.exitstatus
-        assert got == 0
-        assert r.stdout.getvalue() == 'foo\nbar\n'
-
-    def test_and(self):
-        ssh = connection.connect(HOST)
-        r = run.run(
-            client=ssh,
-            args=['true', run.Raw('&&'), 'echo', 'yup'],
-            stdout=StringIO(),
-            )
-        assert r.stdout.getvalue() == 'yup\n'
-
-    def test_os(self):
-        rem = remote.Remote(HOST)
-        assert rem.os.name
-        assert rem.os.version
-
-    def test_17102(self, caplog):
-        # http://tracker.ceph.com/issues/17102
-        rem = remote.Remote(HOST)
-        interval = 3
-        rem.run(args="echo before; sleep %s; echo after" % interval)
-        for record in caplog.records:
-            if record.msg == 'before':
-                before_time = record.created
-            elif record.msg == 'after':
-                after_time = record.created
-        assert int(round(after_time - before_time)) == interval

teuthology/orchestra/test/test_cluster.py

@@ -1,240 +0,0 @@
-import fudge
-import pytest
-
-from mock import patch, Mock
-
-from teuthology.orchestra import cluster, remote
-
-
-class TestCluster(object):
-    @fudge.with_fakes
-    def test_init_empty(self):
-        fudge.clear_expectations()
-        c = cluster.Cluster()
-        assert c.remotes == {}
-
-    @fudge.with_fakes
-    def test_init(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('Remote')
-        r2 = fudge.Fake('Remote')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['baz']),
-                ],
-            )
-        r3 = fudge.Fake('Remote')
-        c.add(r3, ['xyzzy', 'thud', 'foo'])
-        assert c.remotes == {
-            r1: ['foo', 'bar'],
-            r2: ['baz'],
-            r3: ['xyzzy', 'thud', 'foo'],
-        }
-
-    @fudge.with_fakes
-    def test_repr(self):
-        fudge.clear_expectations()
-        r1 = remote.Remote('r1', ssh=fudge.Fake('SSH'))
-        r2 = remote.Remote('r2', ssh=fudge.Fake('SSH'))
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['baz']),
-                ],
-            )
-        assert repr(c) == "Cluster(remotes=[[Remote(name='r1'), ['foo', 'bar']], [Remote(name='r2'), ['baz']]])" # noqa
-
-    @fudge.with_fakes
-    def test_str(self):
-        fudge.clear_expectations()
-        r1 = remote.Remote('r1', ssh=fudge.Fake('SSH'))
-        r2 = remote.Remote('r2', ssh=fudge.Fake('SSH'))
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['baz']),
-                ],
-            )
-        assert str(c) == "r1[foo,bar] r2[baz]"
-
-    @fudge.with_fakes
-    def test_run_all(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('Remote').has_attr(name='r1')
-        ret1 = fudge.Fake('RemoteProcess')
-        r1.expects('run').with_args(args=['test']).returns(ret1)
-        r2 = fudge.Fake('Remote').has_attr(name='r2')
-        ret2 = fudge.Fake('RemoteProcess')
-        r2.expects('run').with_args(args=['test']).returns(ret2)
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['baz']),
-                ],
-            )
-        got = c.run(args=['test'])
-        assert len(got) == 2
-        assert got, [ret1 == ret2]
-        # check identity not equality
-        assert got[0] is ret1
-        assert got[1] is ret2
-
-    @fudge.with_fakes
-    def test_only_one(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_foo = c.only('foo')
-        assert c_foo.remotes == {r1: ['foo', 'bar'], r3: ['foo']}
-
-    @fudge.with_fakes
-    def test_only_two(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_both = c.only('foo', 'bar')
-        assert c_both.remotes, {r1: ['foo' == 'bar']}
-
-    @fudge.with_fakes
-    def test_only_none(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_none = c.only('impossible')
-        assert c_none.remotes == {}
-
-    @fudge.with_fakes
-    def test_only_match(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_foo = c.only('foo', lambda role: role.startswith('b'))
-        assert c_foo.remotes, {r1: ['foo' == 'bar']}
-
-    @fudge.with_fakes
-    def test_exclude_one(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_foo = c.exclude('foo')
-        assert c_foo.remotes == {r2: ['bar']}
-
-    @fudge.with_fakes
-    def test_exclude_two(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_both = c.exclude('foo', 'bar')
-        assert c_both.remotes == {r2: ['bar'], r3: ['foo']}
-
-    @fudge.with_fakes
-    def test_exclude_none(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_none = c.exclude('impossible')
-        assert c_none.remotes == {r1: ['foo', 'bar'], r2: ['bar'], r3: ['foo']}
-
-    @fudge.with_fakes
-    def test_exclude_match(self):
-        fudge.clear_expectations()
-        r1 = fudge.Fake('r1')
-        r2 = fudge.Fake('r2')
-        r3 = fudge.Fake('r3')
-        c = cluster.Cluster(
-            remotes=[
-                (r1, ['foo', 'bar']),
-                (r2, ['bar']),
-                (r3, ['foo']),
-                ],
-            )
-        c_foo = c.exclude('foo', lambda role: role.startswith('b'))
-        assert c_foo.remotes == {r2: ['bar'], r3: ['foo']}
-
-
-class TestWriteFile(object):
-    """ Tests for cluster.write_file """
-    def setup(self):
-        self.r1 = remote.Remote('r1', ssh=Mock())
-        self.c = cluster.Cluster(
-            remotes=[
-                (self.r1, ['foo', 'bar']),
-            ],
-        )
-
-    @patch("teuthology.misc.write_file")
-    def test_write_file(self, m_write_file):
-        self.c.write_file("filename", "content")
-        m_write_file.assert_called_with(self.r1, "filename", "content")
-
-    @patch("teuthology.misc.write_file")
-    def test_fails_with_invalid_perms(self, m_write_file):
-        with pytest.raises(ValueError):
-            self.c.write_file("filename", "content", sudo=False, perms="invalid")
-
-    @patch("teuthology.misc.write_file")
-    def test_fails_with_invalid_owner(self, m_write_file):
-        with pytest.raises(ValueError):
-            self.c.write_file("filename", "content", sudo=False, owner="invalid")
-
-    @patch("teuthology.misc.sudo_write_file")
-    def test_with_sudo(self, m_sudo_write_file):
-        self.c.write_file("filename", "content", sudo=True)
-        m_sudo_write_file.assert_called_with(self.r1, "filename", "content", owner=None, perms=None)

teuthology/orchestra/test/test_connection.py

@@ -1,106 +0,0 @@
-import fudge
-
-from teuthology import config
-from teuthology.orchestra import connection
-from teuthology.orchestra.test.util import assert_raises
-
-
-class TestConnection(object):
-    def setup(self):
-        import time
-        time.sleep = lambda s: True
-
-    def clear_config(self):
-        config.config.teuthology_yaml = ''
-        config.config.load()
-
-    def test_split_user_just_host(self):
-        got = connection.split_user('somehost.example.com')
-        assert got == (None, 'somehost.example.com')
-
-    def test_split_user_both(self):
-        got = connection.split_user('jdoe@somehost.example.com')
-        assert got == ('jdoe', 'somehost.example.com')
-
-    def test_split_user_empty_user(self):
-        s = '@somehost.example.com'
-        e = assert_raises(AssertionError, connection.split_user, s)
-        assert str(e) == 'Bad input to split_user: {s!r}'.format(s=s)
-
-    @fudge.with_fakes
-    def test_connect(self):
-        self.clear_config()
-        config.config.verify_host_keys = True
-        fudge.clear_expectations()
-        ssh = fudge.Fake('SSHClient')
-        ssh.expects_call().with_args().returns(ssh)
-        ssh.expects('set_missing_host_key_policy')
-        ssh.expects('load_system_host_keys').with_args()
-        ssh.expects('connect').with_args(
-            hostname='orchestra.test.newdream.net.invalid',
-            username='jdoe',
-            timeout=60,
-        )
-        transport = ssh.expects('get_transport').with_args().returns_fake()
-        transport.remember_order()
-        transport.expects('set_keepalive').with_args(False)
-        got = connection.connect(
-            'jdoe@orchestra.test.newdream.net.invalid',
-            _SSHClient=ssh,
-        )
-        assert got is ssh
-
-    @fudge.with_fakes
-    def test_connect_no_verify_host_keys(self):
-        self.clear_config()
-        config.config.verify_host_keys = False
-        fudge.clear_expectations()
-        ssh = fudge.Fake('SSHClient')
-        ssh.expects_call().with_args().returns(ssh)
-        ssh.expects('set_missing_host_key_policy')
-        ssh.expects('connect').with_args(
-            hostname='orchestra.test.newdream.net.invalid',
-            username='jdoe',
-            timeout=60,
-        )
-        transport = ssh.expects('get_transport').with_args().returns_fake()
-        transport.remember_order()
-        transport.expects('set_keepalive').with_args(False)
-        got = connection.connect(
-            'jdoe@orchestra.test.newdream.net.invalid',
-            _SSHClient=ssh,
-        )
-        assert got is ssh
-
-    @fudge.with_fakes
-    def test_connect_override_hostkeys(self):
-        self.clear_config()
-        fudge.clear_expectations()
-        sshclient = fudge.Fake('SSHClient')
-        ssh = sshclient.expects_call().with_args().returns_fake()
-        ssh.remember_order()
-        host_keys = fudge.Fake('HostKeys')
-        host_keys.expects('add').with_args(
-            hostname='orchestra.test.newdream.net.invalid',
-            keytype='ssh-rsa',
-            key='frobnitz',
-            )
-        ssh.expects('get_host_keys').with_args().returns(host_keys)
-        ssh.expects('connect').with_args(
-            hostname='orchestra.test.newdream.net.invalid',
-            username='jdoe',
-            timeout=60,
-            )
-        transport = ssh.expects('get_transport').with_args().returns_fake()
-        transport.remember_order()
-        transport.expects('set_keepalive').with_args(False)
-        create_key = fudge.Fake('create_key')
-        create_key.expects_call().with_args('ssh-rsa',
-                                            'testkey').returns('frobnitz')
-        got = connection.connect(
-            'jdoe@orchestra.test.newdream.net.invalid',
-            host_key='ssh-rsa testkey',
-            _SSHClient=sshclient,
-            _create_key=create_key,
-            )
-        assert got is ssh

teuthology/orchestra/test/test_console.py

@@ -1,217 +0,0 @@
-from mock import patch
-
-from teuthology.config import config as teuth_config
-
-from teuthology.orchestra import console
-
-
-class TestConsole(object):
-    pass
-
-
-class TestPhysicalConsole(TestConsole):
-    klass = console.PhysicalConsole
-    ipmi_cmd_templ = 'ipmitool -H {h}.{d} -I lanplus -U {u} -P {p} {c}'
-    conserver_cmd_templ = 'console -M {m} -p {p} {mode} {h}'
-
-    def setup(self):
-        self.hostname = 'host'
-        teuth_config.ipmi_domain = 'ipmi_domain'
-        teuth_config.ipmi_user = 'ipmi_user'
-        teuth_config.ipmi_password = 'ipmi_pass'
-        teuth_config.conserver_master = 'conserver_master'
-        teuth_config.conserver_port = 3109
-        teuth_config.use_conserver = True
-
-    def test_has_ipmi_creds(self):
-        cons = self.klass(self.hostname)
-        assert cons.has_ipmi_credentials is True
-        teuth_config.ipmi_domain = None
-        cons = self.klass(self.hostname)
-        assert cons.has_ipmi_credentials is False
-
-    def test_console_command_conserver(self):
-        cons = self.klass(
-            self.hostname,
-            teuth_config.ipmi_user,
-            teuth_config.ipmi_password,
-            teuth_config.ipmi_domain,
-        )
-        cons.has_conserver = True
-        console_cmd = cons._console_command()
-        assert console_cmd == self.conserver_cmd_templ.format(
-            m=teuth_config.conserver_master,
-            p=teuth_config.conserver_port,
-            mode='-s',
-            h=self.hostname,
-        )
-        console_cmd = cons._console_command(readonly=False)
-        assert console_cmd == self.conserver_cmd_templ.format(
-            m=teuth_config.conserver_master,
-            p=teuth_config.conserver_port,
-            mode='-f',
-            h=self.hostname,
-        )
-
-    def test_console_command_ipmi(self):
-        teuth_config.conserver_master = None
-        cons = self.klass(
-            self.hostname,
-            teuth_config.ipmi_user,
-            teuth_config.ipmi_password,
-            teuth_config.ipmi_domain,
-        )
-        sol_cmd = cons._console_command()
-        assert sol_cmd == self.ipmi_cmd_templ.format(
-            h=self.hostname,
-            d=teuth_config.ipmi_domain,
-            u=teuth_config.ipmi_user,
-            p=teuth_config.ipmi_password,
-            c='sol activate',
-        )
-
-    def test_ipmi_command_ipmi(self):
-        cons = self.klass(
-            self.hostname,
-            teuth_config.ipmi_user,
-            teuth_config.ipmi_password,
-            teuth_config.ipmi_domain,
-        )
-        pc_cmd = cons._ipmi_command('power cycle')
-        assert pc_cmd == self.ipmi_cmd_templ.format(
-            h=self.hostname,
-            d=teuth_config.ipmi_domain,
-            u=teuth_config.ipmi_user,
-            p=teuth_config.ipmi_password,
-            c='power cycle',
-        )
-
-    def test_spawn_log_conserver(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 0
-            m_popen.return_value.wait.return_value = 0
-            cons = self.klass(self.hostname)
-            assert cons.has_conserver is True
-            m_popen.reset_mock()
-            m_popen.return_value.poll.return_value = None
-            cons.spawn_sol_log('/fake/path')
-            assert m_popen.call_count == 1
-            call_args = m_popen.call_args_list[0][0][0]
-            assert any(
-                [teuth_config.conserver_master in arg for arg in call_args]
-            )
-
-    def test_spawn_log_ipmi(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 1
-            m_popen.return_value.wait.return_value = 1
-            cons = self.klass(self.hostname)
-            assert cons.has_conserver is False
-            m_popen.reset_mock()
-            m_popen.return_value.poll.return_value = 1
-            cons.spawn_sol_log('/fake/path')
-            assert m_popen.call_count == 1
-            call_args = m_popen.call_args_list[0][0][0]
-            assert any(
-                ['ipmitool' in arg for arg in call_args]
-            )
-
-    def test_spawn_log_fallback(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 0
-            m_popen.return_value.wait.return_value = 0
-            cons = self.klass(self.hostname)
-            assert cons.has_conserver is True
-            m_popen.reset_mock()
-            m_popen.return_value.poll.return_value = 1
-            cons.spawn_sol_log('/fake/path')
-            assert cons.has_conserver is False
-            assert m_popen.call_count == 2
-            call_args = m_popen.call_args_list[1][0][0]
-            assert any(
-                ['ipmitool' in arg for arg in call_args]
-            )
-
-    def test_get_console_conserver(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 0
-            m_popen.return_value.wait.return_value = 0
-            cons = self.klass(self.hostname)
-        assert cons.has_conserver is True
-        with patch(
-            'teuthology.orchestra.console.pexpect.spawn',
-            autospec=True,
-        ) as m_spawn:
-            cons._get_console()
-            assert m_spawn.call_count == 1
-            assert teuth_config.conserver_master in \
-                m_spawn.call_args_list[0][0][0]
-
-    def test_get_console_ipmitool(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 0
-            m_popen.return_value.wait.return_value = 0
-            cons = self.klass(self.hostname)
-        assert cons.has_conserver is True
-        with patch(
-            'teuthology.orchestra.console.pexpect.spawn',
-            autospec=True,
-        ) as m_spawn:
-            cons.has_conserver = False
-            cons._get_console()
-            assert m_spawn.call_count == 1
-            assert 'ipmitool' in m_spawn.call_args_list[0][0][0]
-
-    def test_get_console_fallback(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 0
-            m_popen.return_value.wait.return_value = 0
-            cons = self.klass(self.hostname)
-        assert cons.has_conserver is True
-        with patch(
-            'teuthology.orchestra.console.pexpect.spawn',
-            autospec=True,
-        ) as m_spawn:
-            cons.has_conserver = True
-            m_spawn.return_value.isalive.return_value = False
-            cons._get_console()
-            assert m_spawn.return_value.isalive.call_count == 1
-            assert m_spawn.call_count == 2
-            assert cons.has_conserver is False
-            assert 'ipmitool' in m_spawn.call_args_list[1][0][0]
-
-    def test_disable_conserver(self):
-        with patch(
-            'teuthology.orchestra.console.psutil.subprocess.Popen',
-            autospec=True,
-        ) as m_popen:
-            m_popen.return_value.pid = 42
-            m_popen.return_value.returncode = 0
-            m_popen.return_value.wait.return_value = 0
-            teuth_config.use_conserver = False
-            cons = self.klass(self.hostname)
-            assert cons.has_conserver is False