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())
