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)
