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

teuthology/test/test_config.py

@@ -1,189 +0,0 @@
-import pytest
-
-from teuthology import config
-
-
-class TestYamlConfig(object):
-    def setup(self):
-        self.test_class = config.YamlConfig
-
-    def test_set_multiple(self):
-        conf_obj = self.test_class()
-        conf_obj.foo = 'foo'
-        conf_obj.bar = 'bar'
-        assert conf_obj.foo == 'foo'
-        assert conf_obj.bar == 'bar'
-        assert conf_obj.to_dict()['foo'] == 'foo'
-
-    def test_from_dict(self):
-        in_dict = dict(foo='bar')
-        conf_obj = self.test_class.from_dict(in_dict)
-        assert conf_obj.foo == 'bar'
-
-    def test_contains(self):
-        in_dict = dict(foo='bar')
-        conf_obj = self.test_class.from_dict(in_dict)
-        conf_obj.bar = "foo"
-        assert "bar" in conf_obj
-        assert "foo" in conf_obj
-        assert "baz" not in conf_obj
-
-    def test_to_dict(self):
-        in_dict = dict(foo='bar')
-        conf_obj = self.test_class.from_dict(in_dict)
-        assert conf_obj.to_dict() == in_dict
-
-    def test_from_str(self):
-        in_str = "foo: bar"
-        conf_obj = self.test_class.from_str(in_str)
-        assert conf_obj.foo == 'bar'
-
-    def test_to_str(self):
-        in_str = "foo: bar"
-        conf_obj = self.test_class.from_str(in_str)
-        assert conf_obj.to_str() == in_str
-
-    def test_update(self):
-        conf_obj = self.test_class(dict())
-        conf_obj.foo = 'foo'
-        conf_obj.bar = 'bar'
-        conf_obj.update(dict(bar='baz'))
-        assert conf_obj.foo == 'foo'
-        assert conf_obj.bar == 'baz'
-
-    def test_delattr(self):
-        conf_obj = self.test_class()
-        conf_obj.foo = 'bar'
-        assert conf_obj.foo == 'bar'
-        del conf_obj.foo
-        assert conf_obj.foo is None
-
-    def test_assignment(self):
-        conf_obj = self.test_class()
-        conf_obj["foo"] = "bar"
-        assert conf_obj["foo"] == "bar"
-        assert conf_obj.foo == "bar"
-
-    def test_used_with_update(self):
-        d = dict()
-        conf_obj = self.test_class.from_dict({"foo": "bar"})
-        d.update(conf_obj)
-        assert d["foo"] == "bar"
-
-    def test_get(self):
-        conf_obj = self.test_class()
-        assert conf_obj.get('foo') is None
-        assert conf_obj.get('foo', 'bar') == 'bar'
-        conf_obj.foo = 'baz'
-        assert conf_obj.get('foo') == 'baz'
-
-
-class TestTeuthologyConfig(TestYamlConfig):
-    def setup(self):
-        self.test_class = config.TeuthologyConfig
-
-    def test_get_ceph_git_base_default(self):
-        conf_obj = self.test_class()
-        conf_obj.yaml_path = ''
-        conf_obj.load()
-        assert conf_obj.ceph_git_base_url == "https://github.com/ceph/"
-
-    def test_set_ceph_git_base_via_private(self):
-        conf_obj = self.test_class()
-        conf_obj._conf['ceph_git_base_url'] = \
-            "git://git.ceph.com/"
-        assert conf_obj.ceph_git_base_url == "git://git.ceph.com/"
-
-    def test_get_reserve_machines_default(self):
-        conf_obj = self.test_class()
-        conf_obj.yaml_path = ''
-        conf_obj.load()
-        assert conf_obj.reserve_machines == 5
-
-    def test_set_reserve_machines_via_private(self):
-        conf_obj = self.test_class()
-        conf_obj._conf['reserve_machines'] = 2
-        assert conf_obj.reserve_machines == 2
-
-    def test_set_nonstandard(self):
-        conf_obj = self.test_class()
-        conf_obj.something = 'something else'
-        assert conf_obj.something == 'something else'
-
-
-class TestJobConfig(TestYamlConfig):
-    def setup(self):
-        self.test_class = config.JobConfig
-
-
-class TestFakeNamespace(TestYamlConfig):
-    def setup(self):
-        self.test_class = config.FakeNamespace
-
-    def test_docopt_dict(self):
-        """
-        Tests if a dict in the format that docopt returns can
-        be parsed correctly.
-        """
-        d = {
-            "--verbose": True,
-            "--an-option": "some_option",
-            "<an_arg>": "the_arg",
-            "something": "some_thing",
-        }
-        conf_obj = self.test_class(d)
-        assert conf_obj.verbose
-        assert conf_obj.an_option == "some_option"
-        assert conf_obj.an_arg == "the_arg"
-        assert conf_obj.something == "some_thing"
-
-    def test_config(self):
-        """
-        Tests that a teuthology_config property is automatically added
-        to the conf_obj
-        """
-        conf_obj = self.test_class(dict(foo="bar"))
-        assert conf_obj["foo"] == "bar"
-        assert conf_obj.foo == "bar"
-        assert conf_obj.teuthology_config.get("fake key") is None
-
-    def test_getattr(self):
-        conf_obj = self.test_class.from_dict({"foo": "bar"})
-        result = getattr(conf_obj, "not_there", "default")
-        assert result == "default"
-        result = getattr(conf_obj, "foo")
-        assert result == "bar"
-
-    def test_none(self):
-        conf_obj = self.test_class.from_dict(dict(null=None))
-        assert conf_obj.null is None
-
-    def test_delattr(self):
-        conf_obj = self.test_class()
-        conf_obj.foo = 'bar'
-        assert conf_obj.foo == 'bar'
-        del conf_obj.foo
-        with pytest.raises(AttributeError):
-            conf_obj.foo
-
-    def test_to_str(self):
-        in_str = "foo: bar"
-        conf_obj = self.test_class.from_str(in_str)
-        assert conf_obj.to_str() == "{'foo': 'bar'}"
-
-    def test_multiple_access(self):
-        """
-        Test that config.config and FakeNamespace.teuthology_config reflect
-        each others' modifications
-        """
-        in_str = "foo: bar"
-        conf_obj = self.test_class.from_str(in_str)
-        assert config.config.get('test_key_1') is None
-        assert conf_obj.teuthology_config.get('test_key_1') is None
-        config.config.test_key_1 = 'test value'
-        assert conf_obj.teuthology_config['test_key_1'] == 'test value'
-
-        assert config.config.get('test_key_2') is None
-        assert conf_obj.teuthology_config.get('test_key_2') is None
-        conf_obj.teuthology_config['test_key_2'] = 'test value'
-        assert config.config['test_key_2'] == 'test value'

