def setUp(self): super(TestNotificationBase, self).setUp() self.ctx = utils.dummy_context() service_id = uuidutils.generate_uuid() self.service_obj = objects.Service.create( self.ctx, service_id, self.fake_service['host'], self.fake_service['binary'], self.fake_service['topic']) self.my_obj = TestObject(field_1='test1', field_2=42, not_important_field=13) self.payload = TestPayload(extra_field='test string') self.payload.populate_schema(source_field=self.my_obj) self.notification = TestNotification( event_type=notification.EventType( object='test_object', action=fields.NotificationAction.UPDATE, phase=fields.NotificationPhase.START), publisher=notification.NotificationPublisher.from_service_obj( self.service_obj), priority=fields.NotificationPriority.INFO, payload=self.payload)
def setUp(self): super(TestLoadBalancingPolicyOperations, self).setUp() self.context = utils.dummy_context() self.spec = { 'type': 'senlin.policy.loadbalance', 'version': '1.0', 'properties': { 'pool': { 'protocol': 'HTTP', 'protocol_port': 80, 'subnet': 'test-subnet', 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True, 'session_persistence': { 'type': 'SOURCE_IP', 'cookie_name': 'whatever' } }, 'vip': { 'address': '192.168.1.100', 'subnet': 'test-subnet', 'connection_limit': 500, 'protocol': 'HTTP', 'protocol_port': 80, 'admin_state_up': True, } } } sd = mock.Mock() self.patchobject(driver_base, 'SenlinDriver', return_value=sd) self.lb_driver = mock.Mock() sd.loadbalancing.return_value = self.lb_driver self.patchobject(oslo_context, 'get_current')
def setUp(self): super(ProfileTypeTest, self).setUp() self.ctx = utils.dummy_context(project='profile_type_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_profile('TestProfile', fakes.TestProfile)
def test_cluster_list_project_safe(self, notify): new_ctx = utils.dummy_context(project='a_diff_project') spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': {'INT': 10, 'STR': 'string'}, } p1 = self.eng.profile_create(self.ctx, 'p-test-1', spec, permission='1111') p2 = self.eng.profile_create(new_ctx, 'p-test-2', spec, permission='1111') c1 = self.eng.cluster_create(self.ctx, 'c1', 0, p1['id']) c2 = self.eng.cluster_create(new_ctx, 'c2', 0, p2['id']) # default is project_safe result = self.eng.cluster_list(self.ctx) self.assertIsInstance(result, list) self.assertEqual(1, len(result)) self.assertEqual(c1['id'], result[0]['id']) result = self.eng.cluster_list(new_ctx) self.assertIsInstance(result, list) self.assertEqual(1, len(result)) self.assertEqual(c2['id'], result[0]['id']) # try project_safe set to False result = self.eng.cluster_list(self.ctx, project_safe=False) self.assertIsInstance(result, list) self.assertEqual(2, len(result)) self.assertEqual(c1['id'], result[0]['id']) self.assertEqual(c2['id'], result[1]['id'])
def setUp(self): super(TestHealthPolicy, self).setUp() self.context = utils.dummy_context() self.spec = { 'type': 'senlin.policy.health', 'version': '1.0', 'properties': { 'detection': { 'type': 'NODE_STATUS_POLLING', 'options': { 'interval': 60 } }, 'recovery': { 'fencing': ['COMPUTE'], 'actions': ['REBUILD'] } } } cluster = mock.Mock() cluster.id = 'CLUSTER_ID' node = mock.Mock() node.status = 'ACTIVE' cluster.nodes = [node] self.cluster = cluster self.patch('senlin.rpc.client.EngineClient') self.hp = health_policy.HealthPolicy('test-policy', self.spec)
def setUp(self): super(TestNeutronLBaaSDriver, self).setUp() self.context = utils.dummy_context() self.conn_params = self.context.to_dict() self.lb_driver = lbaas.LoadBalancerDriver(self.conn_params) self.patchobject(neutron_v2, 'NeutronClient') self.nc = self.lb_driver.nc() self.vip = { 'subnet': 'subnet-01', 'address': '192.168.1.100', 'admin_state_up': True, 'protocol': 'HTTP', 'protocol_port': 80, 'connection_limit': 50 } self.pool = { 'lb_method': 'ROUND_ROBIN', 'protocol': 'HTTP', 'admin_state_up': True } self.hm = { "type": "HTTP", "delay": "1", "timeout": 1, "max_retries": 5, "pool_id": "POOL_ID", "admin_state_up": True, "http_method": "GET", "url_path": "/index.html", "expected_codes": "200,201,202" }
def setUp(self): super(SenlinLockTest, self).setUp() self.ctx = utils.dummy_context() ret = mock.Mock(owner='ENGINE', id='ACTION_ABC') self.stub_get = self.patchobject(ao.Action, 'get', return_value=ret)
def setUp(self): super(ClusterTest, self).setUp() self.ctx = utils.dummy_context(project='cluster_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() self.eng.dispatcher = mock.Mock() env = environment.global_env() env.register_profile('TestProfile', fakes.TestProfile) env.register_policy('TestPolicy', fakes.TestPolicy) spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': {'INT': 10, 'STR': 'string'}, } self.profile = self.eng.profile_create(self.ctx, 'p-test', spec, permission='1111') spec = { 'type': 'TestPolicy', 'version': '1.0', 'properties': {'KEY2': 3} } self.policy = self.eng.policy_create(self.ctx, 'policy_1', spec, cooldown=60, level=50)
def setUp(self): super(TriggerTest, self).setUp() self.ctx = utils.dummy_context(project='trigger_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_trigger('TestTrigger', fakes.TestTrigger)
def test_cluster_get_by_short_id(self): cid1 = 'same-part-unique-part' cid2 = 'same-part-part-unique' cluster1 = shared.create_cluster(self.ctx, self.profile, id=cid1, name='cluster-1') cluster2 = shared.create_cluster(self.ctx, self.profile, id=cid2, name='cluster-2') for x in range(len('same-part-')): self.assertRaises(exception.MultipleChoices, db_api.cluster_get_by_short_id, self.ctx, cid1[:x]) res = db_api.cluster_get_by_short_id(self.ctx, cid1[:11]) self.assertEqual(cluster1.id, res.id) res = db_api.cluster_get_by_short_id(self.ctx, cid2[:11]) self.assertEqual(cluster2.id, res.id) res = db_api.cluster_get_by_short_id(self.ctx, 'non-existent') self.assertIsNone(res) ctx_new = utils.dummy_context(project='different_project_id') res = db_api.cluster_get_by_short_id(ctx_new, cid1[:11]) self.assertIsNone(res)
def _test_engine_api(self, method, rpc_method, **kwargs): ctxt = utils.dummy_context() expected_retval = 'foo' if method == 'call' else None kwargs.pop('version', None) if 'expected_message' in kwargs: expected_message = kwargs['expected_message'] del kwargs['expected_message'] else: expected_message = self.rpcapi.make_msg(method, **kwargs) cast_and_call = [ 'profile_delete', 'policy_delete', 'cluster_delete', 'node_delete', 'receiver_delete', 'webhook_delete', ] if rpc_method == 'call' and method in cast_and_call: kwargs['cast'] = False mock_rpc_method = self.patchobject(self.rpcapi, rpc_method, return_value=expected_retval) retval = getattr(self.rpcapi, method)(ctxt, **kwargs) self.assertEqual(expected_retval, retval) expected_args = [ctxt, expected_message, mock.ANY] actual_args, _ = mock_rpc_method.call_args for expected_arg, actual_arg in zip(expected_args, actual_args): self.assertEqual(expected_arg, actual_arg)
def test_get_delete_candidates_no_deletion_data_resize(self, m_nodes_random, m_parse_param, m_cluster_get, m_node_get): def _parse_param(action, cluster): action.data = {'deletion': {'count': 2}} action = mock.Mock() self.context = utils.dummy_context() action.data = {} action.action = consts.CLUSTER_RESIZE m_parse_param.side_effect = _parse_param m_node_get.return_value = ['node1', 'node2', 'node3'] m_cluster_get.return_value = 'cluster1' m_nodes_random.return_value = ['node1', 'node3'] policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec) res = policy._get_delete_candidates('CLUSTERID', action) m_cluster_get.assert_called_once_with(action.context, 'CLUSTERID') m_parse_param.assert_called_once_with(action, 'cluster1') m_node_get.assert_called_once_with(action.context, cluster_id='CLUSTERID') m_nodes_random.assert_called_once_with(['node1', 'node2', 'node3'], 2) self.assertEqual(['node1', 'node3'], res)
def test_receiver_get_admin_context(self): admin_ctx = utils.dummy_context(project='a-different-project', is_admin=True) r = self._create_receiver(self.ctx) res = db_api.receiver_get(admin_ctx, r.id, project_safe=True) self.assertIsNotNone(res)
def test_get_delete_candidates_deletion_with_candidates(self): action = mock.Mock() self.context = utils.dummy_context() action.data = {'deletion': {'count': 1, 'candidates': ['node3']}} policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec) res = policy._get_delete_candidates('CLUSTERID', action) self.assertEqual(['node3'], res)
def setUp(self): super(TestNeutronV2Driver, self).setUp() self.context = utils.dummy_context() self.conn_params = self.context.to_dict() self.conn = mock.Mock() with mock.patch.object(sdk, 'create_connection') as mock_creare_conn: mock_creare_conn.return_value = self.conn self.nc = neutron_v2.NeutronClient(self.context)
def test_trigger_get_diff_project(self): trigger = self._create_trigger(self.ctx) new_ctx = utils.dummy_context(project='a-different-project') retobj = db_api.trigger_get(new_ctx, trigger.id) self.assertIsNone(retobj) retobj = db_api.trigger_get(new_ctx, trigger.id, project_safe=False) self.assertIsNotNone(retobj) self.assertEqual(trigger.id, retobj.id)
def test_receiver_get_all_with_admin_context(self): self._create_receiver(self.ctx, name='receiver1') self._create_receiver(self.ctx, name='receiver2') admin_ctx = utils.dummy_context(project='a-different-project', is_admin=True) results = db_api.receiver_get_all(admin_ctx, project_safe=True) self.assertEqual(2, len(results))
def test_node_get_all_with_admin_context(self): shared.create_node(self.ctx, None, self.profile, name='node1') shared.create_node(self.ctx, None, self.profile, name='node2') admin_ctx = utils.dummy_context(project='a_different_project', is_admin=True) results = db_api.node_get_all(admin_ctx, project_safe=True) self.assertEqual(2, len(results))
def test_policy_get_admin_context(self): data = self.new_policy_data() policy = db_api.policy_create(self.ctx, data) admin_ctx = utils.dummy_context(project='a-different-project', is_admin=True) res = db_api.policy_get(admin_ctx, policy.id, project_safe=True) self.assertIsNotNone(res)
def test_action_get_project_safe(self): parser.simple_parse(shared.sample_action) action = _create_action(self.ctx) new_ctx = utils.dummy_context(project='another-project') retobj = db_api.action_get(new_ctx, action.id, project_safe=True) self.assertIsNone(retobj) retobj = db_api.action_get(new_ctx, action.id, project_safe=False) self.assertIsNotNone(retobj)
def test_cluster_get_with_admin_context(self): cluster = shared.create_cluster(self.ctx, self.profile) admin_ctx = utils.dummy_context(project='another-project', is_admin=True) ret_cluster = db_api.cluster_get(admin_ctx, cluster.id, project_safe=True) self.assertEqual(cluster.id, ret_cluster.id) self.assertEqual('db_test_cluster_name', ret_cluster.name)
def setUp(self): messaging.setup("fake://", optional=True) self.addCleanup(messaging.cleanup) self.context = utils.dummy_context() # self.stubs = stubout.StubOutForTesting() self.rpcapi = rpc_client.EngineClient() super(EngineRpcAPITestCase, self).setUp()
def test_event_get_diff_project(self): event = self.create_event(self.ctx) new_ctx = utils.dummy_context(project='a-different-project') res = db_api.event_get(new_ctx, event.id) self.assertIsNone(res) res = db_api.event_get(new_ctx, event.id, project_safe=False) self.assertIsNotNone(res) self.assertEqual(event.id, res.id)
def setUp(self): super(TestDispatcher, self).setUp() self.context = utils.dummy_context() self.thm = scheduler.ThreadGroupManager() self.svc = service.EngineService('HOST', 'TOPIC') self.svc.engine_id = '1234'
def test_load_all_diff_project(self): self._create_db_policy(name='policy-1', id='ID1') self._create_db_policy(name='policy-2', id='ID2') new_ctx = utils.dummy_context(project='a-different-project') res = policy_base.Policy.load_all(new_ctx) self.assertEqual(0, len(list(res))) res = policy_base.Policy.load_all(new_ctx, project_safe=False) self.assertEqual(2, len(list(res)))
def test_load_all_diff_project(self): utils.create_policy(self.ctx, UUID1, 'policy-1') utils.create_policy(self.ctx, UUID2, 'policy-2') new_ctx = utils.dummy_context(project='a-different-project') res = pb.Policy.load_all(new_ctx) self.assertEqual(0, len(list(res))) res = pb.Policy.load_all(new_ctx, project_safe=False) self.assertEqual(2, len(list(res)))
def test_profile_get_diff_project(self): profile = shared.create_profile(self.ctx) new_ctx = utils.dummy_context(project='a-different-project') res = db_api.profile_get(new_ctx, profile.id) self.assertIsNone(res) res = db_api.profile_get(new_ctx, profile.id, project_safe=False) self.assertIsNotNone(res) self.assertEqual(profile.id, res.id)
def test_receiver_load_all_diff_project(self): self._create_receiver('receiver-1', 'ID1') self._create_receiver('receiver-2', 'ID2') new_context = utils.dummy_context(project='a-different-project') result = rb.Receiver.load_all(new_context) self.assertEqual(0, len(list(result))) result = rb.Receiver.load_all(new_context, project_safe=False) self.assertEqual(2, len(list(result)))
def test_profile_get_all_admin_context(self): ids = ['profile1', 'profile2'] for pid in ids: shared.create_profile(self.ctx, id=pid) admin_ctx = utils.dummy_context(project='a-different-project', is_admin=True) profiles = db_api.profile_get_all(admin_ctx, project_safe=True) self.assertEqual(2, len(profiles))
def test_webhook_get_diff_project(self): new_ctx = utils.dummy_context(project='a-different-project') webhook = shared.create_webhook(self.ctx, self.obj_id, self.obj_type, self.action) res = db_api.webhook_get(new_ctx, webhook.id) self.assertIsNone(res) res = db_api.webhook_get(new_ctx, webhook.id, project_safe=False) self.assertIsNotNone(res) self.assertEqual(webhook.id, res.id)
def setUp(self): super(ClusterReplaceNodesTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(ActionPolicyCheckTest, self).setUp() self.ctx = utils.dummy_context() environment.global_env().register_policy('DummyPolicy', fakes.TestPolicy)
def setUp(self): super(DBAPIPolicyTest, self).setUp() self.ctx = utils.dummy_context() self.profile = shared.create_profile(self.ctx) self.cluster = shared.create_cluster(self.ctx, self.profile)
def setUp(self): super(DBAPICredentialTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(SenlinLockTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(ReceiverTest, self).setUp() self.ctx = utils.dummy_context(project='receiver_test_project') self.svc = service.ConductorService('host-a', 'topic-a')
def test_profile_get_admin_context(self): profile = shared.create_profile(self.ctx) admin_ctx = utils.dummy_context(project='a-different-project', is_admin=True) res = db_api.profile_get(admin_ctx, profile.id, project_safe=True) self.assertIsNotNone(res)
def setUp(self): super(TestCluster, self).setUp() self.context = utils.dummy_context(project='cluster_test_project')
def setUp(self): super(TestWebhook, self).setUp() self.context = utils.dummy_context()
def setUp(self): super(ClusterUpdatePolicyTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(TestClusterPolicy, self).setUp() self.context = utils.dummy_context()
def setUp(self): super(ClusterRecoverTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(TestEvent, self).setUp() self.context = utils.dummy_context()
def setUp(self): super(CredentialTest, self).setUp() self.ctx = utils.dummy_context(user_id='fake_user_id', project='fake_project_id') self.eng = service.EngineService('host-a', 'topic-a')
def setUp(self): super(TestCluster, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(ClusterDeleteTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(ProfileTypeTest, self).setUp() self.ctx = utils.dummy_context(project='profile_type_test_project') self.eng = service.EngineService('host-a', 'topic-a')
def setUp(self): super(ClusterOperationTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(NodeActionTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(TestTriggerBase, self).setUp() self.ctx = utils.dummy_context() environment.global_env().register_trigger('FakeTriggerType', FakeTriggerImpl)
def setUp(self): super(DBAPIProfileTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(DBAPIReceiverTest, self).setUp() self.ctx = utils.dummy_context() self.type = 'webhook' self.cluster_id = 'FAKE_ID' self.action = 'test_action'
def setUp(self): super(TestEventBackend, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(ActionProcTest, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(TestProfileBase, self).setUp() self.ctx = utils.dummy_context(project='profile_test_project') g_env = environment.global_env() g_env.register_profile('os.dummy-1.0', DummyProfile) self.spec = parser.simple_parse(sample_profile)
def setUp(self): super(PolicyTest, self).setUp() self.ctx = utils.dummy_context(project='policy_test_project') self.eng = service.EngineService('host-a', 'topic-a')
def setUp(self): super(DBAPIClusterTest, self).setUp() self.ctx = utils.dummy_context() self.profile = shared.create_profile(self.ctx)
def setUp(self): super(ActionTest, self).setUp() self.ctx = utils.dummy_context(project='action_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm()
def setUp(self): super(TestNode, self).setUp() self.context = utils.dummy_context(project='node_test_project') self.profile = utils.create_profile(self.context, PROFILE_ID) self.cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
def test_event_get_admin_context(self): event = self.create_event(self.ctx) admin_ctx = utils.dummy_context(project='a-different-project', is_admin=True) res = db_api.event_get(admin_ctx, event.id, project_safe=True) self.assertIsNotNone(res)