def test__run_scenario_aborted(self): runner = constant.ConstantScenarioRunner(self.task, self.config) runner.abort() runner._run_scenario(fakes.FakeScenario, "do_it", self.context, self.args) self.assertEqual(len(runner.result_queue), 0)
def test_run(self, mock_ctx_manager, mock_osclients): runner = constant.ConstantScenarioRunner(mock.MagicMock(), self.fake_endpoints, mock.MagicMock()) mock_ctx_manager.run.return_value = base.ScenarioRunnerResult([]) scenario_name = "NovaServers.boot_server_from_volume_and_delete" config_kwargs = {"image": {"id": 1}, "flavor": {"id": 1}} result = runner.run(scenario_name, {"some_ctx": 2}, config_kwargs) self.assertEqual(result, mock_ctx_manager.run.return_value) cls_name, method_name = scenario_name.split(".", 1) cls = base_scenario.Scenario.get_by_name(cls_name) context_obj = { "task": runner.task, "admin": { "endpoint": runner.admin_user }, "scenario_name": scenario_name, "config": { "cleanup": ["nova", "cinder"], "some_ctx": 2, "users": {} } } expected = [ context_obj, runner._run_scenario, cls, method_name, context_obj, config_kwargs ] mock_ctx_manager.run.assert_called_once_with(*expected)
def test__run_scenario(self): runner = constant.ConstantScenarioRunner(self.task, self.config) runner._run_scenario(fakes.FakeScenario, "do_it", self.context, self.args) self.assertEqual(len(runner.result_queue), self.config["times"]) for result in runner.result_queue: self.assertIsNotNone(base.ScenarioRunnerResult(result))
def test_run_scenario_constantly_for_times(self): runner = constant.ConstantScenarioRunner( None, [self.context["admin"]["endpoint"]], self.config) result = runner._run_scenario(fakes.FakeScenario, "do_it", self.context, self.args) self.assertEqual(len(result), self.config["times"]) self.assertIsNotNone(base.ScenarioRunnerResult(result))
def test__run_scenario_exception(self): runner = constant.ConstantScenarioRunner(self.task, self.config) runner._run_scenario(fakes.FakeScenario, "something_went_wrong", self.context, self.args) self.assertEqual(len(runner.result_queue), self.config["times"]) for result in runner.result_queue: self.assertIsNotNone(base.ScenarioRunnerResult(result)) self.assertIn("error", runner.result_queue[0])
def test__run_scenario_constantly_for_times_timeout(self): runner = constant.ConstantScenarioRunner(None, self.config) runner._run_scenario(fakes.FakeScenario, "raise_timeout", self.context, self.args) self.assertEqual(len(runner.result_queue), self.config["times"]) for result in runner.result_queue: self.assertIsNotNone(base.ScenarioRunnerResult(result)) self.assertIn("error", runner.result_queue[0])
def test_run_scenario_constantly_for_times_exception(self): runner = constant.ConstantScenarioRunner( None, [self.context["admin"]["endpoint"]], self.config) result = runner._run_scenario(fakes.FakeScenario, "something_went_wrong", self.context, self.args) self.assertEqual(len(result), self.config["times"]) self.assertIsNotNone(base.ScenarioRunnerResult(result)) self.assertIn('error', result[0])
def test_abort(self): runner = constant.ConstantScenarioRunner(self.task, self.config) self.assertFalse(runner.aborted.is_set()) runner.abort() self.assertTrue(runner.aborted.is_set())
def test_that_cpu_count_is_adjusted_properly(self, mock_join_processes, mock_create_pool, mock_log, mock_cpu_count, mock_queue): samples = [ { "input": { "times": 20, "concurrency": 20, "type": "constant", "max_cpu_count": 1 }, "real_cpu": 2, "expected": { # max_cpu_used equals to min(max_cpu_count, real_cpu) "max_cpu_used": 1, # processes_to_start equals to # min(max_cpu_used, times, concurrency)) "processes_to_start": 1, "concurrency_per_worker": 20, "concurrency_overhead": 0, } }, { "input": { "times": 20, "concurrency": 15, "type": "constant", "max_cpu_count": 3 }, "real_cpu": 2, "expected": { "max_cpu_used": 2, "processes_to_start": 2, "concurrency_per_worker": 7, "concurrency_overhead": 1, } }, { "input": { "times": 20, "concurrency": 1, "type": "constant", "max_cpu_count": 3 }, "real_cpu": 2, "expected": { "max_cpu_used": 2, "processes_to_start": 1, "concurrency_per_worker": 1, "concurrency_overhead": 0, } }, { "input": { "times": 2, "concurrency": 5, "type": "constant", "max_cpu_count": 4 }, "real_cpu": 4, "expected": { "max_cpu_used": 4, "processes_to_start": 2, "concurrency_per_worker": 2, "concurrency_overhead": 1, } } ] for sample in samples: mock_log.reset_mock() mock_cpu_count.reset_mock() mock_create_pool.reset_mock() mock_join_processes.reset_mock() mock_queue.reset_mock() mock_cpu_count.return_value = sample["real_cpu"] runner = constant.ConstantScenarioRunner(self.task, sample["input"]) runner._run_scenario(fakes.FakeScenario, "do_it", self.context, self.args) mock_cpu_count.assert_called_once_with() mock_log.assert_called_once_with( times=sample["input"]["times"], concurrency=sample["input"]["concurrency"], timeout=0, max_cpu_used=sample["expected"]["max_cpu_used"], processes_to_start=sample["expected"]["processes_to_start"], concurrency_per_worker=( sample["expected"]["concurrency_per_worker"]), concurrency_overhead=( sample["expected"]["concurrency_overhead"])) args, kwargs = mock_create_pool.call_args self.assertIn(sample["expected"]["processes_to_start"], args) self.assertIn(constant._worker_process, args) mock_join_processes.assert_called_once_with( mock_create_pool(), mock_queue())