teuthology/test/test_contextutil.py

@@ -1,68 +0,0 @@
-from pytest import raises
-from teuthology import contextutil
-from logging import ERROR
-
-
-class TestSafeWhile(object):
-
-    def setup(self):
-        contextutil.log.setLevel(ERROR)
-        self.fake_sleep = lambda s: True
-        self.s_while = contextutil.safe_while
-
-    def test_6_5_10_deal(self):
-        with raises(contextutil.MaxWhileTries):
-            with self.s_while(_sleeper=self.fake_sleep) as proceed:
-                while proceed():
-                    pass
-
-    def test_6_0_1_deal(self):
-        with raises(contextutil.MaxWhileTries) as error:
-            with self.s_while(
-                tries=1,
-                _sleeper=self.fake_sleep
-            ) as proceed:
-                while proceed():
-                    pass
-
-        assert 'waiting for 6 seconds' in str(error)
-
-    def test_1_0_10_deal(self):
-        with raises(contextutil.MaxWhileTries) as error:
-            with self.s_while(
-                sleep=1,
-                _sleeper=self.fake_sleep
-            ) as proceed:
-                while proceed():
-                    pass
-
-        assert 'waiting for 10 seconds' in str(error)
-
-    def test_6_1_10_deal(self):
-        with raises(contextutil.MaxWhileTries) as error:
-            with self.s_while(
-                increment=1,
-                _sleeper=self.fake_sleep
-            ) as proceed:
-                while proceed():
-                    pass
-
-        assert 'waiting for 105 seconds' in str(error)
-
-    def test_action(self):
-        with raises(contextutil.MaxWhileTries) as error:
-            with self.s_while(
-                action='doing the thing',
-                _sleeper=self.fake_sleep
-            ) as proceed:
-                while proceed():
-                    pass
-
-        assert "'doing the thing' reached maximum tries" in str(error)
-
-    def test_no_raise(self):
-        with self.s_while(_raise=False, _sleeper=self.fake_sleep) as proceed:
-            while proceed():
-                pass
-
-        assert True

