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)
