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

teuthology/test/test_run.py

@@ -1,238 +0,0 @@
-import pytest
-import docopt
-
-from unittest.mock import patch, call, Mock
-
-from teuthology import run
-from scripts import run as scripts_run
-
-
-class TestRun(object):
-    """ Tests for teuthology.run """
-
-    @patch("teuthology.log.setLevel")
-    @patch("teuthology.setup_log_file")
-    @patch("os.mkdir")
-    def test_set_up_logging(self, m_mkdir, m_setup_log_file, m_setLevel):
-        run.set_up_logging(True, "path/to/archive")
-        m_mkdir.assert_called_with("path/to/archive")
-        m_setup_log_file.assert_called_with("path/to/archive/teuthology.log")
-        assert m_setLevel.called
-
-    # because of how we import things, mock merge_configs from run - where it's used
-    # see: http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch
-    @patch("teuthology.run.merge_configs")
-    def test_setup_config(self, m_merge_configs):
-        config = {"job_id": 1, "foo": "bar"}
-        m_merge_configs.return_value = config
-        result = run.setup_config(["some/config.yaml"])
-        assert m_merge_configs.called
-        assert result["job_id"] == "1"
-        assert result["foo"] == "bar"
-
-    @patch("teuthology.run.merge_configs")
-    def test_setup_config_targets_ok(self, m_merge_configs):
-        config = {"targets": list(range(4)), "roles": list(range(2))}
-        m_merge_configs.return_value = config
-        result = run.setup_config(["some/config.yaml"])
-        assert result["targets"] == [0, 1, 2, 3]
-        assert result["roles"] == [0, 1]
-
-    @patch("teuthology.run.merge_configs")
-    def test_setup_config_targets_invalid(self, m_merge_configs):
-        config = {"targets": range(2), "roles": range(4)}
-        m_merge_configs.return_value = config
-        with pytest.raises(AssertionError):
-            run.setup_config(["some/config.yaml"])
-
-    @patch("teuthology.run.open")
-    def test_write_initial_metadata(self, m_open):
-        config = {"job_id": "123", "foo": "bar"}
-        run.write_initial_metadata(
-            "some/archive/dir",
-            config,
-            "the_name",
-            "the_description",
-            "the_owner",
-        )
-        expected = [
-            call('some/archive/dir/pid', 'w'),
-            call('some/archive/dir/owner', 'w'),
-            call('some/archive/dir/orig.config.yaml', 'w'),
-            call('some/archive/dir/info.yaml', 'w')
-        ]
-        assert m_open.call_args_list == expected
-
-    def test_get_machine_type(self):
-        result = run.get_machine_type(None, {"machine-type": "the_machine_type"})
-        assert result == "the_machine_type"
-
-    def test_get_summary(self):
-        result = run.get_summary("the_owner", "the_description")
-        assert result == {"owner": "the_owner", "description": "the_description", "success": True}
-        result = run.get_summary("the_owner", None)
-        assert result == {"owner": "the_owner", "success": True}
-
-    def test_validate_tasks_invalid(self):
-        config = {"tasks": [{"kernel": "can't be here"}]}
-        with pytest.raises(AssertionError) as excinfo:
-            run.validate_tasks(config)
-        assert excinfo.value.args[0].startswith("kernel installation")
-
-    def test_validate_task_no_tasks(self):
-        result = run.validate_tasks({})
-        assert result == []
-
-    def test_validate_tasks_valid(self):
-        expected = [{"foo": "bar"}, {"bar": "foo"}]
-        result = run.validate_tasks({"tasks": expected})
-        assert result == expected
-
-    def test_validate_tasks_is_list(self):
-        with pytest.raises(AssertionError) as excinfo:
-            run.validate_tasks({"tasks": {"foo": "bar"}})
-        assert excinfo.value.args[0].startswith("Expected list")
-
-    def test_get_initial_tasks_invalid(self):
-        with pytest.raises(AssertionError) as excinfo:
-            run.get_initial_tasks(True, {"targets": "can't be here",
-                                         "roles": "roles" }, "machine_type")
-        assert excinfo.value.args[0].startswith("You cannot")
-
-    def test_get_inital_tasks(self):
-        config = {"roles": range(2), "kernel": "the_kernel", "use_existing_cluster": False}
-        result = run.get_initial_tasks(True, config, "machine_type")
-        assert {"internal.lock_machines": (2, "machine_type")} in result
-        assert {"kernel": "the_kernel"} in result
-        # added because use_existing_cluster == False
-        assert {'internal.vm_setup': None} in result
-        assert {'internal.buildpackages_prep': None} in result
-
-    @patch("teuthology.run.fetch_qa_suite")
-    def test_fetch_tasks_if_needed(self, m_fetch_qa_suite):
-        config = {"suite_path": "/some/suite/path", "suite_branch": "feature_branch"}
-        m_fetch_qa_suite.return_value = "/some/other/suite/path"
-        result = run.fetch_tasks_if_needed(config)
-        m_fetch_qa_suite.assert_called_with("feature_branch")
-        assert result == "/some/other/suite/path"
-
-    @patch("teuthology.run.get_status")
-    @patch("teuthology.run.nuke")
-    @patch("yaml.safe_dump")
-    @patch("teuthology.report.try_push_job_info")
-    @patch("teuthology.run.email_results")
-    @patch("teuthology.run.open")
-    @patch("sys.exit")
-    def test_report_outcome(self, m_sys_exit, m_open, m_email_results, m_try_push_job_info, m_safe_dump, m_nuke, m_get_status):
-        m_get_status.return_value = "fail"
-        fake_ctx = Mock()
-        summary = {"failure_reason": "reasons"}
-        summary_dump = "failure_reason: reasons\n"
-        config = {"nuke-on-error": True, "email-on-error": True}
-        config_dump = "nuke-on-error: true\nemail-on-error: true\n"
-        m_safe_dump.side_effect = [None, summary_dump, config_dump]
-        run.report_outcome(config, "the/archive/path", summary, fake_ctx)
-        assert m_nuke.called
-        m_try_push_job_info.assert_called_with(config, summary)
-        m_open.assert_called_with("the/archive/path/summary.yaml", "w")
-        assert m_email_results.called
-        assert m_open.called
-        assert m_sys_exit.called
-
-    @patch("teuthology.run.set_up_logging")
-    @patch("teuthology.run.setup_config")
-    @patch("teuthology.run.get_user")
-    @patch("teuthology.run.write_initial_metadata")
-    @patch("teuthology.report.try_push_job_info")
-    @patch("teuthology.run.get_machine_type")
-    @patch("teuthology.run.get_summary")
-    @patch("yaml.safe_dump")
-    @patch("teuthology.run.validate_tasks")
-    @patch("teuthology.run.get_initial_tasks")
-    @patch("teuthology.run.fetch_tasks_if_needed")
-    @patch("teuthology.run.run_tasks")
-    @patch("teuthology.run.report_outcome")
-    def test_main(self, m_report_outcome, m_run_tasks, m_fetch_tasks_if_needed, m_get_initial_tasks, m_validate_tasks,
-                  m_safe_dump, m_get_summary, m_get_machine_type, m_try_push_job_info, m_write_initial_metadata,
-                  m_get_user, m_setup_config, m_set_up_logging):
-        """ This really should be an integration test of some sort. """
-        config = {"job_id": 1}
-        m_setup_config.return_value = config
-        m_get_machine_type.return_value = "machine_type"
-        doc = scripts_run.__doc__
-        args = docopt.docopt(doc, [
-            "--verbose",
-            "--archive", "some/archive/dir",
-            "--description", "the_description",
-            "--lock",
-            "--os-type", "os_type",
-            "--os-version", "os_version",
-            "--block",
-            "--name", "the_name",
-            "--suite-path", "some/suite/dir",
-            "path/to/config.yml",
-        ])
-        m_get_user.return_value = "the_owner"
-        m_get_summary.return_value = dict(success=True, owner="the_owner", description="the_description")
-        m_validate_tasks.return_value = ['task3']
-        m_get_initial_tasks.return_value = ['task1', 'task2']
-        m_fetch_tasks_if_needed.return_value = "some/suite/dir"
-        run.main(args)
-        m_set_up_logging.assert_called_with(True, "some/archive/dir")
-        m_setup_config.assert_called_with(["path/to/config.yml"])
-        m_write_initial_metadata.assert_called_with(
-            "some/archive/dir",
-            config,
-            "the_name",
-            "the_description",
-            "the_owner"
-        )
-        m_try_push_job_info.assert_called_with(config, dict(status='running'))
-        m_get_machine_type.assert_called_with(None, config)
-        m_get_summary.assert_called_with("the_owner", "the_description")
-        m_get_initial_tasks.assert_called_with(True, config, "machine_type")
-        m_fetch_tasks_if_needed.assert_called_with(config)
-        assert m_report_outcome.called
-        args, kwargs = m_run_tasks.call_args
-        fake_ctx = kwargs["ctx"]._conf
-        # fields that must be in ctx for the tasks to behave
-        expected_ctx = ["verbose", "archive", "description", "owner", "lock", "machine_type", "os_type", "os_version",
-                        "block", "name", "suite_path", "config", "summary"]
-        for key in expected_ctx:
-            assert key in fake_ctx
-        assert isinstance(fake_ctx["config"], dict)
-        assert isinstance(fake_ctx["summary"], dict)
-        assert "tasks" in fake_ctx["config"]
-        # ensures that values missing in args are added with the correct value
-        assert fake_ctx["owner"] == "the_owner"
-        assert fake_ctx["machine_type"] == "machine_type"
-        # ensures os_type and os_version are property overwritten
-        assert fake_ctx["config"]["os_type"] == "os_type"
-        assert fake_ctx["config"]["os_version"] == "os_version"
-
-    def test_get_teuthology_command(self):
-        doc = scripts_run.__doc__
-        args = docopt.docopt(doc, [
-            "--archive", "some/archive/dir",
-            "--description", "the_description",
-            "--lock",
-            "--block",
-            "--name", "the_name",
-            "--suite-path", "some/suite/dir",
-            "path/to/config.yml", "path/to/config2.yaml",
-        ])
-        result = run.get_teuthology_command(args)
-        result = result.split()
-        expected = [
-            "teuthology",
-            "path/to/config.yml", "path/to/config2.yaml",
-            "--suite-path", "some/suite/dir",
-            "--lock",
-            "--description", "the_description",
-            "--name", "the_name",
-            "--block",
-            "--archive", "some/archive/dir",
-        ]
-        assert len(result) == len(expected)
-        for arg in expected:
-            assert arg in result