teuthology/test/test_describe_tests.py

@@ -1,316 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from teuthology.test.fake_fs import make_fake_fstools
-from teuthology.describe_tests import (tree_with_info, extract_info,
-                                       get_combinations)
-from teuthology.exceptions import ParseError
-from mock import MagicMock, patch
-
-realistic_fs = {
-    'basic': {
-        '%': None,
-        'base': {
-            'install.yaml':
-            """meta:
-- desc: install ceph
-install:
-"""
-        },
-        'clusters': {
-            'fixed-1.yaml':
-            """meta:
-- desc: single node cluster
-roles:
-- [osd.0, osd.1, osd.2, mon.a, mon.b, mon.c, client.0]
-""",
-            'fixed-2.yaml':
-            """meta:
-- desc: couple node cluster
-roles:
-- [osd.0, osd.1, osd.2, mon.a, mon.b, mon.c]
-- [client.0]
-""",
-            'fixed-3.yaml':
-            """meta:
-- desc: triple node cluster
-roles:
-- [osd.0, osd.1, osd.2, mon.a, mon.b, mon.c]
-- [client.0]
-- [client.1]
-"""
-        },
-        'workloads': {
-            'rbd_api_tests_old_format.yaml':
-            """meta:
-- desc: c/c++ librbd api tests with format 1 images
-  rbd_features: none
-overrides:
-  ceph:
-    conf:
-      client:
-        rbd default format: 1
-tasks:
-- workunit:
-    env:
-      RBD_FEATURES: 0
-    clients:
-      client.0:
-        - rbd/test_librbd.sh
-""",
-            'rbd_api_tests.yaml':
-            """meta:
-- desc: c/c++ librbd api tests with default settings
-  rbd_features: default
-tasks:
-- workunit:
-    clients:
-      client.0:
-        - rbd/test_librbd.sh
-""",
-        },
-    },
-}
-
-
-expected_tree = """├── %
-├── base
-│   └── install.yaml
-├── clusters
-│   ├── fixed-1.yaml
-│   ├── fixed-2.yaml
-│   └── fixed-3.yaml
-└── workloads
-    ├── rbd_api_tests.yaml
-    └── rbd_api_tests_old_format.yaml""".split('\n')
-
-
-expected_facets = [
-    '',
-    '',
-    'base',
-    '',
-    'clusters',
-    'clusters',
-    'clusters',
-    '',
-    'workloads',
-    'workloads',
-]
-
-
-expected_desc = [
-    '',
-    '',
-    'install ceph',
-    '',
-    'single node cluster',
-    'couple node cluster',
-    'triple node cluster',
-    '',
-    'c/c++ librbd api tests with default settings',
-    'c/c++ librbd api tests with format 1 images',
-]
-
-
-expected_rbd_features = [
-    '',
-    '',
-    '',
-    '',
-    '',
-    '',
-    '',
-    '',
-    'default',
-    'none',
-]
-
-
-class TestDescribeTests(object):
-
-    def setup(self):
-        self.mocks = dict()
-        self.patchers = dict()
-        exists, listdir, isfile, isdir, open = make_fake_fstools(realistic_fs)
-        for ppoint, fn in {
-             'os.listdir': listdir,
-             'os.path.isdir': isdir,
-             'teuthology.describe_tests.open': open,
-             'os.path.exists': exists,
-             'os.listdir': listdir,
-             'os.path.isfile': isfile,
-         }.items():
-            mockobj = MagicMock()
-            patcher = patch(ppoint, mockobj)
-            mockobj.side_effect = fn
-            patcher.start()
-            self.mocks[ppoint] = mockobj
-            self.patchers[ppoint] = patcher
-
-    def stop_patchers(self):
-        for patcher in self.patchers.values():
-            patcher.stop()
-
-    def teardown(self):
-        self.stop_patchers()
-
-    @staticmethod
-    def assert_expected_combo_headers(headers):
-        assert headers == (['subsuite depth 0'] +
-                           sorted(set(filter(bool, expected_facets))))
-
-    def test_no_filters(self):
-        rows = tree_with_info('basic', [], False, '', [])
-        assert rows == [[x] for x in expected_tree]
-
-    def test_single_filter(self):
-        rows = tree_with_info('basic', ['desc'], False, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree, expected_desc)]
-
-        rows = tree_with_info('basic', ['rbd_features'], False, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree, expected_rbd_features)]
-
-    def test_single_filter_with_facets(self):
-        rows = tree_with_info('basic', ['desc'], True, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree, expected_facets,
-                                     expected_desc)]
-
-        rows = tree_with_info('basic', ['rbd_features'], True, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree, expected_facets,
-                                     expected_rbd_features)]
-
-    def test_no_matching(self):
-        rows = tree_with_info('basic', ['extra'], False, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree, [''] * len(expected_tree))]
-
-        rows = tree_with_info('basic', ['extra'], True, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree, expected_facets,
-                                     [''] * len(expected_tree))]
-
-    def test_multiple_filters(self):
-        rows = tree_with_info('basic', ['desc', 'rbd_features'], False, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree,
-                                     expected_desc,
-                                     expected_rbd_features)]
-
-        rows = tree_with_info('basic', ['rbd_features', 'desc'], False, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree,
-                                     expected_rbd_features,
-                                     expected_desc)]
-
-    def test_multiple_filters_with_facets(self):
-        rows = tree_with_info('basic', ['desc', 'rbd_features'], True, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree,
-                                     expected_facets,
-                                     expected_desc,
-                                     expected_rbd_features)]
-
-        rows = tree_with_info('basic', ['rbd_features', 'desc'], True, '', [])
-        assert rows == [list(_) for _ in zip(expected_tree,
-                                     expected_facets,
-                                     expected_rbd_features,
-                                     expected_desc)]
-
-    def test_combinations_only_facets(self):
-        headers, rows = get_combinations('basic',
-                fields=[], subset=None, limit=1,
-                filter_in=None, filter_out=None, filter_all=None,
-                include_facet=True)
-        self.assert_expected_combo_headers(headers)
-        assert rows == [['basic', 'install', 'fixed-1', 'rbd_api_tests']]
-
-    def test_combinations_desc_features(self):
-        headers, rows = get_combinations('basic',
-                fields=['desc', 'rbd_features'], subset=None, limit=1,
-                filter_in=None, filter_out=None, filter_all=None,
-                include_facet=False)
-        assert headers == ['desc', 'rbd_features']
-        descriptions = '\n'.join([
-            'install ceph',
-            'single node cluster',
-            'c/c++ librbd api tests with default settings',
-        ])
-        assert rows == [[descriptions, 'default']]
-
-    def test_combinations_filter_in(self):
-        headers, rows = get_combinations('basic',
-                fields=[], subset=None, limit=0,
-                filter_in=['old_format'], filter_out=None, filter_all=None,
-                include_facet=True)
-        self.assert_expected_combo_headers(headers)
-        assert rows == [
-            ['basic', 'install', 'fixed-1', 'rbd_api_tests_old_format'],
-            ['basic', 'install', 'fixed-2', 'rbd_api_tests_old_format'],
-            ['basic', 'install', 'fixed-3', 'rbd_api_tests_old_format'],
-        ]
-
-    def test_combinations_filter_out(self):
-        headers, rows = get_combinations('basic',
-                fields=[], subset=None, limit=0,
-                filter_in=None, filter_out=['old_format'], filter_all=None,
-                include_facet=True)
-        self.assert_expected_combo_headers(headers)
-        assert rows == [
-            ['basic', 'install', 'fixed-1', 'rbd_api_tests'],
-            ['basic', 'install', 'fixed-2', 'rbd_api_tests'],
-            ['basic', 'install', 'fixed-3', 'rbd_api_tests'],
-        ]
-
-    def test_combinations_filter_all(self):
-        headers, rows = get_combinations('basic',
-                fields=[], subset=None, limit=0,
-                filter_in=None, filter_out=None,
-                filter_all=['fixed-2', 'old_format'],
-                include_facet=True)
-        self.assert_expected_combo_headers(headers)
-        assert rows == [
-            ['basic', 'install', 'fixed-2', 'rbd_api_tests_old_format']
-        ]
-
-
-@patch('teuthology.describe_tests.open')
-@patch('os.path.isdir')
-def test_extract_info_dir(m_isdir, m_open):
-    simple_fs = {'a': {'b.yaml': 'meta: [{foo: c}]'}}
-    _, _, _, m_isdir.side_effect, m_open.side_effect = \
-        make_fake_fstools(simple_fs)
-    info = extract_info('a', [])
-    assert info == {}
-
-    info = extract_info('a', ['foo', 'bar'])
-    assert info == {'foo': '', 'bar': ''}
-
-    info = extract_info('a/b.yaml', ['foo', 'bar'])
-    assert info == {'foo': 'c', 'bar': ''}
-
-
-@patch('teuthology.describe_tests.open')
-@patch('os.path.isdir')
-def check_parse_error(fs, m_isdir, m_open):
-    _, _, _, m_isdir.side_effect, m_open.side_effect = make_fake_fstools(fs)
-    with pytest.raises(ParseError):
-        a = extract_info('a.yaml', ['a'])
-        raise Exception(str(a))
-
-
-def test_extract_info_too_many_elements():
-    check_parse_error({'a.yaml': 'meta: [{a: b}, {b: c}]'})
-
-
-def test_extract_info_not_a_list():
-    check_parse_error({'a.yaml': 'meta: {a: b}'})
-
-
-def test_extract_info_not_a_dict():
-    check_parse_error({'a.yaml': 'meta: [[a, b]]'})
-
-
-@patch('teuthology.describe_tests.open')
-@patch('os.path.isdir')
-def test_extract_info_empty_file(m_isdir, m_open):
-    simple_fs = {'a.yaml': ''}
-    _, _, _, m_isdir.side_effect, m_open.side_effect = \
-        make_fake_fstools(simple_fs)
-    info = extract_info('a.yaml', [])
-    assert info == {}

