def _test_engine_service_stop(self, service_delete_method, admin_context_method): cfg.CONF.set_default('periodic_interval', 60) self.patchobject(self.eng, 'service_manage_cleanup') self.patchobject(self.eng, 'reset_stack_status') self.patchobject(self.eng, 'service_manage_report') self.eng.start() # Add dummy thread group to test thread_group_mgr.stop() is executed? dtg1 = tools.DummyThreadGroup() dtg2 = tools.DummyThreadGroup() self.eng.thread_group_mgr.groups['sample-uuid1'] = dtg1 self.eng.thread_group_mgr.groups['sample-uuid2'] = dtg2 self.eng.service_id = 'sample-service-uuid' self.patchobject(self.eng.manage_thread_grp, 'stop', new=mock.Mock(wraps=self.eng.manage_thread_grp.stop)) self.patchobject(self.eng, '_stop_rpc_server', new=mock.Mock(wraps=self.eng._stop_rpc_server)) orig_stop = self.eng.thread_group_mgr.stop with mock.patch.object(self.eng.thread_group_mgr, 'stop') as stop: stop.side_effect = orig_stop self.eng.stop() # RPC server self.eng._stop_rpc_server.assert_called_once_with() if cfg.CONF.convergence_engine: # WorkerService self.eng.worker_service.stop.assert_called_once_with() # Wait for all active threads to be finished calls = [ mock.call('sample-uuid1', True), mock.call('sample-uuid2', True) ] self.eng.thread_group_mgr.stop.assert_has_calls(calls, True) # Manage Thread group self.eng.manage_thread_grp.stop.assert_called_with() # Service delete admin_context_method.assert_called_once_with() ctxt = admin_context_method.return_value service_delete_method.assert_called_once_with( ctxt, self.eng.service_id)
def test_set_watch_state(self, mock_ref): self._create_periodic_tasks() # Insert dummy watch rule into the DB rule = { u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure' } self.wr = watchrule.WatchRule(context=self.ctx, watch_name='OverrideAlarm', rule=rule, watch_data=[], stack_id=self.stack.id, state='NORMAL') self.wr.store() class DummyAction(object): def signal(self): return "dummyfoo" dummy_action = DummyAction() mock_ref.return_value = dummy_action # Replace the real stack threadgroup with a dummy one, so we can # check the function returned on ALARM is correctly scheduled dtg = tools.DummyThreadGroup() self.eng.thread_group_mgr.groups[self.stack.id] = dtg state = watchrule.WatchRule.NODATA result = self.eng.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state) self.assertEqual(state, result[rpc_api.WATCH_STATE_VALUE]) self.assertEqual( [], self.eng.thread_group_mgr.groups[self.stack.id].threads) state = watchrule.WatchRule.NORMAL result = self.eng.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state) self.assertEqual(state, result[rpc_api.WATCH_STATE_VALUE]) self.assertEqual( [], self.eng.thread_group_mgr.groups[self.stack.id].threads) state = watchrule.WatchRule.ALARM result = self.eng.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state) self.assertEqual(state, result[rpc_api.WATCH_STATE_VALUE]) self.assertEqual( [dummy_action.signal], self.eng.thread_group_mgr.groups[self.stack.id].threads) mock_ref.assert_called_once_with('WebServerRestartPolicy')
def test_stack_create_nested(self, mock_validate, mock_tg): convergence_engine = cfg.CONF.convergence_engine stack_name = 'service_create_nested_test_stack' mock_tg.return_value = tools.DummyThreadGroup() stk = tools.get_stack(stack_name, self.ctx, with_params=True) tmpl_id = stk.t.store(self.ctx) mock_load = self.patchobject(templatem.Template, 'load', return_value=stk.t) mock_stack = self.patchobject(stack, 'Stack', return_value=stk) result = self.man.create_stack(self.ctx, stack_name, None, None, None, {}, nested_depth=1, template_id=tmpl_id) self.assertEqual(stk.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) mock_load.assert_called_once_with(self.ctx, tmpl_id) mock_stack.assert_called_once_with(self.ctx, stack_name, stk.t, owner_id=None, nested_depth=1, user_creds_id=None, stack_user_project_id=None, convergence=convergence_engine, parent_resource=None) mock_validate.assert_called_once_with()
def _test_stack_create(self, stack_name, mock_validate, mock_tg): mock_tg.return_value = tools.DummyThreadGroup() params = {'foo': 'bar'} template = '{ "Template": "data" }' stk = tools.get_stack(stack_name, self.ctx) mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t) mock_env = self.patchobject(environment, 'Environment', return_value=stk.env) mock_stack = self.patchobject(stack, 'Stack', return_value=stk) result = self.man.create_stack(self.ctx, stack_name, template, params, None, {}) self.assertEqual(stk.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) mock_tmpl.assert_called_once_with(template, files=None, env=stk.env) mock_env.assert_called_once_with(params) mock_stack.assert_called_once_with(self.ctx, stack_name, stk.t, owner_id=None, nested_depth=0, user_creds_id=None, stack_user_project_id=None, convergence=False, parent_resource=None) mock_validate.assert_called_once_with()
def test_stack_delete_current_engine_active_lock(self, mock_acquire, mock_try, mock_load): self.man.start() stack_name = 'service_delete_test_stack_current_active_lock' stack = tools.get_stack(stack_name, self.ctx) sid = stack.store() # Insert a fake lock into the db stack_lock_object.StackLock.create(stack.id, self.man.engine_id) # Create a fake ThreadGroup too self.man.thread_group_mgr.groups[stack.id] = tools.DummyThreadGroup() st = stack_object.Stack.get_by_id(self.ctx, sid) mock_load.return_value = stack mock_try.return_value = self.man.engine_id mock_stop = self.patchobject(self.man.thread_group_mgr, 'stop') self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) mock_load.assert_called_with(self.ctx, stack=st) self.assertEqual(2, len(mock_load.mock_calls)) mock_try.assert_called_once_with() mock_acquire.assert_called_once_with(True) mock_stop.assert_called_once_with(stack.id)
def _test_stack_create(self, stack_name, mock_validate, mock_tg, environment_files=None, files_container=None, error=False): mock_tg.return_value = tools.DummyThreadGroup() params = {'foo': 'bar'} template = '{ "Template": "data" }' stk = tools.get_stack(stack_name, self.ctx, convergence=cfg.CONF.convergence_engine) files = None if files_container: files = {'/env/test.yaml': "{'resource_registry': {}}"} mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t) mock_env = self.patchobject(environment, 'Environment', return_value=stk.env) mock_stack = self.patchobject(stack, 'Stack', return_value=stk) mock_merge = self.patchobject(env_util, 'merge_environments') if not error: result = self.man.create_stack(self.ctx, stack_name, template, params, None, {}, environment_files=environment_files, files_container=files_container) self.assertEqual(stk.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) mock_tmpl.assert_called_once_with(template, files=files) mock_env.assert_called_once_with(params) mock_stack.assert_called_once_with( self.ctx, stack_name, stk.t, owner_id=None, nested_depth=0, user_creds_id=None, stack_user_project_id=None, convergence=cfg.CONF.convergence_engine, parent_resource=None) if environment_files: mock_merge.assert_called_once_with(environment_files, files, params, mock.ANY) mock_validate.assert_called_once_with() else: ex = self.assertRaises(dispatcher.ExpectedException, self.man.create_stack, self.ctx, stack_name, template, params, None, {}, environment_files=environment_files, files_container=files_container) self.assertEqual(exception.NotFound, ex.exc_info[0]) self.assertIn( 'Could not fetch files from container ' 'test_container, reason: error.', six.text_type(ex.exc_info[1]))