teuthology/test/test_safepath.py

@@ -1,55 +0,0 @@
-from teuthology import safepath
-
-class TestSafepath(object):
-    def test_simple(self):
-        got = safepath.munge('foo')
-        assert got == 'foo'
-
-    def test_empty(self):
-        # really odd corner case
-        got = safepath.munge('')
-        assert got == '_'
-
-    def test_slash(self):
-        got = safepath.munge('/')
-        assert got == '_'
-
-    def test_slashslash(self):
-        got = safepath.munge('//')
-        assert got == '_'
-
-    def test_absolute(self):
-        got = safepath.munge('/evil')
-        assert got == 'evil'
-
-    def test_absolute_subdir(self):
-        got = safepath.munge('/evil/here')
-        assert got == 'evil/here'
-
-    def test_dot_leading(self):
-        got = safepath.munge('./foo')
-        assert got == 'foo'
-
-    def test_dot_middle(self):
-        got = safepath.munge('evil/./foo')
-        assert got == 'evil/foo'
-
-    def test_dot_trailing(self):
-        got = safepath.munge('evil/foo/.')
-        assert got == 'evil/foo'
-
-    def test_dotdot(self):
-        got = safepath.munge('../evil/foo')
-        assert got == '_./evil/foo'
-
-    def test_dotdot_subdir(self):
-        got = safepath.munge('evil/../foo')
-        assert got == 'evil/_./foo'
-
-    def test_hidden(self):
-        got = safepath.munge('.evil')
-        assert got == '_evil'
-
-    def test_hidden_subdir(self):
-        got = safepath.munge('foo/.evil')
-        assert got == 'foo/_evil'

