def test_event_get_all_project_safe(self):
self.ctx.project = 'project_1'
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
self.create_event(self.ctx, entity=cluster1)
self.ctx.project = 'project_2'
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_CREATE')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_DELETE')
# Default project_safe to true, only the last two events are visible
events = db_api.event_get_all(self.ctx)
self.assertEqual(2, len(events))
oids = [event.oid for event in events]
onames = [event.oname for event in events]
self.assertNotIn(cluster1.id, oids)
self.assertNotIn(cluster1.name, onames)
self.assertIn(cluster2.id, oids)
self.assertIn(cluster2.name, onames)
# Set project_safe to false, we should get all three events
events = db_api.event_get_all(self.ctx, project_safe=False)
self.assertEqual(3, len(events))
oids = [event.oid for event in events]
onames = [event.oname for event in events]
self.assertIn(cluster1.id, oids)
self.assertIn(cluster1.name, onames)
self.assertIn(cluster2.id, oids)
self.assertIn(cluster2.name, onames)
def test_event_get_all_project_safe(self):
self.ctx.project = 'project_1'
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
self.create_event(self.ctx, entity=cluster1)
self.ctx.project = 'project_2'
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_CREATE')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_DELETE')
# Default project_safe to true, only the last two events are visible
events = db_api.event_get_all(self.ctx)
self.assertEqual(2, len(events))
oids = [event.oid for event in events]
onames = [event.oname for event in events]
self.assertNotIn(cluster1.id, oids)
self.assertNotIn(cluster1.name, onames)
self.assertIn(cluster2.id, oids)
self.assertIn(cluster2.name, onames)
# Set project_safe to false, we should get all three events
events = db_api.event_get_all(self.ctx, project_safe=False)
self.assertEqual(3, len(events))
oids = [event.oid for event in events]
onames = [event.oname for event in events]
self.assertIn(cluster1.id, oids)
self.assertIn(cluster1.name, onames)
self.assertIn(cluster2.id, oids)
self.assertIn(cluster2.name, onames)
def test_cluster_get_by_name_diff_project(self):
self.ctx.project_id = UUID2
cluster1 = shared.create_cluster(self.ctx,
self.profile,
name='cluster_A',
project=UUID2)
shared.create_cluster(self.ctx,
self.profile,
name='cluster_B',
project=UUID2)
shared.create_cluster(self.ctx,
self.profile,
name='cluster_B',
project=UUID2)
self.ctx.project_id = UUID1
res = db_api.cluster_get_by_name(self.ctx, 'cluster_A')
self.assertIsNone(res)
self.ctx.project_id = UUID3
self.assertIsNone(db_api.cluster_get_by_name(self.ctx, 'cluster_A'))
self.ctx.project_id = UUID2
res = db_api.cluster_get_by_name(self.ctx, 'cluster_A')
self.assertEqual(cluster1.id, res.id)
self.assertRaises(exception.MultipleChoices,
db_api.cluster_get_by_name, self.ctx, 'cluster_B')
res = db_api.cluster_get_by_name(self.ctx, 'non-existent')
self.assertIsNone(res)
def test_cluster_get_by_name_diff_project(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster_A',
project=UUID2)
shared.create_cluster(self.ctx, self.profile, name='cluster_B',
project=UUID2)
shared.create_cluster(self.ctx, self.profile, name='cluster_B',
project=UUID2)
res = db_api.cluster_get_by_name(self.ctx, 'cluster_A')
self.assertIsNone(res)
self.ctx.project = UUID3
self.assertIsNone(db_api.cluster_get_by_name(self.ctx,
'cluster_A'))
self.ctx.project = UUID2
res = db_api.cluster_get_by_name(self.ctx, 'cluster_A')
self.assertEqual(cluster1.id, res.id)
self.assertRaises(exception.MultipleChoices,
db_api.cluster_get_by_name,
self.ctx, 'cluster_B')
res = db_api.cluster_get_by_name(self.ctx, 'non-existent')
self.assertIsNone(res)
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_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_cluster_get_all_returns_all_if_no_filters(self):
shared.create_cluster(self.ctx, self.profile)
shared.create_cluster(self.ctx, self.profile)
filters = None
results = db_api.cluster_get_all(self.ctx, filters=filters)
self.assertEqual(2, len(results))
def test_node_count_by_cluster(self):
shared.create_cluster(self.ctx, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
res = db_api.node_count_by_cluster(self.ctx, self.cluster.id)
self.assertEqual(2, res)
def test_node_count_by_cluster(self):
shared.create_cluster(self.ctx, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
res = db_api.node_count_by_cluster(self.ctx, self.cluster.id)
self.assertEqual(2, res)
def test_cluster_get_all_returns_all_if_no_filters(self):
shared.create_cluster(self.ctx, self.profile)
shared.create_cluster(self.ctx, self.profile)
filters = None
results = db_api.cluster_get_all(self.ctx, filters=filters)
self.assertEqual(2, len(results))
def test_event_get_all_filtered(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2')
self.create_event(self.ctx, entity=cluster1, action='CLUSTER_CREATE')
self.create_event(self.ctx, entity=cluster1, action='CLUSTER_DELETE')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_CREATE')
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(2, len(events))
# test filter by action
filters = {'action': 'CLUSTER_CREATE'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(1, len(events))
self.assertEqual('CLUSTER_CREATE', events[0].action)
filters = {'action': 'CLUSTER_UPDATE'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(0, len(events))
# test filter by oname
filters = {'oname': 'cluster1'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(2, len(events))
self.assertEqual('cluster1', events[0].oname)
self.assertEqual('cluster1', events[1].oname)
filters = {'oname': 'cluster3'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(0, len(events))
# test filter by otype
filters = {'otype': 'CLUSTER'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id,
filters=filters)
self.assertEqual(1, len(events))
self.assertEqual('CLUSTER', events[0].otype)
filters = {'otype': 'NODE'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id,
filters=filters)
self.assertEqual(0, len(events))
# test limit and marker
events_all = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
marker = events_all[0].id
expected = events_all[1].id
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
limit=1, marker=marker)
self.assertEqual(1, len(events))
self.assertEqual(expected, events[0].id)
def test_event_get_all_filtered(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2')
self.create_event(self.ctx, entity=cluster1, action='CLUSTER_CREATE')
self.create_event(self.ctx, entity=cluster1, action='CLUSTER_DELETE')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_CREATE')
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(2, len(events))
# test filter by action
filters = {'action': 'CLUSTER_CREATE'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(1, len(events))
self.assertEqual('CLUSTER_CREATE', events[0].action)
filters = {'action': 'CLUSTER_UPDATE'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(0, len(events))
# test filter by oname
filters = {'oname': 'cluster1'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(2, len(events))
self.assertEqual('cluster1', events[0].oname)
self.assertEqual('cluster1', events[1].oname)
filters = {'oname': 'cluster3'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
filters=filters)
self.assertEqual(0, len(events))
# test filter by otype
filters = {'otype': 'CLUSTER'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id,
filters=filters)
self.assertEqual(1, len(events))
self.assertEqual('CLUSTER', events[0].otype)
filters = {'otype': 'NODE'}
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id,
filters=filters)
self.assertEqual(0, len(events))
# test limit and marker
events_all = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
marker = events_all[0].id
expected = events_all[1].id
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id,
limit=1, marker=marker)
self.assertEqual(1, len(events))
self.assertEqual(expected, events[0].id)
def test_cluster_count_all_show_nested(self):
cluster1 = shared.create_cluster(self.ctx, self.profile, name='c1')
shared.create_cluster(self.ctx, self.profile, name='c2',
parent=cluster1.id)
results = db_api.cluster_count_all(self.ctx)
self.assertEqual(1, results)
results = db_api.cluster_count_all(self.ctx, show_nested=True)
self.assertEqual(2, results)
def test_node_count_by_cluster_admin_context(self):
shared.create_cluster(self.ctx, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
admin_ctx = utils.dummy_context(project='a_different_project',
is_admin=True)
res = db_api.node_count_by_cluster(admin_ctx, self.cluster.id,
project_safe=True)
self.assertEqual(2, res)
def test_node_get_by_cluster_admin_context(self):
shared.create_cluster(self.ctx, self.profile)
node1 = shared.create_node(self.ctx, self.cluster, self.profile)
node2 = shared.create_node(self.ctx, self.cluster, self.profile)
admin_ctx = utils.dummy_context(project='a_different_project',
is_admin=True)
nodes = db_api.node_get_all_by_cluster(admin_ctx, self.cluster.id)
self.assertEqual(2, len(nodes))
self.assertEqual(set([node1.id, node2.id]),
set([nodes[0].id, nodes[1].id]))
def test_node_get_by_cluster_admin_context(self):
shared.create_cluster(self.ctx, self.profile)
node1 = shared.create_node(self.ctx, self.cluster, self.profile)
node2 = shared.create_node(self.ctx, self.cluster, self.profile)
admin_ctx = utils.dummy_context(project='a_different_project',
is_admin=True)
nodes = db_api.node_get_all_by_cluster(admin_ctx, self.cluster.id)
self.assertEqual(2, len(nodes))
self.assertEqual(set([node1.id, node2.id]),
set([nodes[0].id, nodes[1].id]))
def test_event_get_all_by_cluster(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
node1_1 = shared.create_node(self.ctx, cluster1, self.profile)
node1_2 = shared.create_node(self.ctx, cluster1, self.profile)
node2_1 = shared.create_node(self.ctx, cluster2, self.profile)
node_orphan = shared.create_node(self.ctx, None, self.profile)
# 1 event for cluster 1
self.create_event(self.ctx, entity=cluster1)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(events))
# two more events for cluster 1, with one for an orphan node
self.create_event(self.ctx, entity=node1_1)
self.create_event(self.ctx, entity=node1_2)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(3, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(events))
# one more events for cluster 2, with one for an orphan node
self.create_event(self.ctx, entity=cluster2)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(3, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(1, len(events))
# two more events for cluster 2, with one for an orphan node
self.create_event(self.ctx, entity=node2_1)
self.create_event(self.ctx, entity=node2_1)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(3, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(3, len(events))
# two more events for cluster 1, with one for an orphan node
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=node1_1)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(5, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(3, len(events))
def test_event_count_all_by_cluster_diff_project(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster2)
new_ctx = utils.dummy_context(project='a-different-project')
res = db_api.event_count_by_cluster(new_ctx, cluster1.id)
self.assertEqual(0, res)
res = db_api.event_count_by_cluster(new_ctx, cluster1.id,
project_safe=False)
self.assertEqual(1, res)
def test_event_count_all_by_cluster_diff_project(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster2)
new_ctx = utils.dummy_context(project='a-different-project')
res = db_api.event_count_by_cluster(new_ctx, cluster1.id)
self.assertEqual(0, res)
res = db_api.event_count_by_cluster(new_ctx, cluster1.id,
project_safe=False)
self.assertEqual(1, res)
def test_event_get_all_by_cluster(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
node1_1 = shared.create_node(self.ctx, cluster1, self.profile)
node1_2 = shared.create_node(self.ctx, cluster1, self.profile)
node2_1 = shared.create_node(self.ctx, cluster2, self.profile)
node_orphan = shared.create_node(self.ctx, None, self.profile)
# 1 event for cluster 1
self.create_event(self.ctx, entity=cluster1)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(events))
# two more events for cluster 1, with one for an orphan node
self.create_event(self.ctx, entity=node1_1)
self.create_event(self.ctx, entity=node1_2)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(3, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(events))
# one more events for cluster 2, with one for an orphan node
self.create_event(self.ctx, entity=cluster2)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(3, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(1, len(events))
# two more events for cluster 2, with one for an orphan node
self.create_event(self.ctx, entity=node2_1)
self.create_event(self.ctx, entity=node2_1)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(3, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(3, len(events))
# two more events for cluster 1, with one for an orphan node
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=node1_1)
self.create_event(self.ctx, entity=node_orphan)
events = db_api.event_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(5, len(events))
events = db_api.event_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(3, len(events))
def test_cluster_get_all_with_filters(self):
shared.create_cluster(self.ctx, self.profile, name='foo')
shared.create_cluster(self.ctx, self.profile, name='bar')
filters = {'name': ['bar', 'quux']}
results = db_api.cluster_get_all(self.ctx, filters=filters)
self.assertEqual(1, len(results))
self.assertEqual('bar', results[0]['name'])
filters = {'name': 'foo'}
results = db_api.cluster_get_all(self.ctx, filters=filters)
self.assertEqual(1, len(results))
self.assertEqual('foo', results[0]['name'])
def test_node_count_by_cluster_diff_project(self):
ctx_new = utils.dummy_context(project='a_different_project')
shared.create_cluster(self.ctx, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile)
res = db_api.node_count_by_cluster(ctx_new, self.cluster.id)
self.assertEqual(0, res)
res = db_api.node_count_by_cluster(ctx_new, self.cluster.id,
project_safe=False)
self.assertEqual(2, res)
def test_nested_cluster_get_by_name(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2',
parent=cluster1.id)
result = db_api.cluster_get_by_name(self.ctx, 'cluster2')
self.assertEqual(cluster2.id, result.id)
db_api.cluster_delete(self.ctx, cluster2.id)
result = db_api.cluster_get_by_name(self.ctx, 'cluster2')
self.assertIsNone(result)
def test_nested_cluster_get_by_name(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2',
parent=cluster1.id)
result = db_api.cluster_get_by_name(self.ctx, 'cluster2')
self.assertEqual(cluster2.id, result.id)
db_api.cluster_delete(self.ctx, cluster2.id)
result = db_api.cluster_get_by_name(self.ctx, 'cluster2')
self.assertIsNone(result)
def test_cluster_get_all_with_filters(self):
shared.create_cluster(self.ctx, self.profile, name='foo')
shared.create_cluster(self.ctx, self.profile, name='bar')
filters = {'name': ['bar', 'quux']}
results = db_api.cluster_get_all(self.ctx, filters=filters)
self.assertEqual(1, len(results))
self.assertEqual('bar', results[0]['name'])
filters = {'name': 'foo'}
results = db_api.cluster_get_all(self.ctx, filters=filters)
self.assertEqual(1, len(results))
self.assertEqual('foo', results[0]['name'])
def test_node_count_by_cluster_with_filters(self):
shared.create_cluster(self.ctx, self.profile)
shared.create_node(self.ctx, self.cluster, self.profile,
status='ACTIVE')
shared.create_node(self.ctx, self.cluster, self.profile,
status='ERROR')
res = db_api.node_count_by_cluster(self.ctx, self.cluster.id,
status='ACTIVE')
self.assertEqual(1, res)
res = db_api.node_count_by_cluster(self.ctx, self.cluster.id,
status='ERROR')
self.assertEqual(1, res)
def test_event_get_all_admin_context(self):
self.ctx.project = 'project_1'
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
self.create_event(self.ctx, entity=cluster1)
self.ctx.project = 'project_2'
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_CREATE')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_DELETE')
admin_ctx = utils.dummy_context(project='another-project',
is_admin=True)
events = db_api.event_get_all(admin_ctx, project_safe=True)
self.assertEqual(3, len(events))
def test_event_get_all_with_limit_and_marker(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster1)
events_all = db_api.event_get_all(self.ctx)
self.assertEqual(3, len(events_all))
marker = events_all[0].id
event1_id = events_all[1].id
event2_id = events_all[2].id
events = db_api.event_get_all(self.ctx, limit=1, marker=marker)
self.assertEqual(1, len(events))
self.assertEqual(event1_id, events[0].id)
events = db_api.event_get_all(self.ctx, limit=2, marker=marker)
self.assertEqual(2, len(events))
self.assertEqual(event1_id, events[0].id)
self.assertEqual(event2_id, events[1].id)
marker = event1_id
events = db_api.event_get_all(self.ctx, limit=1, marker=marker)
self.assertEqual(1, len(events))
self.assertEqual(event2_id, events[0].id)
def test_cluster_get_all_with_regular_project(self):
values = [
{
'project': UUID1
},
{
'project': UUID1
},
{
'project': UUID2
},
{
'project': UUID2
},
{
'project': UUID2
},
]
[shared.create_cluster(self.ctx, self.profile, **v) for v in values]
self.ctx.project_id = UUID1
clusters = db_api.cluster_get_all(self.ctx)
self.assertEqual(2, len(clusters))
self.ctx.project_id = UUID2
clusters = db_api.cluster_get_all(self.ctx)
self.assertEqual(3, len(clusters))
self.ctx.project_id = UUID3
self.assertEqual([], db_api.cluster_get_all(self.ctx))
def test_cluster_get_returns_a_cluster(self):
cluster = shared.create_cluster(self.ctx, self.profile)
ret_cluster = db_api.cluster_get(self.ctx, cluster.id,
show_deleted=False)
self.assertIsNotNone(ret_cluster)
self.assertEqual(cluster.id, ret_cluster.id)
self.assertEqual('db_test_cluster_name', ret_cluster.name)
def test_cluster_get_all_marker(self):
clusters = [shared.create_cluster(self.ctx, self.profile,
created_at=tu.utcnow(True))
for x in range(3)]
cl_db = db_api.cluster_get_all(self.ctx, marker=clusters[1].id)
self.assertEqual(1, len(cl_db))
self.assertEqual(clusters[2].id, cl_db[0].id)
def test_event_get_all_with_limit_and_marker(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster1)
events_all = db_api.event_get_all(self.ctx)
self.assertEqual(3, len(events_all))
marker = events_all[0].id
event1_id = events_all[1].id
event2_id = events_all[2].id
events = db_api.event_get_all(self.ctx, limit=1, marker=marker)
self.assertEqual(1, len(events))
self.assertEqual(event1_id, events[0].id)
events = db_api.event_get_all(self.ctx, limit=2, marker=marker)
self.assertEqual(2, len(events))
self.assertEqual(event1_id, events[0].id)
self.assertEqual(event2_id, events[1].id)
marker = event1_id
events = db_api.event_get_all(self.ctx, limit=1, marker=marker)
self.assertEqual(1, len(events))
self.assertEqual(event2_id, events[0].id)
def test_cluster_count_all_with_admin_context(self):
values = [
{
'project': UUID1
},
{
'project': UUID1
},
{
'project': UUID2
},
{
'project': UUID2
},
{
'project': UUID2
},
]
[shared.create_cluster(self.ctx, self.profile, **v) for v in values]
admin_ctx = utils.dummy_context(project='another-project',
is_admin=True)
self.assertEqual(
0, db_api.cluster_count_all(admin_ctx, project_safe=True))
self.assertEqual(
5, db_api.cluster_count_all(admin_ctx, project_safe=False))
def test_event_get_all_show_deleted(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
# Simulate deleted events by setting 'deleted_time' to not-None
now = tu.utcnow()
self.create_event(self.ctx, entity=cluster1, deleted_time=now)
self.create_event(self.ctx, entity=cluster1)
self.create_event(self.ctx, entity=cluster2, deleted_time=now)
# Default show_deleted is False
events = db_api.event_get_all(self.ctx)
self.assertEqual(1, len(events))
events = db_api.event_get_all(self.ctx, show_deleted=True)
self.assertEqual(3, len(events))
def test_event_get_all_with_sort_keys_and_dir(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
event1 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(),
action='action2')
event2 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(),
action='action3')
event3 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(),
action='action1')
events = db_api.event_get_all(self.ctx, sort_keys=['timestamp'])
self.assertEqual(event1.id, events[0].id)
self.assertEqual(event2.id, events[1].id)
self.assertEqual(event3.id, events[2].id)
events = db_api.event_get_all(self.ctx, sort_keys=['timestamp'],
sort_dir='desc')
self.assertEqual(event1.id, events[2].id)
self.assertEqual(event2.id, events[1].id)
self.assertEqual(event3.id, events[0].id)
events = db_api.event_get_all(self.ctx, sort_keys=['action'])
self.assertEqual(event1.id, events[1].id)
self.assertEqual(event2.id, events[2].id)
self.assertEqual(event3.id, events[0].id)
events = db_api.event_get_all(self.ctx, sort_keys=['action'],
sort_dir='desc')
self.assertEqual(event1.id, events[1].id)
self.assertEqual(event2.id, events[0].id)
self.assertEqual(event3.id, events[2].id)
def test_cluster_get_all_marker(self):
clusters = [shared.create_cluster(self.ctx, self.profile,
created_time=tu.utcnow())
for x in range(3)]
cl_db = db_api.cluster_get_all(self.ctx, marker=clusters[1].id)
self.assertEqual(1, len(cl_db))
self.assertEqual(clusters[2].id, cl_db[0].id)
def test_event_get_all_with_sorting(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
event1 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(True),
action='action2')
event2 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(True),
action='action3')
event3 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(True),
action='action1')
events = db_api.event_get_all(self.ctx, sort='timestamp')
self.assertEqual(event1.id, events[0].id)
self.assertEqual(event2.id, events[1].id)
self.assertEqual(event3.id, events[2].id)
events = db_api.event_get_all(self.ctx, sort='timestamp:desc')
self.assertEqual(event1.id, events[2].id)
self.assertEqual(event2.id, events[1].id)
self.assertEqual(event3.id, events[0].id)
events = db_api.event_get_all(self.ctx, sort='action')
self.assertEqual(event1.id, events[1].id)
self.assertEqual(event2.id, events[2].id)
self.assertEqual(event3.id, events[0].id)
events = db_api.event_get_all(self.ctx, sort='action:desc')
self.assertEqual(event1.id, events[1].id)
self.assertEqual(event2.id, events[0].id)
self.assertEqual(event3.id, events[2].id)
def test_cluster_get_all_show_nested(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2',
parent=cluster1.id)
cl_db = db_api.cluster_get_all(self.ctx)
self.assertEqual(1, len(cl_db))
self.assertEqual(cluster1.id, cl_db[0].id)
cl_db = db_api.cluster_get_all(self.ctx, show_nested=True)
self.assertEqual(2, len(cl_db))
cl_ids = [s.id for s in cl_db]
self.assertIn(cluster1.id, cl_ids)
self.assertIn(cluster2.id, cl_ids)
def test_cluster_count_all_with_regular_project(self):
values = [
{
'project': UUID1
},
{
'project': UUID1
},
{
'project': UUID2
},
{
'project': UUID2
},
{
'project': UUID2
},
]
[shared.create_cluster(self.ctx, self.profile, **v) for v in values]
self.ctx.project_id = UUID1
self.assertEqual(2, db_api.cluster_count_all(self.ctx))
self.ctx.project_id = UUID2
self.assertEqual(3, db_api.cluster_count_all(self.ctx))
def test_node_get_by_cluster(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
node0 = shared.create_node(self.ctx, None, self.profile)
node1 = shared.create_node(self.ctx, self.cluster, self.profile)
node2 = shared.create_node(self.ctx, self.cluster, self.profile)
node3 = shared.create_node(self.ctx, cluster1, self.profile)
nodes = db_api.node_get_all_by_cluster(self.ctx, self.cluster.id)
self.assertEqual(2, len(nodes))
self.assertEqual(set([node1.id, node2.id]),
set([nodes[0].id, nodes[1].id]))
# retrieve orphan nodes
nodes = db_api.node_get_all_by_cluster(self.ctx, '')
self.assertEqual(1, len(nodes))
self.assertEqual(node0.id, nodes[0].id)
# retrieve all nodes
nodes = db_api.node_get_all_by_cluster(self.ctx, None)
self.assertEqual(4, len(nodes))
self.assertEqual(node0.id, nodes[0].id)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(nodes))
self.assertEqual(node3.id, nodes[0].id)
def test_event_get_all_with_sorting(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
event1 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(True),
action='action2')
event2 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(True),
action='action3')
event3 = self.create_event(self.ctx, entity=cluster1,
timestamp=tu.utcnow(True),
action='action1')
events = db_api.event_get_all(self.ctx, sort='timestamp')
self.assertEqual(event1.id, events[0].id)
self.assertEqual(event2.id, events[1].id)
self.assertEqual(event3.id, events[2].id)
events = db_api.event_get_all(self.ctx, sort='timestamp:desc')
self.assertEqual(event1.id, events[2].id)
self.assertEqual(event2.id, events[1].id)
self.assertEqual(event3.id, events[0].id)
events = db_api.event_get_all(self.ctx, sort='action')
self.assertEqual(event1.id, events[1].id)
self.assertEqual(event2.id, events[2].id)
self.assertEqual(event3.id, events[0].id)
events = db_api.event_get_all(self.ctx, sort='action:desc')
self.assertEqual(event1.id, events[1].id)
self.assertEqual(event2.id, events[0].id)
self.assertEqual(event3.id, events[2].id)
def test_node_get_by_cluster(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
node0 = shared.create_node(self.ctx, None, self.profile)
node1 = shared.create_node(self.ctx, self.cluster, self.profile)
node2 = shared.create_node(self.ctx, self.cluster, self.profile)
node3 = shared.create_node(self.ctx, cluster1, self.profile)
nodes = db_api.node_get_all_by_cluster(self.ctx, self.cluster.id)
self.assertEqual(2, len(nodes))
self.assertEqual(set([node1.id, node2.id]),
set([nodes[0].id, nodes[1].id]))
# retrieve orphan nodes
nodes = db_api.node_get_all_by_cluster(self.ctx, '')
self.assertEqual(1, len(nodes))
self.assertEqual(node0.id, nodes[0].id)
# retrieve all nodes
nodes = db_api.node_get_all_by_cluster(self.ctx, None)
self.assertEqual(4, len(nodes))
self.assertEqual(node0.id, nodes[0].id)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(nodes))
self.assertEqual(node3.id, nodes[0].id)
def test_node_migrate_between_clusters(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
node = shared.create_node(self.ctx, cluster1, self.profile)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(nodes))
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(nodes))
# Refresh cluster1 and cluster2
cluster1 = db_api.cluster_get(self.ctx, cluster1.id)
cluster2 = db_api.cluster_get(self.ctx, cluster2.id)
self.assertEqual(2, cluster1.next_index)
self.assertEqual(1, cluster2.next_index)
timestamp = tu.utcnow(True)
node_new = db_api.node_migrate(self.ctx, node.id, cluster2.id,
timestamp)
cluster1 = db_api.cluster_get(self.ctx, cluster1.id)
cluster2 = db_api.cluster_get(self.ctx, cluster2.id)
self.assertEqual(timestamp, node_new.updated_at)
self.assertEqual(cluster2.id, node_new.cluster_id)
self.assertIsNone(node_new.role)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(0, len(nodes))
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(1, len(nodes))
self.assertEqual(2, cluster1.next_index)
self.assertEqual(2, cluster2.next_index)
# Migrate it back!
timestamp = tu.utcnow(True)
node_new = db_api.node_migrate(self.ctx, node.id, cluster1.id,
timestamp, 'FAKE-ROLE')
cluster1 = db_api.cluster_get(self.ctx, cluster1.id)
cluster2 = db_api.cluster_get(self.ctx, cluster2.id)
self.assertEqual(timestamp, node_new.updated_at)
self.assertEqual(cluster1.id, node_new.cluster_id)
self.assertEqual('FAKE-ROLE', node_new.role)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(nodes))
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(nodes))
self.assertEqual(3, cluster1.next_index)
self.assertEqual(2, cluster2.next_index)
def test_node_migrate_between_clusters(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
node = shared.create_node(self.ctx, cluster1, self.profile)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(nodes))
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(nodes))
# Refresh cluster1 and cluster2
cluster1 = db_api.cluster_get(self.ctx, cluster1.id)
cluster2 = db_api.cluster_get(self.ctx, cluster2.id)
self.assertEqual(2, cluster1.next_index)
self.assertEqual(1, cluster2.next_index)
timestamp = tu.utcnow()
node_new = db_api.node_migrate(self.ctx, node.id, cluster2.id,
timestamp)
cluster1 = db_api.cluster_get(self.ctx, cluster1.id)
cluster2 = db_api.cluster_get(self.ctx, cluster2.id)
self.assertEqual(timestamp, node_new.updated_at)
self.assertEqual(cluster2.id, node_new.cluster_id)
self.assertIsNone(node_new.role)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(0, len(nodes))
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(1, len(nodes))
self.assertEqual(2, cluster1.next_index)
self.assertEqual(2, cluster2.next_index)
# Migrate it back!
timestamp = tu.utcnow()
node_new = db_api.node_migrate(self.ctx, node.id, cluster1.id,
timestamp, 'FAKE-ROLE')
cluster1 = db_api.cluster_get(self.ctx, cluster1.id)
cluster2 = db_api.cluster_get(self.ctx, cluster2.id)
self.assertEqual(timestamp, node_new.updated_at)
self.assertEqual(cluster1.id, node_new.cluster_id)
self.assertEqual('FAKE-ROLE', node_new.role)
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster1.id)
self.assertEqual(1, len(nodes))
nodes = db_api.node_get_all_by_cluster(self.ctx, cluster2.id)
self.assertEqual(0, len(nodes))
self.assertEqual(3, cluster1.next_index)
self.assertEqual(2, cluster2.next_index)
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 test_cluster_get_all_by_parent(self):
cluster1 = shared.create_cluster(self.ctx, self.profile)
cluster2 = shared.create_cluster(self.ctx, self.profile)
values = [
{'parent': cluster1.id},
{'parent': cluster1.id},
{'parent': cluster2.id},
{'parent': cluster2.id},
]
[shared.create_cluster(self.ctx, self.profile, **v) for v in values]
children1 = db_api.cluster_get_all_by_parent(self.ctx, cluster1.id)
self.assertEqual(2, len(children1))
children2 = db_api.cluster_get_all_by_parent(self.ctx, cluster2.id)
self.assertEqual(2, len(children2))
children0 = db_api.cluster_get_all_by_parent(self.ctx, 'non-existent')
self.assertEqual(0, len(children0))
def test_cluster_add_dependents(self):
cluster = shared.create_cluster(self.ctx, self.profile)
profile_id = 'profile1'
db_api.cluster_add_dependents(self.ctx, cluster.id, profile_id)
res = db_api.cluster_get(self.ctx, cluster.id)
self.assertEqual(['profile1'], res.dependents['profiles'])
deps = {}
cluster = shared.create_cluster(self.ctx, self.profile,
dependents=deps)
db_api.cluster_add_dependents(self.ctx, cluster.id, profile_id)
res = db_api.cluster_get(self.ctx, cluster.id)
deps = {'profiles': ['profile1']}
self.assertEqual(deps, res.dependents)
db_api.cluster_add_dependents(self.ctx, cluster.id, 'profile2')
res = db_api.cluster_get(self.ctx, cluster.id)
deps = {'profiles': ['profile1', 'profile2']}
self.assertEqual(deps, res.dependents)
def test_event_get_all_admin_context(self):
self.ctx.project = 'project_1'
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
self.create_event(self.ctx, entity=cluster1)
self.ctx.project = 'project_2'
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_CREATE')
self.create_event(self.ctx, entity=cluster2, action='CLUSTER_DELETE')
admin_ctx = utils.dummy_context(project='another-project',
is_admin=True)
events = db_api.event_get_all(admin_ctx, project_safe=True)
self.assertEqual(0, len(events))
events = db_api.event_get_all(admin_ctx, project_safe=False)
self.assertEqual(3, len(events))
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 test_node_get_by_cluster_diff_project(self):
shared.create_cluster(self.ctx, self.profile)
node1 = shared.create_node(self.ctx, self.cluster, self.profile)
node2 = shared.create_node(self.ctx, self.cluster, self.profile)
nodes = db_api.node_get_all_by_cluster(self.ctx, self.cluster.id)
self.assertEqual(2, len(nodes))
self.assertEqual(set([node1.id, node2.id]),
set([nodes[0].id, nodes[1].id]))
ctx_new = utils.dummy_context(project='a_different_project')
nodes = db_api.node_get_all_by_cluster(ctx_new, self.cluster.id)
self.assertEqual(0, len(nodes))
nodes = db_api.node_get_all_by_cluster(ctx_new, self.cluster.id,
project_safe=False)
self.assertEqual(2, len(nodes))
def test_cluster_get_by_name_and_parent(self):
cluster1 = shared.create_cluster(self.ctx, self.profile,
name='cluster1')
cluster2 = shared.create_cluster(self.ctx, self.profile,
name='cluster2',
parent=cluster1.id)
result = db_api.cluster_get_by_name_and_parent(self.ctx, 'cluster2',
None)
self.assertIsNone(result)
result = db_api.cluster_get_by_name_and_parent(self.ctx, 'cluster2',
cluster1.id)
self.assertEqual(cluster2.id, result.id)
result = db_api.cluster_get_by_name_and_parent(self.ctx, 'cluster1',
cluster1.id)
self.assertIsNone(result)
def test_cluster_get_all_default_sort_dir(self):
clusters = [shared.create_cluster(self.ctx, self.profile,
init_time=tu.utcnow())
for x in range(3)]
st_db = db_api.cluster_get_all(self.ctx, sort_dir='asc')
self.assertEqual(3, len(st_db))
self.assertEqual(clusters[0].id, st_db[0].id)
self.assertEqual(clusters[1].id, st_db[1].id)
self.assertEqual(clusters[2].id, st_db[2].id)
def test_cluster_get_all_str_sort_keys(self):
clusters = [shared.create_cluster(self.ctx, self.profile,
created_at=tu.utcnow(True))
for x in range(3)]
st_db = db_api.cluster_get_all(self.ctx, sort='created_at')
self.assertEqual(3, len(st_db))
self.assertEqual(clusters[0].id, st_db[0].id)
self.assertEqual(clusters[1].id, st_db[1].id)
self.assertEqual(clusters[2].id, st_db[2].id)
def test_cluster_get_from_different_project(self):
cluster = shared.create_cluster(self.ctx, self.profile)
self.ctx.project = 'abc'
ret_cluster = db_api.cluster_get(self.ctx, cluster.id,
project_safe=False)
self.assertEqual(cluster.id, ret_cluster.id)
self.assertEqual('db_test_cluster_name', ret_cluster.name)
cluster = db_api.cluster_get(self.ctx, cluster.id)
self.assertIsNone(cluster)
def test_cluster_get_all_str_sort_keys(self):
clusters = [shared.create_cluster(self.ctx, self.profile,
created_time=tu.utcnow())
for x in range(3)]
st_db = db_api.cluster_get_all(self.ctx, sort_keys='created_time')
self.assertEqual(3, len(st_db))
self.assertEqual(clusters[0].id, st_db[0].id)
self.assertEqual(clusters[1].id, st_db[1].id)
self.assertEqual(clusters[2].id, st_db[2].id)