teuthology/test/test_email_sleep_before_teardown.py

@@ -1,81 +0,0 @@
-from humanfriendly import format_timespan
-from mock import Mock, patch
-from pytest import mark
-from teuthology.config import config
-from teuthology.run_tasks import build_email_body as email_body
-from textwrap import dedent
-
-class TestSleepBeforeTeardownEmail(object):
-    def setup(self):
-        config.results_ui_server = "http://example.com/"
-        config.archive_server = "http://qa-proxy.ceph.com/teuthology/"
-
-    @mark.parametrize(
-        ['status', 'owner', 'suite_name', 'run_name', 'job_id', 'dura'],
-        [
-            [
-                'pass',
-                'noreply@host',
-                'dummy',
-                'run-name',
-                123,
-                3600,
-            ],
-            [
-                'fail',
-                'noname',
-                'yummy',
-                'next-run',
-                1000,
-                99999,
-            ],
-        ]
-    )
-    @patch("teuthology.run_tasks.time.time")
-    def test_sleep_before_teardown_email_body(self, m_time, status, owner,
-                                              suite_name, run_name, job_id, dura):
-        ctx = Mock()
-        archive_path='archive/path'
-        archive_dir='/archive/dir'
-        date_sec=3661
-        date_str='1970-01-01 01:01:01'
-        m_time.return_value=float(date_sec)
-        duration_sec=dura
-        duration_str=format_timespan(duration_sec)
-        ref_body=dedent("""
-            Teuthology job {run}/{job} has fallen asleep at {date} for {duration_str}
-
-            Owner: {owner}
-            Suite Name: {suite}
-            Sleep Date: {date}
-            Sleep Time: {duration_sec} seconds ({duration_str})
-            Job Info: http://example.com/{run}/
-            Job Logs: http://qa-proxy.ceph.com/teuthology/path/{job}/
-            Task Stack: a/b/c
-            Current Status: {status}"""
-            .format(duration_sec=duration_sec, duration_str=duration_str,
-                owner=owner, suite=suite_name, run=run_name,
-                job=job_id, status=status, date=date_str))
-        print(ref_body)
-        ctx.config = dict(
-            archive_path=archive_path,
-            job_id=job_id,
-            suite=suite_name,
-            )
-        if status == 'pass':
-            ctx.summary = dict(
-                success=True,
-            )
-        elif status == 'fail':
-            ctx.summary = dict(
-                success=False,
-            )
-        else:
-            ctx.summary = dict()
-
-        ctx.owner   = owner
-        ctx.name    = run_name
-        ctx.archive_dir = archive_dir
-        tasks = [('a', None), ('b', None), ('c', None)]
-        (subj, body) = email_body(ctx, tasks, dura)
-        assert body == ref_body.lstrip('\n')