teuthology/test/test_schedule.py

@@ -1,45 +0,0 @@
-from teuthology.schedule import build_config
-from teuthology.misc import get_user
-
-
-class TestSchedule(object):
-    basic_args = {
-        '--verbose': False,
-        '--owner': 'OWNER',
-        '--description': 'DESC',
-        '--email': 'EMAIL',
-        '--first-in-suite': False,
-        '--last-in-suite': True,
-        '--name': 'NAME',
-        '--worker': 'tala',
-        '--timeout': '6',
-        '--priority': '99',
-        # TODO: make this work regardless of $PWD
-        #'<conf_file>': ['../../examples/3node_ceph.yaml',
-        #                '../../examples/3node_rgw.yaml'],
-        }
-
-    def test_basic(self):
-        expected = {
-            'description': 'DESC',
-            'email': 'EMAIL',
-            'first_in_suite': False,
-            'last_in_suite': True,
-            'machine_type': 'tala',
-            'name': 'NAME',
-            'owner': 'OWNER',
-            'priority': 99,
-            'results_timeout': '6',
-            'verbose': False,
-            'tube': 'tala',
-        }
-
-        job_dict = build_config(self.basic_args)
-        assert job_dict == expected
-
-    def test_owner(self):
-        args = self.basic_args
-        args['--owner'] = None
-        job_dict = build_config(self.basic_args)
-        assert job_dict['owner'] == 'scheduled_%s' % get_user()
-

