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