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_load_all(self):
result = pb.Policy.load_all(self.ctx)
self.assertEqual([], list(result))
policy1 = utils.create_policy(self.ctx, UUID1, 'policy-1')
policy2 = utils.create_policy(self.ctx, UUID2, 'policy-2')
result = pb.Policy.load_all(self.ctx)
policies = list(result)
self.assertEqual(2, len(policies))
self.assertEqual(policy1.id, policies[0].id)
self.assertEqual(policy2.id, policies[1].id)
def test_cluster_policy_load(self):
ex = self.assertRaises(exception.PolicyNotAttached,
cpm.ClusterPolicy.load, self.context,
'some-cluster', 'any-policy')
self.assertEqual(
"The policy 'any-policy' is not attached to the "
"specified cluster 'some-cluster'.", six.text_type(ex))
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy = utils.create_policy(self.context, POLICY_ID)
values = {
'priority': 12,
'enabled': True,
}
cp = cpm.ClusterPolicy(cluster.id, policy.id, **values)
cp_id = cp.store(self.context)
result = cpm.ClusterPolicy.load(self.context, CLUSTER_ID, POLICY_ID)
self.assertEqual(cp_id, result.id)
self.assertEqual(cluster.id, result.cluster_id)
self.assertEqual(policy.id, result.policy_id)
self.assertTrue(True, result.enabled)
self.assertEqual(12, result.priority)
self.assertEqual({}, result.data)
self.assertIsNone(result.last_op)
self.assertEqual('test-cluster', result.cluster_name)
self.assertEqual('senlin.policy.dummy-1.0', result.policy_type)
self.assertEqual('test_policy', result.policy_name)
def test_cluster_policy_load(self):
ex = self.assertRaises(exception.PolicyNotAttached,
cpm.ClusterPolicy.load,
self.context, 'some-cluster', 'any-policy')
self.assertEqual('The policy (any-policy) is not attached to the '
'specified cluster (some-cluster).',
six.text_type(ex))
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy = utils.create_policy(self.context, POLICY_ID)
values = {
'priority': 12,
'enabled': True,
}
cp = cpm.ClusterPolicy(cluster.id, policy.id, **values)
cp_id = cp.store(self.context)
result = cpm.ClusterPolicy.load(self.context, CLUSTER_ID, POLICY_ID)
self.assertEqual(cp_id, result.id)
self.assertEqual(cluster.id, result.cluster_id)
self.assertEqual(policy.id, result.policy_id)
self.assertTrue(True, result.enabled)
self.assertEqual(12, result.priority)
self.assertEqual({}, result.data)
self.assertIsNone(result.last_op)
self.assertEqual('test-cluster', result.cluster_name)
self.assertEqual('senlin.policy.dummy-1.0', result.policy_type)
self.assertEqual('test_policy', result.policy_name)
def test_delete(self):
policy = utils.create_policy(self.ctx, UUID1)
policy_id = policy.id
res = pb.Policy.delete(self.ctx, policy_id)
self.assertIsNone(res)
self.assertRaises(exception.ResourceNotFound, pb.Policy.load, self.ctx,
policy_id, None)
def test_load_with_policy(self):
policy = utils.create_policy(self.ctx, UUID1)
expected = pb.Policy.load(self.ctx, policy.id)
res = pb.Policy.load(self.ctx, db_policy=policy)
self.assertIsNotNone(res)
self.assertEqual(expected.id, res.id)
def test_delete(self):
policy = utils.create_policy(self.ctx, UUID1)
policy_id = policy.id
res = pb.Policy.delete(self.ctx, policy_id)
self.assertIsNone(res)
self.assertRaises(exception.PolicyNotFound,
pb.Policy.load,
self.ctx, policy_id, None)
def test_load_diff_project(self):
policy = utils.create_policy(self.ctx, UUID1)
new_ctx = utils.dummy_context(project='a-different-project')
self.assertRaises(exception.ResourceNotFound, pb.Policy.load, new_ctx,
policy.id, None)
res = pb.Policy.load(new_ctx, policy.id, project_safe=False)
self.assertIsNotNone(res)
self.assertEqual(policy.id, res.id)
def test_load_diff_project(self):
policy = utils.create_policy(self.ctx, UUID1)
new_ctx = utils.dummy_context(project='a-different-project')
self.assertRaises(exception.PolicyNotFound,
pb.Policy.load,
new_ctx, policy.id, None)
res = pb.Policy.load(new_ctx, policy.id, project_safe=False)
self.assertIsNotNone(res)
self.assertEqual(policy.id, res.id)
def test_cluster_policy_load_all(self):
result = cpm.ClusterPolicy.load_all(self.context, 'non-existent')
self.assertEqual([], result)
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy1 = utils.create_policy(self.context,
'd752f3e4-7be5-41a6-8a36-85bbbdbd7d4a')
policy2 = utils.create_policy(self.context,
'0a2e1240-d34f-4c96-8034-37388cdcdb7b')
b1 = cpm.ClusterPolicy(cluster.id, policy1.id, enabled=True,
priority=10)
b1.store(self.context)
b2 = cpm.ClusterPolicy(cluster.id, policy2.id, enabled=False,
priority=20)
b2.store(self.context)
# NOTE: we don't test all other parameters because the db api tests
# already covered that
result = cpm.ClusterPolicy.load_all(self.context, CLUSTER_ID)
self.assertEqual(2, len(result))
def test_load(self):
policy = utils.create_policy(self.ctx, UUID1)
result = pb.Policy.load(self.ctx, policy.id)
self.assertEqual(policy.id, result.id)
self.assertEqual(policy.name, result.name)
self.assertEqual(policy.type, result.type)
self.assertEqual(policy.user, result.user)
self.assertEqual(policy.project, result.project)
self.assertEqual(policy.domain, result.domain)
self.assertEqual(policy.spec, result.spec)
self.assertEqual(policy.data, result.data)
self.assertEqual({'key1': 'value1', 'key2': 2}, result.properties)
self.assertEqual(policy.created_at, result.created_at)
self.assertEqual(policy.updated_at, result.updated_at)
def test_cluster_policy_store(self):
utils.create_profile(self.context, PROFILE_ID)
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy = utils.create_policy(self.context, POLICY_ID)
values = {
'priority': 12,
'enabled': True,
}
cp = cpm.ClusterPolicy(cluster.id, policy.id, **values)
self.assertIsNone(cp.id)
cp_id = cp.store(self.context)
self.assertIsNotNone(cp_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertEqual(12, result.priority)
self.assertTrue(result.enabled)
self.assertEqual({}, result.data)
self.assertIsNone(result.last_op)
# do an update
cp.enabled = False
cp.priority = 60
cp.data = {'foo': 'bar'}
timestamp = timeutils.utcnow(True)
cp.last_op = timestamp
new_id = cp.store(self.context)
self.assertEqual(cp_id, new_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertFalse(result.enabled)
self.assertEqual(60, result.priority)
self.assertEqual({'foo': 'bar'}, result.data)
self.assertEqual(common_utils.isotime(timestamp),
common_utils.isotime(result.last_op))
def test_cluster_policy_store(self):
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy = utils.create_policy(self.context, POLICY_ID)
values = {
'priority': 12,
'enabled': True,
}
cp = cpm.ClusterPolicy(cluster.id, policy.id, **values)
self.assertIsNone(cp.id)
cp_id = cp.store(self.context)
self.assertIsNotNone(cp_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertEqual(12, result.priority)
self.assertTrue(result.enabled)
self.assertEqual({}, result.data)
self.assertIsNone(result.last_op)
# do an update
cp.enabled = False
cp.priority = 60
cp.data = {'foo': 'bar'}
timestamp = timeutils.utcnow(True)
cp.last_op = timestamp
new_id = cp.store(self.context)
self.assertEqual(cp_id, new_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertFalse(result.enabled)
self.assertEqual(60, result.priority)
self.assertEqual({'foo': 'bar'}, result.data)
self.assertEqual(common_utils.isotime(timestamp),
common_utils.isotime(result.last_op))
def test_to_dict(self):
PROFILE_ID = '96f4df4b-889e-4184-ba8d-b5ca122f95bb'
POLICY1_ID = '2c5139a6-24ba-4a6f-bd53-a268f61536de'
POLICY2_ID = '2c5139a6-24ba-4a6f-bd53-a268f61536d3'
NODE1_ID = '26f4df4b-889e-4184-ba8d-b5ca122f9566'
NODE2_ID = '26f4df4b-889e-4184-ba8d-b5ca122f9567'
utils.create_profile(self.ctx, PROFILE_ID)
policy_1 = utils.create_policy(self.ctx, POLICY1_ID, 'P1')
policy_2 = utils.create_policy(self.ctx, POLICY2_ID, 'P2')
values = {
'profile_id': PROFILE_ID,
'name': 'test-cluster',
'desired_capacity': 1,
'status': 'INIT',
'init_at': timeutils.utcnow(True),
'max_size': -1,
'min_size': 0,
'timeout': cfg.CONF.default_action_timeout,
'user': self.ctx.user_id,
'project': self.ctx.project_id,
}
cluster = co.Cluster.create(self.ctx, values)
p1 = cpo.ClusterPolicy(cluster_id=cluster.id,
policy_id=policy_1.id,
enabled=True,
id=uuidutils.generate_uuid(),
last_op=None)
p2 = cpo.ClusterPolicy(cluster_id=cluster.id,
policy_id=policy_2.id,
enabled=True,
id=uuidutils.generate_uuid(),
last_op=None)
values = {
'priority': 12,
'enabled': True,
}
p1.create(self.ctx, cluster.id, POLICY1_ID, values)
p2.create(self.ctx, cluster.id, POLICY2_ID, values)
utils.create_node(self.ctx, NODE1_ID, PROFILE_ID, cluster.id)
utils.create_node(self.ctx, NODE2_ID, PROFILE_ID, cluster.id)
cluster = co.Cluster.get(self.ctx, cluster.id)
expected = {
'id': cluster.id,
'name': cluster.name,
'profile_id': PROFILE_ID,
'user': cluster.user,
'project': cluster.project,
'domain': cluster.domain,
'init_at': mock.ANY,
'created_at': None,
'updated_at': None,
'min_size': 0,
'max_size': -1,
'desired_capacity': 1,
'timeout': cfg.CONF.default_action_timeout,
'status': six.text_type('INIT'),
'status_reason': None,
'metadata': {},
'data': {},
'dependents': {},
'config': {},
'nodes': [mock.ANY, mock.ANY],
'policies': [mock.ANY, mock.ANY],
'profile_name': six.text_type('test-profile'),
}
cluster_dict = cluster.to_dict()
self.assertEqual(expected, cluster_dict)
self.assertEqual(2, len(cluster_dict['nodes']))
self.assertEqual(2, len(cluster_dict['policies']))