teuthology/test/test_scrape.py

@@ -1,167 +0,0 @@
-from __future__ import with_statement
-
-import os
-import shutil
-import tempfile
-import yaml
-from teuthology import scrape
-
-class FakeResultDir(object):
-    """Mocks a Result Directory"""
-
-    def __init__(self,
-                failure_reason="Dummy reason",
-                assertion="FAILED assert 1 == 2\n",
-                blank_backtrace=False
-    ):
-        self.failure_reason = failure_reason
-        self.assertion = assertion
-        self.blank_backtrace = blank_backtrace
-        self.path = tempfile.mkdtemp()
-        
-        with open(os.path.join(self.path, "config.yaml"), "w") as f:
-            yaml.dump({"description": "Dummy test"}, f)
-        
-        with open(os.path.join(self.path, "summary.yaml"), "w") as f:
-            yaml.dump({
-                "success": "false",
-                "failure_reason": self.failure_reason
-            }, f)
-
-        with open(os.path.join(self.path, "teuthology.log"), "w") as f:
-            if not self.blank_backtrace:
-                f.write(" ceph version 1000\n")
-                f.write(".stderr: Dummy error\n")
-                f.write(self.assertion)
-            f.write(" NOTE: a copy of the executable dummy text\n")
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_typ, exc_val, exc_tb):
-        shutil.rmtree(self.path)
-
-class TestScrape(object):
-    """Tests for teuthology.scrape"""
-
-    def test_grep(self):
-        with FakeResultDir() as d:
-            filepath = os.path.join(d.path, "scrapetest.txt")
-            with open(filepath, 'w') as f:
-                f.write("Ceph is an open-source software storage platform\n\
-                        Teuthology is used for testing.")
-
-            #System level grep is called
-            value1 = scrape.grep(filepath, "software")
-            value2 = scrape.grep(filepath, "device")
-
-            assert value1 ==\
-                ['Ceph is an open-source software storage platform', '']
-            assert value2 == []
-
-    def test_job(self):
-        with FakeResultDir() as d:
-            job = scrape.Job(d.path, 1)
-            assert job.get_success() == "false"
-            assert job.get_assertion() == "FAILED assert 1 == 2"
-            assert job.get_last_tlog_line() ==\
-                b"NOTE: a copy of the executable dummy text"
-            assert job.get_failure_reason() == "Dummy reason"
-
-    def test_timeoutreason(self):
-        with FakeResultDir(failure_reason=\
-            "status 124:  timeout '123 /home/ubuntu/cephtest/workunit.client.0/cephtool/test.sh'") as d:
-            job = scrape.Job(d.path, 1)
-            assert scrape.TimeoutReason.could_be(job)
-            assert scrape.TimeoutReason(job).match(job)
-
-    def test_deadreason(self):
-        with FakeResultDir() as d:
-            job = scrape.Job(d.path, 1)
-            #Summary is present
-            #So this cannot be a DeadReason
-            assert not scrape.DeadReason.could_be(job)
-
-    def test_lockdepreason(self):
-        lkReason = None
-        with FakeResultDir(assertion=\
-            "FAILED assert common/lockdep reason\n") as d:
-            job = scrape.Job(d.path, 1)
-            assert scrape.LockdepReason.could_be(job)
-
-            lkReason = scrape.LockdepReason(job)
-            #Backtraces of same jobs must match 100%
-            assert lkReason.match(job)
-        with FakeResultDir(blank_backtrace=True) as d:
-            #Corresponding to 0% match
-            assert not lkReason.match(scrape.Job(d.path, 2))
-
-    def test_assertionreason(self):
-        with FakeResultDir() as d:
-            job = scrape.Job(d.path, 1)
-            assert scrape.AssertionReason.could_be(job)
-
-    def test_genericreason(self):
-        d1 = FakeResultDir(blank_backtrace=True)
-        d2 = FakeResultDir(failure_reason="Dummy dummy")
-        d3 = FakeResultDir()
-
-        job1 = scrape.Job(d1.path, 1)
-        job2 = scrape.Job(d2.path, 2)
-        job3 = scrape.Job(d3.path, 3)
-
-        reason = scrape.GenericReason(job3)
-
-        assert reason.match(job2)
-        assert not reason.match(job1)
-
-        shutil.rmtree(d1.path)
-        shutil.rmtree(d2.path)
-        shutil.rmtree(d3.path)
-
-    def test_valgrindreason(self):
-        vreason = None
-        with FakeResultDir(
-            failure_reason="saw valgrind issues",
-            assertion="2014-08-22T20:07:18.668 ERROR:tasks.ceph:saw valgrind issue   <kind>Leak_DefinitelyLost</kind> in /var/log/ceph/valgrind/osd.3.log.gz\n"
-        ) as d:
-            job = scrape.Job(d.path, 1)
-            assert scrape.ValgrindReason.could_be(job)
-            
-            vreason = scrape.ValgrindReason(job)
-            assert vreason.match(job)
-
-    def test_give_me_a_reason(self):
-        with FakeResultDir() as d:
-            job = scrape.Job(d.path, 1)
-            
-            assert type(scrape.give_me_a_reason(job)) == scrape.AssertionReason
-
-        #Test the lockdep ordering
-        with FakeResultDir(assertion=\
-        "FAILED assert common/lockdep reason\n") as d:
-            job = scrape.Job(d.path, 1)
-            assert type(scrape.give_me_a_reason(job)) == scrape.LockdepReason
-
-    def test_scraper(self):
-        d = FakeResultDir()
-        os.mkdir(os.path.join(d.path, "test"))
-        shutil.move(
-            os.path.join(d.path, "config.yaml"),
-            os.path.join(d.path, "test", "config.yaml")
-        )
-        shutil.move(
-            os.path.join(d.path, "summary.yaml"),
-            os.path.join(d.path, "test", "summary.yaml")
-        )
-        shutil.move(
-            os.path.join(d.path, "teuthology.log"),
-            os.path.join(d.path, "test", "teuthology.log")
-        )
-
-        scrape.Scraper(d.path).analyze()
-
-        #scrape.log should be created
-        assert os.path.exists(os.path.join(d.path, "scrape.log"))
-
-        shutil.rmtree(d.path)

