def test__run_scenario(self, mock_sleep):
context = fakes.FakeUserContext({}).context
context["task"] = {"uuid": "fake_uuid"}
config = {"times": 20, "rps": 20, "timeout": 5}
runner = rps.RPSScenarioRunner(None, config)
runner._run_scenario(fakes.FakeScenario, "do_it", context, {})
self.assertEqual(len(runner.result_queue), config["times"])
for result in runner.result_queue:
self.assertIsNotNone(base.ScenarioRunnerResult(result))
def setUp(self):
super(ConstantForDurationScenarioRunnerTestCase, self).setUp()
self.config = {
"duration": 0,
"concurrency": 2,
"timeout": 2,
"type": "constant_for_duration"
}
self.context = fakes.FakeUserContext({
"task": {
"uuid": "uuid"
}
}).context
self.args = {"a": 1}
def test_run_scenario(self, mock_run_once):
times = 5
result = {"duration": 10, "idle_duration": 0, "error": [],
"scenario_output": {}, "atomic_actions": {}}
mock_run_once.return_value = result
expected_results = [result for i in range(times)]
runner = serial.SerialScenarioRunner(mock.MagicMock(),
{"times": times})
runner._run_scenario(fakes.FakeScenario, "do_it",
fakes.FakeUserContext({}).context, {})
self.assertEqual(len(runner.result_queue), times)
results = list(runner.result_queue)
self.assertEqual(results, expected_results)
def test_run_scenario_once_with_scenario_output(self, mock_clients,
mock_rtimer):
context = base._get_scenario_context(fakes.FakeUserContext({}).context)
args = (1, fakes.FakeScenario, "with_output", context, {})
result = base._run_scenario_once(args)
expected_result = {
"duration": fakes.FakeTimer().duration(),
"timestamp": fakes.FakeTimer().timestamp(),
"idle_duration": 0,
"error": [],
"scenario_output": fakes.FakeScenario().with_output(),
"atomic_actions": {}
}
self.assertEqual(expected_result, result)
def test_run_scenario_once_internal_logic(self, mock_clients):
mock_clients.Clients.return_value = "cl"
context = base._get_scenario_context(fakes.FakeUserContext({}).context)
scenario_cls = mock.MagicMock()
args = (2, scenario_cls, "test", context, {})
base._run_scenario_once(args)
expected_calls = [
mock.call(context=context, admin_clients="cl", clients="cl"),
mock.call().test(),
mock.call().idle_duration(),
mock.call().idle_duration(),
mock.call().atomic_actions()
]
scenario_cls.assert_has_calls(expected_calls, any_order=True)
def setUp(self):
super(ConstantScenarioRunnerTestCase, self).setUp()
self.config = {
"times": 4,
"concurrency": 2,
"timeout": 2,
"type": "constant",
"max_cpu_count": 2
}
self.context = fakes.FakeUserContext({
"task": {
"uuid": "uuid"
}
}).context
self.args = {"a": 1}
self.task = mock.MagicMock()
def test_run_scenario_once_exception(self, mock_clients, mock_rtimer):
context = base._get_scenario_context(fakes.FakeUserContext({}).context)
args = (1, fakes.FakeScenario, "something_went_wrong", context, {})
result = base._run_scenario_once(args)
expected_error = result.pop("error")
expected_result = {
"duration": fakes.FakeTimer().duration(),
"timestamp": fakes.FakeTimer().timestamp(),
"idle_duration": 0,
"scenario_output": {
"errors": "",
"data": {}
},
"atomic_actions": {}
}
self.assertEqual(expected_result, result)
self.assertEqual(expected_error[:2],
["Exception", "Something went wrong"])
def setUp(self):
super(ConstantForDurationScenarioRunnerTestCase, self).setUp()
duration = 0
concurrency = 2
timeout = 2
type = consts.RunnerType.CONSTANT_FOR_DURATION
self.config = {
"duration": duration,
"concurrency": concurrency,
"timeout": timeout,
"type": type
}
self.context = fakes.FakeUserContext({
"task": {
"uuid": "uuid"
}
}).context
self.args = {"a": 1}
def setUp(self):
super(ConstantScenarioRunnerTestCase, self).setUp()
times = 4
concurrency = 2
timeout = 2
type = consts.RunnerType.CONSTANT
self.config = {
"times": times,
"concurrency": concurrency,
"timeout": timeout,
"type": type
}
self.context = fakes.FakeUserContext({
"task": {
"uuid": "uuid"
}
}).context
self.args = {"a": 1}
def test__run_scenario_aborted(self):
runner = serial.SerialScenarioRunner(mock.MagicMock(), {"times": 5})
runner.abort()
runner._run_scenario(fakes.FakeScenario, "do_it",
fakes.FakeUserContext({}).context, {})
self.assertEqual(len(runner.result_queue), 0)
def test_that_cpu_count_is_adjusted_properly(self, mock_join_processes,
mock_create_pool, mock_log,
mock_cpu_count, mock_queue):
context = fakes.FakeUserContext({}).context
context["task"] = {"uuid": "fake_uuid"}
samples = [
{
"input": {"times": 20, "rps": 20, "max_concurrency": 10,
"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, max_concurrency))
"processes_to_start": 1,
"rps_per_worker": 20,
"times_per_worker": 20,
"times_overhead": 0,
"concurrency_per_worker": 10,
"concurrency_overhead": 0
}
},
{
"input": {"times": 20, "rps": 9, "max_concurrency": 5,
"max_cpu_count": 3},
"real_cpu": 4,
"expected": {
"max_cpu_used": 3,
"processes_to_start": 3,
"rps_per_worker": 3,
"times_per_worker": 6,
"times_overhead": 2,
"concurrency_per_worker": 1,
"concurrency_overhead": 2
}
},
{
"input": {"times": 10, "rps": 20, "max_concurrency": 12,
"max_cpu_count": 20},
"real_cpu": 20,
"expected": {
"max_cpu_used": 20,
"processes_to_start": 10,
"rps_per_worker": 2,
"times_per_worker": 1,
"times_overhead": 0,
"concurrency_per_worker": 1,
"concurrency_overhead": 2
}
},
{
"input": {"times": 20, "rps": 20, "max_concurrency": 10,
"max_cpu_count": 20},
"real_cpu": 20,
"expected": {
"max_cpu_used": 20,
"processes_to_start": 10,
"rps_per_worker": 2,
"times_per_worker": 2,
"times_overhead": 0,
"concurrency_per_worker": 1,
"concurrency_overhead": 0
}
}
]
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 = rps.RPSScenarioRunner(self.task, sample["input"])
runner._run_scenario(fakes.FakeScenario, "do_it", context, {})
mock_cpu_count.assert_called_once_with()
mock_log.assert_called_once_with(
times=sample["input"]["times"],
timeout=0,
max_cpu_used=sample["expected"]["max_cpu_used"],
processes_to_start=sample["expected"]["processes_to_start"],
rps_per_worker=sample["expected"]["rps_per_worker"],
times_per_worker=sample["expected"]["times_per_worker"],
times_overhead=sample["expected"]["times_overhead"],
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(rps._worker_process, args)
mock_join_processes.assert_called_once_with(
mock_create_pool(),
mock_queue())
