def test_run_scenario_internal_logic(self, mock_time, mock_pool, mock_result): context = fakes.FakeUserContext({}).context config = {"times": 4, "period": 0, "timeout": 5} runner = periodic.PeriodicScenarioRunner( None, [context["admin"]["endpoint"]], config) mock_pool_inst = mock.MagicMock() mock_pool.ThreadPool.return_value = mock_pool_inst runner._run_scenario(fakes.FakeScenario, "do_it", context, {}) exptected_pool_inst_call = [] for i in range(config["times"]): args = ( base._run_scenario_once, ((i, fakes.FakeScenario, "do_it", base._get_scenario_context(context), {}),) ) exptected_pool_inst_call.append(mock.call.apply_async(*args)) for i in range(config["times"]): call = mock.call.apply_async().get(timeout=5) exptected_pool_inst_call.append(call) mock_pool.assert_has_calls([mock.call.ThreadPool(processes=1)]) mock_pool_inst.assert_has_calls(exptected_pool_inst_call) mock_time.assert_has_calls([])
def test_run_scenario(self): context = fakes.FakeUserContext({}).context config = {"times": 3, "period": 0, "timeout": 5} runner = periodic.PeriodicScenarioRunner( None, [context["admin"]["endpoint"]], config) result = runner._run_scenario(fakes.FakeScenario, "do_it", context, {}) self.assertEqual(len(result), config["times"]) self.assertIsNotNone(base.ScenarioRunnerResult(result))
def test_run_scenario_exception(self): context = fakes.FakeUserContext({}).context config = {"times": 4, "period": 0} runner = periodic.PeriodicScenarioRunner( None, [context["admin"]["endpoint"]], config) result = runner._run_scenario(fakes.FakeScenario, "something_went_wrong", context, {}) self.assertEqual(len(result), config["times"]) self.assertIsNotNone(base.ScenarioRunnerResult(result))
def setUp(self): super(ConstantForDurationScenarioRunnerTeestCase, 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_with_statement(self): fake_user_ctx = fakes.FakeUserContext({}).context fake_user_ctx["config"] = {"cleanup": ["nova"]} user_cleaner = user_cleanup.UserCleanup(fake_user_ctx) user_cleaner.setup() user_cleaner._cleanup_resources = mock.MagicMock() with user_cleaner as cleaner: self.assertEqual(user_cleaner, cleaner) user_cleaner._cleanup_resources.assert_called_once_with()
def test_with_statement(self): fake_admin_ctx = fakes.FakeUserContext({}).context fake_admin_ctx["config"] = {"admin_cleanup": ["keystone"]} admin_cleaner = admin_cleanup.AdminCleanup(fake_admin_ctx) admin_cleaner.setup() admin_cleaner._cleanup_resources = mock.MagicMock() with admin_cleaner as cleaner: self.assertEqual(admin_cleaner, cleaner) admin_cleaner._cleanup_resources.assert_called_once_with()
def test_with_statement(self): fake_user_ctx = fakes.FakeUserContext({}).context fake_user_ctx["config"] = {"cleanup": ["nova"]} res_cleaner = cleanup_ctx.ResourceCleaner(fake_user_ctx) res_cleaner.setup() res_cleaner._cleanup_users_resources = mock.MagicMock() res_cleaner._cleanup_admin_resources = mock.MagicMock() with res_cleaner as cleaner: self.assertEqual(res_cleaner, cleaner) res_cleaner._cleanup_users_resources.assert_called_once_with() res_cleaner._cleanup_admin_resources.assert_called_once_with()
def test_run_scenario_once_without_scenario_output(self, mock_clients, mock_rutils): mock_rutils.Timer = fakes.FakeTimer context = base._get_scenario_context(fakes.FakeUserContext({}).context) args = (1, fakes.FakeScenario, "do_it", context, {}) result = base._run_scenario_once(args) expected_result = { "duration": fakes.FakeTimer().duration(), "idle_duration": 0, "error": [], "scenario_output": {"errors": "", "data": {}}, "atomic_actions": [] } self.assertEqual(expected_result, result)
def test_run_scenario_once_exception(self, mock_clients, mock_rutils): mock_rutils.Timer = fakes.FakeTimer 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(), "idle_duration": 0, "scenario_output": {"errors": "", "data": {}}, "atomic_actions": [] } self.assertEqual(expected_result, result) self.assertEqual(expected_error[:2], [str(Exception), "Something went wrong"])
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(), self.fake_endpoints, {"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_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)