teuthology/test/test_timer.py

@@ -1,80 +0,0 @@
-from teuthology import timer
-
-from unittest.mock import MagicMock, patch, mock_open
-from time import time
-
-
-class TestTimer(object):
-    def test_data_empty(self):
-        self.timer = timer.Timer()
-        assert self.timer.data == dict()
-
-    def test_data_one_mark(self):
-        self.timer = timer.Timer()
-        # Avoid failing if ~1ms elapses between these two calls
-        self.timer.precision = 2
-        self.timer.mark()
-        assert len(self.timer.data['marks']) == 1
-        assert self.timer.data['marks'][0]['interval'] == 0
-        assert self.timer.data['marks'][0]['message'] == ''
-
-    def test_data_five_marks(self):
-        self.timer = timer.Timer()
-        for i in range(5):
-            self.timer.mark(str(i))
-        assert len(self.timer.data['marks']) == 5
-        assert [m['message'] for m in self.timer.data['marks']] == \
-            ['0', '1', '2', '3', '4']
-
-    def test_intervals(self):
-        fake_time = MagicMock()
-        with patch('teuthology.timer.time.time', fake_time):
-            self.timer = timer.Timer()
-            now = start_time = fake_time.return_value = time()
-            intervals = [0, 1, 1, 2, 3, 5, 8]
-            for i in intervals:
-                now += i
-                fake_time.return_value = now
-                self.timer.mark(str(i))
-
-        summed_intervals = [sum(intervals[:x + 1]) for x in range(len(intervals))]
-        result_intervals = [m['interval'] for m in self.timer.data['marks']]
-        assert result_intervals == summed_intervals
-        assert self.timer.data['start'] == \
-            self.timer.get_datetime_string(start_time)
-        assert self.timer.data['end'] == \
-            self.timer.get_datetime_string(start_time + summed_intervals[-1])
-        assert [m['message'] for m in self.timer.data['marks']] == \
-            [str(i) for i in intervals]
-        assert self.timer.data['elapsed'] == summed_intervals[-1]
-
-    def test_write(self):
-        _path = '/path'
-        _safe_dump = MagicMock(name='safe_dump')
-        with patch('teuthology.timer.yaml.safe_dump', _safe_dump):
-            with patch('teuthology.timer.open', mock_open(), create=True) as _open:
-                self.timer = timer.Timer(path=_path)
-                assert self.timer.path == _path
-                self.timer.write()
-                _open.assert_called_once_with(_path, 'w')
-                _safe_dump.assert_called_once_with(
-                    dict(),
-                    _open.return_value.__enter__.return_value,
-                    default_flow_style=False,
-                )
-
-    def test_sync(self):
-        _path = '/path'
-        _safe_dump = MagicMock(name='safe_dump')
-        with patch('teuthology.timer.yaml.safe_dump', _safe_dump):
-            with patch('teuthology.timer.open', mock_open(), create=True) as _open:
-                self.timer = timer.Timer(path=_path, sync=True)
-                assert self.timer.path == _path
-                assert self.timer.sync is True
-                self.timer.mark()
-                _open.assert_called_once_with(_path, 'w')
-                _safe_dump.assert_called_once_with(
-                    self.timer.data,
-                    _open.return_value.__enter__.return_value,
-                    default_flow_style=False,
-                )

teuthology/test/test_vps_os_vers_parameter_checking.py

@@ -1,84 +0,0 @@
-from unittest.mock import patch, Mock
-
-import teuthology.lock.util
-from teuthology import provision
-
-
-class TestVpsOsVersionParamCheck(object):
-
-    def setup(self):
-        self.fake_ctx = Mock()
-        self.fake_ctx.machine_type = 'vps'
-        self.fake_ctx.num_to_lock = 1
-        self.fake_ctx.lock = False
-
-        def fake_downburst_executable():
-            return ''
-
-        self.fake_downburst_executable = fake_downburst_executable
-
-    def test_ubuntu_precise(self):
-        self.fake_ctx.os_type = 'ubuntu'
-        self.fake_ctx.os_version = 'precise'
-        with patch.multiple(
-            provision.downburst,
-            downburst_executable=self.fake_downburst_executable,
-        ):
-            check_value = teuthology.lock.util.vps_version_or_type_valid(
-                self.fake_ctx.machine_type,
-                self.fake_ctx.os_type,
-                self.fake_ctx.os_version)
-
-        assert check_value
-
-    def test_ubuntu_number(self):
-        self.fake_ctx.os_type = 'ubuntu'
-        self.fake_ctx.os_version = '12.04'
-        with patch.multiple(
-            provision.downburst,
-            downburst_executable=self.fake_downburst_executable,
-        ):
-            check_value = teuthology.lock.util.vps_version_or_type_valid(
-                self.fake_ctx.machine_type,
-                self.fake_ctx.os_type,
-                self.fake_ctx.os_version)
-        assert check_value
-
-    def test_mixup(self):
-        self.fake_ctx.os_type = '6.5'
-        self.fake_ctx.os_version = 'rhel'
-        with patch.multiple(
-            provision.downburst,
-            downburst_executable=self.fake_downburst_executable,
-        ):
-            check_value = teuthology.lock.util.vps_version_or_type_valid(
-                self.fake_ctx.machine_type,
-                self.fake_ctx.os_type,
-                self.fake_ctx.os_version)
-        assert not check_value
-
-    def test_bad_type(self):
-        self.fake_ctx.os_type = 'aardvark'
-        self.fake_ctx.os_version = '6.5'
-        with patch.multiple(
-            provision.downburst,
-            downburst_executable=self.fake_downburst_executable,
-        ):
-            check_value = teuthology.lock.util.vps_version_or_type_valid(
-                self.fake_ctx.machine_type,
-                self.fake_ctx.os_type,
-                self.fake_ctx.os_version)
-        assert not check_value
-
-    def test_bad_version(self):
-        self.fake_ctx.os_type = 'rhel'
-        self.fake_ctx.os_version = 'vampire_bat'
-        with patch.multiple(
-            provision.downburst,
-            downburst_executable=self.fake_downburst_executable,
-        ):
-            check_value = teuthology.lock.util.vps_version_or_type_valid(
-                self.fake_ctx.machine_type,
-                self.fake_ctx.os_type,
-                self.fake_ctx.os_version)
-        assert not check_value