Merge "Wrong order of assertEquals args(Glance)"
This commit is contained in:
commit
1428533249
|
@ -154,8 +154,8 @@ class DriverTests(object):
|
|||
self.assertFalse(image['deleted'])
|
||||
self.assertIsNone(image['deleted_at'])
|
||||
self.assertEqual([], image['properties'])
|
||||
self.assertEqual(image['created_at'], create_time)
|
||||
self.assertEqual(image['updated_at'], create_time)
|
||||
self.assertEqual(create_time, image['created_at'])
|
||||
self.assertEqual(create_time, image['updated_at'])
|
||||
|
||||
# Image IDs aren't predictable, but they should be populated
|
||||
self.assertTrue(uuid.UUID(image['id']))
|
||||
|
@ -263,13 +263,13 @@ class DriverTests(object):
|
|||
|
||||
# New properties are set
|
||||
self.assertTrue('ping' in properties)
|
||||
self.assertEqual(properties['ping']['value'], 'pong')
|
||||
self.assertEqual('pong', properties['ping']['value'])
|
||||
self.assertFalse(properties['ping']['deleted'])
|
||||
|
||||
# Original properties still show up, but with deleted=True
|
||||
# TODO(markwash): db api should not return deleted properties
|
||||
self.assertTrue('foo' in properties)
|
||||
self.assertEqual(properties['foo']['value'], 'bar')
|
||||
self.assertEqual('bar', properties['foo']['value'])
|
||||
self.assertTrue(properties['foo']['deleted'])
|
||||
|
||||
def test_image_property_delete(self):
|
||||
|
@ -282,7 +282,7 @@ class DriverTests(object):
|
|||
|
||||
def test_image_get(self):
|
||||
image = self.db_api.image_get(self.context, UUID1)
|
||||
self.assertEqual(image['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(self.fixtures[0]['id'], image['id'])
|
||||
|
||||
def test_image_get_disallow_deleted(self):
|
||||
self.db_api.image_destroy(self.adm_context, UUID1)
|
||||
|
@ -292,14 +292,14 @@ class DriverTests(object):
|
|||
def test_image_get_allow_deleted(self):
|
||||
self.db_api.image_destroy(self.adm_context, UUID1)
|
||||
image = self.db_api.image_get(self.adm_context, UUID1)
|
||||
self.assertEqual(image['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(self.fixtures[0]['id'], image['id'])
|
||||
self.assertTrue(image['deleted'])
|
||||
|
||||
def test_image_get_force_allow_deleted(self):
|
||||
self.db_api.image_destroy(self.adm_context, UUID1)
|
||||
image = self.db_api.image_get(self.context, UUID1,
|
||||
force_show_deleted=True)
|
||||
self.assertEqual(image['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(self.fixtures[0]['id'], image['id'])
|
||||
|
||||
def test_image_get_not_owned(self):
|
||||
TENANT1 = str(uuid.uuid4())
|
||||
|
@ -327,37 +327,37 @@ class DriverTests(object):
|
|||
filters={
|
||||
'id': self.fixtures[0]['id'],
|
||||
})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(images[0]['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(self.fixtures[0]['id'], images[0]['id'])
|
||||
|
||||
def test_image_get_all_with_filter_user_defined_property(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'foo': 'bar'})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(images[0]['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(self.fixtures[0]['id'], images[0]['id'])
|
||||
|
||||
def test_image_get_all_with_filter_nonexistent_userdef_property(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'faz': 'boo'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_with_filter_userdef_prop_nonexistent_value(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'foo': 'baz'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_with_filter_multiple_user_defined_properties(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'foo': 'bar',
|
||||
'far': 'boo'})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(images[0]['id'], self.fixtures[0]['id'])
|
||||
|
||||
def test_image_get_all_with_filter_nonexistent_user_defined_property(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'foo': 'bar',
|
||||
'faz': 'boo'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_with_filter_user_deleted_property(self):
|
||||
fixture = {'name': 'poo', 'value': 'bear', 'image_id': UUID1}
|
||||
|
@ -368,19 +368,19 @@ class DriverTests(object):
|
|||
filters={
|
||||
'properties': {'poo': 'bear'},
|
||||
})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
self.db_api.image_property_delete(self.context,
|
||||
prop['name'], images[0]['id'])
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={
|
||||
'properties': {'poo': 'bear'},
|
||||
})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_with_filter_undefined_property(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'poo': 'bear'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_size_min_max(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
|
@ -388,27 +388,27 @@ class DriverTests(object):
|
|||
'size_min': 10,
|
||||
'size_max': 15,
|
||||
})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(images[0]['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(self.fixtures[0]['id'], images[0]['id'])
|
||||
|
||||
def test_image_get_all_size_min(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'size_min': 15})
|
||||
self.assertEqual(len(images), 2)
|
||||
self.assertEqual(images[0]['id'], self.fixtures[2]['id'])
|
||||
self.assertEqual(images[1]['id'], self.fixtures[1]['id'])
|
||||
self.assertEqual(2, len(images))
|
||||
self.assertEqual(self.fixtures[2]['id'], images[0]['id'])
|
||||
self.assertEqual(self.fixtures[1]['id'], images[1]['id'])
|
||||
|
||||
def test_image_get_all_size_range(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'size_max': 15,
|
||||
'size_min': 20})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_size_max(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'size_max': 15})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(images[0]['id'], self.fixtures[0]['id'])
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(self.fixtures[0]['id'], images[0]['id'])
|
||||
|
||||
def test_image_get_all_with_filter_min_range_bad_value(self):
|
||||
self.assertRaises(exception.InvalidFilterRangeValue,
|
||||
|
@ -674,7 +674,7 @@ class DriverTests(object):
|
|||
self.db_api.image_tag_create(self.context, UUID2, '64bit')
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'tags': ['64bit']})
|
||||
self.assertEqual(len(images), 2)
|
||||
self.assertEqual(2, len(images))
|
||||
image_ids = [image['id'] for image in images]
|
||||
expected = [UUID1, UUID2]
|
||||
self.assertEqual(sorted(expected), sorted(image_ids))
|
||||
|
@ -687,7 +687,7 @@ class DriverTests(object):
|
|||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'tags': ['64bit', 'power']
|
||||
})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(UUID2, images[0]['id'])
|
||||
|
||||
def test_image_get_all_with_filter_tags_and_nonexistent(self):
|
||||
|
@ -695,7 +695,7 @@ class DriverTests(object):
|
|||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'tags': ['x86', 'fake']
|
||||
})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_with_filter_deleted_tags(self):
|
||||
tag = self.db_api.image_tag_create(self.context, UUID1, 'AIX')
|
||||
|
@ -703,18 +703,18 @@ class DriverTests(object):
|
|||
filters={
|
||||
'tags': [tag],
|
||||
})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
self.db_api.image_tag_delete(self.context, UUID1, tag)
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={
|
||||
'tags': [tag],
|
||||
})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_get_all_with_filter_undefined_tags(self):
|
||||
images = self.db_api.image_get_all(self.context,
|
||||
filters={'tags': ['fake']})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_image_paginate(self):
|
||||
"""Paginate through a list of images using limit and marker"""
|
||||
|
@ -764,7 +764,7 @@ class DriverTests(object):
|
|||
|
||||
for image in images:
|
||||
self.assertIn('tags', image)
|
||||
self.assertEqual(image['tags'], expected_tags[image['id']])
|
||||
self.assertEqual(expected_tags[image['id']], image['tags'])
|
||||
|
||||
self.db_api.image_tag_delete(self.context, UUID1,
|
||||
expected_tags[UUID1][0])
|
||||
|
@ -775,7 +775,7 @@ class DriverTests(object):
|
|||
|
||||
for image in images:
|
||||
self.assertIn('tags', image)
|
||||
self.assertEqual(image['tags'], expected_tags[image['id']])
|
||||
self.assertEqual(expected_tags[image['id']], image['tags'])
|
||||
|
||||
def test_image_destroy(self):
|
||||
location_data = [{'url': 'a', 'metadata': {'key': 'value'},
|
||||
|
@ -861,7 +861,7 @@ class DriverTests(object):
|
|||
self.assertFalse(active_image['deleted'])
|
||||
self.assertFalse(active_image['deleted_at'])
|
||||
|
||||
self.assertEqual(len(active_image['locations']), 2)
|
||||
self.assertEqual(2, len(active_image['locations']))
|
||||
self.assertTrue('id' in active_image['locations'][0])
|
||||
self.assertTrue('id' in active_image['locations'][1])
|
||||
active_image['locations'][0].pop('id')
|
||||
|
@ -1193,7 +1193,7 @@ class DriverTests(object):
|
|||
|
||||
actual = self.db_api.image_member_count(self.context, UUID1)
|
||||
|
||||
self.assertEqual(actual, 1)
|
||||
self.assertEqual(1, actual)
|
||||
|
||||
def test_image_member_count_invalid_image_id(self):
|
||||
TENANT1 = str(uuid.uuid4())
|
||||
|
@ -1382,10 +1382,10 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
filters={'type': 'import'})
|
||||
|
||||
self.assertTrue(import_tasks)
|
||||
self.assertEqual(len(import_tasks), 2)
|
||||
self.assertEqual(2, len(import_tasks))
|
||||
for task in import_tasks:
|
||||
self.assertEqual(task['type'], 'import')
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual('import', task['type'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
|
||||
def test_task_get_all_as_admin(self):
|
||||
tasks = []
|
||||
|
@ -1395,7 +1395,7 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
tasks.append(task)
|
||||
import_tasks = self.db_api.task_get_all(self.adm_context)
|
||||
self.assertTrue(import_tasks)
|
||||
self.assertEqual(len(import_tasks), 3)
|
||||
self.assertEqual(3, len(import_tasks))
|
||||
|
||||
def test_task_get_all_marker(self):
|
||||
for fixture in self.fixtures:
|
||||
|
@ -1405,7 +1405,7 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
task_ids = [t['id'] for t in tasks]
|
||||
tasks = self.db_api.task_get_all(self.adm_context, sort_key='id',
|
||||
marker=task_ids[0])
|
||||
self.assertEqual(len(tasks), 2)
|
||||
self.assertEqual(2, len(tasks))
|
||||
|
||||
def test_task_get_all_limit(self):
|
||||
for fixture in self.fixtures:
|
||||
|
@ -1470,14 +1470,14 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
task = self.db_api.task_get(self.adm_context, task_id)
|
||||
|
||||
self.assertIsNotNone(task)
|
||||
self.assertEqual(task['id'], task_id)
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual(task['type'], 'import')
|
||||
self.assertEqual(task['status'], 'pending')
|
||||
self.assertEqual(task['input'], fixture['input'])
|
||||
self.assertEqual(task['result'], fixture['result'])
|
||||
self.assertEqual(task['message'], fixture['message'])
|
||||
self.assertEqual(task['expires_at'], expires_at)
|
||||
self.assertEqual(task_id, task['id'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
self.assertEqual('import', task['type'])
|
||||
self.assertEqual('pending', task['status'])
|
||||
self.assertEqual(fixture['input'], task['input'])
|
||||
self.assertEqual(fixture['result'], task['result'])
|
||||
self.assertEqual(fixture['message'], task['message'])
|
||||
self.assertEqual(expires_at, task['expires_at'])
|
||||
|
||||
def test_task_get_all(self):
|
||||
now = timeutils.utcnow()
|
||||
|
@ -1517,20 +1517,20 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
task_fixtures = {task1_id: fixture1, task2_id: fixture2}
|
||||
tasks = self.db_api.task_get_all(self.adm_context)
|
||||
|
||||
self.assertEqual(len(tasks), 2)
|
||||
self.assertEqual(2, len(tasks))
|
||||
self.assertEqual(set((tasks[0]['id'], tasks[1]['id'])),
|
||||
set((task1_id, task2_id)))
|
||||
for task in tasks:
|
||||
fixture = task_fixtures[task['id']]
|
||||
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual(task['type'], fixture['type'])
|
||||
self.assertEqual(task['status'], fixture['status'])
|
||||
self.assertEqual(task['expires_at'], fixture['expires_at'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
self.assertEqual(fixture['type'], task['type'])
|
||||
self.assertEqual(fixture['status'], task['status'])
|
||||
self.assertEqual(fixture['expires_at'], task['expires_at'])
|
||||
self.assertFalse(task['deleted'])
|
||||
self.assertIsNone(task['deleted_at'])
|
||||
self.assertEqual(task['created_at'], fixture['created_at'])
|
||||
self.assertEqual(task['updated_at'], fixture['updated_at'])
|
||||
self.assertEqual(fixture['created_at'], task['created_at'])
|
||||
self.assertEqual(fixture['updated_at'], task['updated_at'])
|
||||
task_details_keys = ['input', 'message', 'result']
|
||||
for key in task_details_keys:
|
||||
self.assertFalse(key in task)
|
||||
|
@ -1547,11 +1547,11 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
task_values = build_task_fixture(**values)
|
||||
task = self.db_api.task_create(self.adm_context, task_values)
|
||||
self.assertIsNotNone(task)
|
||||
self.assertEqual(task['id'], task_id)
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual(task['type'], 'export')
|
||||
self.assertEqual(task['status'], 'pending')
|
||||
self.assertEqual(task['input'], {'ping': 'pong'})
|
||||
self.assertEqual(task_id, task['id'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
self.assertEqual('export', task['type'])
|
||||
self.assertEqual('pending', task['status'])
|
||||
self.assertEqual({'ping': 'pong'}, task['input'])
|
||||
|
||||
def test_task_create_with_all_task_info_null(self):
|
||||
task_id = str(uuid.uuid4())
|
||||
|
@ -1568,10 +1568,10 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
task_values = build_task_fixture(**values)
|
||||
task = self.db_api.task_create(self.adm_context, task_values)
|
||||
self.assertIsNotNone(task)
|
||||
self.assertEqual(task['id'], task_id)
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual(task['type'], 'export')
|
||||
self.assertEqual(task['status'], 'pending')
|
||||
self.assertEqual(task_id, task['id'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
self.assertEqual('export', task['type'])
|
||||
self.assertEqual('pending', task['status'])
|
||||
self.assertIsNone(task['input'])
|
||||
self.assertIsNone(task['result'])
|
||||
self.assertIsNone(task['message'])
|
||||
|
@ -1590,17 +1590,17 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
}
|
||||
task = self.db_api.task_update(self.adm_context, task_id, fixture)
|
||||
|
||||
self.assertEqual(task['id'], task_id)
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual(task['type'], 'import')
|
||||
self.assertEqual(task['status'], 'processing')
|
||||
self.assertEqual(task['input'], {'ping': 'pong'})
|
||||
self.assertEqual(task['result'], result)
|
||||
self.assertEqual(task['message'], 'This is a error string')
|
||||
self.assertEqual(task_id, task['id'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
self.assertEqual('import', task['type'])
|
||||
self.assertEqual('processing', task['status'])
|
||||
self.assertEqual({'ping': 'pong'}, task['input'])
|
||||
self.assertEqual(result, task['result'])
|
||||
self.assertEqual('This is a error string', task['message'])
|
||||
self.assertFalse(task['deleted'])
|
||||
self.assertIsNone(task['deleted_at'])
|
||||
self.assertIsNone(task['expires_at'])
|
||||
self.assertEqual(task['created_at'], task_values['created_at'])
|
||||
self.assertEqual(task_values['created_at'], task['created_at'])
|
||||
self.assertTrue(task['updated_at'] > task['created_at'])
|
||||
|
||||
def test_task_update_with_all_task_info_null(self):
|
||||
|
@ -1615,17 +1615,17 @@ class TaskTests(test_utils.BaseTestCase):
|
|||
fixture = {'status': 'processing'}
|
||||
task = self.db_api.task_update(self.adm_context, task_id, fixture)
|
||||
|
||||
self.assertEqual(task['id'], task_id)
|
||||
self.assertEqual(task['owner'], self.context.owner)
|
||||
self.assertEqual(task['type'], 'import')
|
||||
self.assertEqual(task['status'], 'processing')
|
||||
self.assertEqual(task_id, task['id'])
|
||||
self.assertEqual(self.context.owner, task['owner'])
|
||||
self.assertEqual('import', task['type'])
|
||||
self.assertEqual('processing', task['status'])
|
||||
self.assertIsNone(task['input'])
|
||||
self.assertIsNone(task['result'])
|
||||
self.assertIsNone(task['message'])
|
||||
self.assertFalse(task['deleted'])
|
||||
self.assertIsNone(task['deleted_at'])
|
||||
self.assertIsNone(task['expires_at'])
|
||||
self.assertEqual(task['created_at'], task_values['created_at'])
|
||||
self.assertEqual(task_values['created_at'], task['created_at'])
|
||||
self.assertTrue(task['updated_at'] > task['created_at'])
|
||||
|
||||
def test_task_delete(self):
|
||||
|
@ -1712,119 +1712,119 @@ class VisibilityTests(object):
|
|||
|
||||
def test_unknown_admin_sees_all(self):
|
||||
images = self.db_api.image_get_all(self.admin_none_context)
|
||||
self.assertEqual(len(images), 8)
|
||||
self.assertEqual(8, len(images))
|
||||
|
||||
def test_unknown_admin_is_public_true(self):
|
||||
images = self.db_api.image_get_all(self.admin_none_context,
|
||||
is_public=True)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_unknown_admin_is_public_false(self):
|
||||
images = self.db_api.image_get_all(self.admin_none_context,
|
||||
is_public=False)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertFalse(i['is_public'])
|
||||
|
||||
def test_unknown_admin_is_public_none(self):
|
||||
images = self.db_api.image_get_all(self.admin_none_context)
|
||||
self.assertEqual(len(images), 8)
|
||||
self.assertEqual(8, len(images))
|
||||
|
||||
def test_unknown_admin_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.admin_none_context,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_unknown_admin_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.admin_none_context,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertFalse(i['is_public'])
|
||||
|
||||
def test_known_admin_sees_all(self):
|
||||
images = self.db_api.image_get_all(self.admin_context)
|
||||
self.assertEqual(len(images), 8)
|
||||
self.assertEqual(8, len(images))
|
||||
|
||||
def test_known_admin_is_public_true(self):
|
||||
images = self.db_api.image_get_all(self.admin_context, is_public=True)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_known_admin_is_public_false(self):
|
||||
images = self.db_api.image_get_all(self.admin_context,
|
||||
is_public=False)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertFalse(i['is_public'])
|
||||
|
||||
def test_known_admin_is_public_none(self):
|
||||
images = self.db_api.image_get_all(self.admin_context)
|
||||
self.assertEqual(len(images), 8)
|
||||
self.assertEqual(8, len(images))
|
||||
|
||||
def test_admin_as_user_true(self):
|
||||
images = self.db_api.image_get_all(self.admin_context,
|
||||
admin_as_user=True)
|
||||
self.assertEqual(len(images), 5)
|
||||
self.assertEqual(5, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'] or i['owner'] == self.admin_tenant)
|
||||
|
||||
def test_known_admin_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.admin_context,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_known_admin_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.admin_context,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertFalse(i['is_public'])
|
||||
|
||||
def test_what_unknown_user_sees(self):
|
||||
images = self.db_api.image_get_all(self.none_context)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_unknown_user_is_public_true(self):
|
||||
images = self.db_api.image_get_all(self.none_context, is_public=True)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_unknown_user_is_public_false(self):
|
||||
images = self.db_api.image_get_all(self.none_context, is_public=False)
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_unknown_user_is_public_none(self):
|
||||
images = self.db_api.image_get_all(self.none_context)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_unknown_user_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.none_context,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_unknown_user_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.none_context,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_what_tenant1_sees(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context)
|
||||
self.assertEqual(len(images), 5)
|
||||
self.assertEqual(5, len(images))
|
||||
for i in images:
|
||||
if not i['is_public']:
|
||||
self.assertEqual(i['owner'], self.tenant1)
|
||||
|
@ -1832,37 +1832,37 @@ class VisibilityTests(object):
|
|||
def test_tenant1_is_public_true(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
is_public=True)
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_tenant1_is_public_false(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
is_public=False)
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertFalse(images[0]['is_public'])
|
||||
self.assertEqual(images[0]['owner'], self.tenant1)
|
||||
|
||||
def test_tenant1_is_public_none(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context)
|
||||
self.assertEqual(len(images), 5)
|
||||
self.assertEqual(5, len(images))
|
||||
for i in images:
|
||||
if not i['is_public']:
|
||||
self.assertEqual(i['owner'], self.tenant1)
|
||||
self.assertEqual(self.tenant1, i['owner'])
|
||||
|
||||
def test_tenant1_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for i in images:
|
||||
self.assertTrue(i['is_public'])
|
||||
|
||||
def test_tenant1_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertFalse(images[0]['is_public'])
|
||||
self.assertEqual(images[0]['owner'], self.tenant1)
|
||||
self.assertEqual(self.tenant1, images[0]['owner'])
|
||||
|
||||
def _setup_is_public_red_herring(self):
|
||||
values = {
|
||||
|
@ -1878,15 +1878,15 @@ class VisibilityTests(object):
|
|||
self._setup_is_public_red_herring()
|
||||
images = self.db_api.image_get_all(self.admin_context,
|
||||
filters={'is_public': 'silly'})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(images[0]['name'], 'Red Herring')
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual('Red Herring', images[0]['name'])
|
||||
|
||||
def test_is_public_is_a_normal_filter_for_user(self):
|
||||
self._setup_is_public_red_herring()
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
filters={'is_public': 'silly'})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(images[0]['name'], 'Red Herring')
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual('Red Herring', images[0]['name'])
|
||||
|
||||
# NOTE(markwash): the following tests are sanity checks to make sure
|
||||
# visibility filtering and is_public=(True|False) do not interact in
|
||||
|
@ -1896,46 +1896,46 @@ class VisibilityTests(object):
|
|||
def test_admin_is_public_true_and_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.admin_context, is_public=True,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
|
||||
def test_admin_is_public_false_and_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.admin_context, is_public=False,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_admin_is_public_true_and_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.admin_context, is_public=True,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_admin_is_public_false_and_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.admin_context, is_public=False,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
|
||||
def test_tenant1_is_public_true_and_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
is_public=True,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
|
||||
def test_tenant1_is_public_false_and_visibility_public(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
is_public=False,
|
||||
filters={'visibility': 'public'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_tenant1_is_public_true_and_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
is_public=True,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
def test_tenant1_is_public_false_and_visibility_private(self):
|
||||
images = self.db_api.image_get_all(self.tenant1_context,
|
||||
is_public=False,
|
||||
filters={'visibility': 'private'})
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
|
||||
|
||||
class TestMembershipVisibility(test_utils.BaseTestCase):
|
||||
|
|
|
@ -132,7 +132,7 @@ class MetadefNamespaceTests(object):
|
|||
found = self.db_api.\
|
||||
metadef_namespace_get_all(self.context, filters=rt_filters,
|
||||
sort_key='created_at')
|
||||
self.assertEqual(len(found), 1)
|
||||
self.assertEqual(1, len(found))
|
||||
for item in found:
|
||||
self._assert_saved_fields(ns_fixture, item)
|
||||
|
||||
|
@ -142,7 +142,7 @@ class MetadefNamespaceTests(object):
|
|||
|
||||
created = self.db_api.metadef_namespace_create(self.context, fixture)
|
||||
self.assertIsNotNone(created['namespace'])
|
||||
self.assertEqual(created['namespace'], fixture['namespace'])
|
||||
self.assertEqual(fixture['namespace'], created['namespace'])
|
||||
delta_dict = copy.deepcopy(created)
|
||||
delta_dict.update(delta.copy())
|
||||
|
||||
|
@ -241,7 +241,7 @@ class MetadefPropertyTests(object):
|
|||
|
||||
found = self.db_api.\
|
||||
metadef_property_get_all(self.context, ns_created['namespace'])
|
||||
self.assertEqual(len(found), 2)
|
||||
self.assertEqual(2, len(found))
|
||||
|
||||
def test_property_update(self):
|
||||
delta = {'name': u'New-name', 'json_schema': u'new-schema'}
|
||||
|
@ -408,7 +408,7 @@ class MetadefResourceTypeTests(object):
|
|||
self.context)
|
||||
|
||||
test_len = len(resource_types_orig) + 1
|
||||
self.assertEqual(len(resource_types), test_len)
|
||||
self.assertEqual(test_len, len(resource_types))
|
||||
|
||||
|
||||
class MetadefResourceTypeAssociationTests(object):
|
||||
|
@ -464,7 +464,7 @@ class MetadefResourceTypeAssociationTests(object):
|
|||
found = self.db_api.\
|
||||
metadef_resource_type_association_get_all_by_namespace(
|
||||
self.context, ns_created['namespace'])
|
||||
self.assertEqual(len(found), 1)
|
||||
self.assertEqual(1, len(found))
|
||||
for item in found:
|
||||
self._assert_saved_fields(fixture, item)
|
||||
|
||||
|
|
|
@ -192,8 +192,8 @@ class TestRootApi(functional.FunctionalTest):
|
|||
path = 'http://%s:%d/v1/images' % ('127.0.0.1', self.api_port)
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'GET')
|
||||
self.assertEqual(response.status, 200)
|
||||
self.assertEqual(content, images_json)
|
||||
self.assertEqual(200, response.status)
|
||||
self.assertEqual(images_json, content)
|
||||
|
||||
# 3. GET / with Accept: unknown header
|
||||
# Verify version choices returned. Verify message in API log about
|
||||
|
@ -211,8 +211,8 @@ class TestRootApi(functional.FunctionalTest):
|
|||
http = httplib2.Http()
|
||||
headers = {'Accept': 'application/vnd.openstack.images-v1'}
|
||||
response, content = http.request(path, 'GET', headers=headers)
|
||||
self.assertEqual(response.status, 200)
|
||||
self.assertEqual(content, images_json)
|
||||
self.assertEqual(200, response.status)
|
||||
self.assertEqual(images_json, content)
|
||||
|
||||
# 5. GET /images with a Accept: application/vnd.openstack.compute-v1
|
||||
# header. Verify version choices returned. Verify message in API log
|
||||
|
@ -268,7 +268,7 @@ class TestRootApi(functional.FunctionalTest):
|
|||
path = 'http://%s:%d/v1/versions' % ('127.0.0.1', self.api_port)
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'GET')
|
||||
self.assertEqual(response.status, 404)
|
||||
self.assertEqual(404, response.status)
|
||||
|
||||
# Verify version choices returned
|
||||
path = 'http://%s:%d/v10' % ('127.0.0.1', self.api_port)
|
||||
|
|
|
@ -62,10 +62,10 @@ class TestBinGlanceCacheManage(functional.FunctionalTest):
|
|||
body=image_data)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], name)
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual(name, data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
return data['image']['id']
|
||||
|
||||
|
|
|
@ -62,10 +62,10 @@ class BaseCacheMiddlewareTest(object):
|
|||
body=image_data)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
image_id = data['image']['id']
|
||||
|
@ -234,10 +234,10 @@ class BaseCacheMiddlewareTest(object):
|
|||
body=image_data)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
image_id = data['image']['id']
|
||||
|
@ -359,10 +359,10 @@ class BaseCacheManageMiddlewareTest(object):
|
|||
body=image_data)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], name)
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual(name, data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
return data['image']['id']
|
||||
|
||||
|
@ -541,7 +541,7 @@ class BaseCacheManageMiddlewareTest(object):
|
|||
ids[x])
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'GET')
|
||||
self.assertEqual(response.status, 200,
|
||||
self.assertEqual(200, response.status,
|
||||
"Failed to find image %s" % ids[x])
|
||||
|
||||
# Verify images now in cache
|
||||
|
|
|
@ -139,10 +139,10 @@ class TestApi(functional.FunctionalTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
image_id = data['image']['id']
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 3. HEAD image
|
||||
|
@ -176,14 +176,14 @@ class TestApi(functional.FunctionalTest):
|
|||
'content-type': 'application/octet-stream'}
|
||||
|
||||
for expected_key, expected_value in expected_image_headers.items():
|
||||
self.assertEqual(response[expected_key], expected_value,
|
||||
self.assertEqual(expected_value, response[expected_key],
|
||||
"For key '%s' expected header value '%s'. "
|
||||
"Got '%s'" % (expected_key,
|
||||
expected_value,
|
||||
response[expected_key]))
|
||||
|
||||
for expected_key, expected_value in expected_std_headers.items():
|
||||
self.assertEqual(response[expected_key], expected_value,
|
||||
self.assertEqual(expected_value, response[expected_key],
|
||||
"For key '%s' expected header value '%s'. "
|
||||
"Got '%s'" % (expected_key,
|
||||
expected_value,
|
||||
|
@ -402,14 +402,14 @@ class TestApi(functional.FunctionalTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
image2_id = data['image']['id']
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image2")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image2", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
self.assertEqual(data['image']['properties']['distro'], 'Ubuntu')
|
||||
self.assertEqual(data['image']['properties']['arch'], 'i386')
|
||||
self.assertEqual(data['image']['properties']['foo'], 'bar')
|
||||
self.assertEqual('Ubuntu', data['image']['properties']['distro'])
|
||||
self.assertEqual('i386', data['image']['properties']['arch'])
|
||||
self.assertEqual('bar', data['image']['properties']['foo'])
|
||||
|
||||
# 19. HEAD image2
|
||||
# Verify image2 found now
|
||||
|
@ -587,10 +587,10 @@ class TestApi(functional.FunctionalTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
image_id = data['image']['id']
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 1. HEAD image
|
||||
|
@ -666,10 +666,10 @@ class TestApi(functional.FunctionalTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
image_id = data['image']['id']
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 1. HEAD image
|
||||
|
|
|
@ -65,7 +65,7 @@ class TestCopyToFile(functional.FunctionalTest):
|
|||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'POST', headers=headers,
|
||||
body=image_data)
|
||||
self.assertEqual(response.status, 201, content)
|
||||
self.assertEqual(201, response.status, content)
|
||||
data = jsonutils.loads(content)
|
||||
|
||||
original_image_id = data['image']['id']
|
||||
|
@ -81,7 +81,7 @@ class TestCopyToFile(functional.FunctionalTest):
|
|||
path = "http://%s:%d/v1/images" % ("127.0.0.1", self.api_port)
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(response.status, 201, content)
|
||||
self.assertEqual(201, response.status, content)
|
||||
data = jsonutils.loads(content)
|
||||
|
||||
copy_image_id = data['image']['id']
|
||||
|
@ -177,11 +177,11 @@ class TestCopyToFile(functional.FunctionalTest):
|
|||
path = "http://%s:%d/v1/images" % ("127.0.0.1", self.api_port)
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(response.status, 201, content)
|
||||
self.assertEqual(201, response.status, content)
|
||||
data = jsonutils.loads(content)
|
||||
|
||||
copy_image_id = data['image']['id']
|
||||
self.assertEqual(data['image']['status'], 'queued', content)
|
||||
self.assertEqual('queued', data['image']['status'], content)
|
||||
|
||||
path = "http://%s:%d/v1/images/%s" % ("127.0.0.1", self.api_port,
|
||||
copy_image_id)
|
||||
|
@ -202,7 +202,7 @@ class TestCopyToFile(functional.FunctionalTest):
|
|||
# GET image and make sure image content is as expected
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'GET')
|
||||
self.assertEqual(response.status, 200 if exists else 404)
|
||||
self.assertEqual(200 if exists else 404, response.status)
|
||||
|
||||
if exists:
|
||||
self.assertEqual(str(FIVE_KB), response['content-length'])
|
||||
|
@ -248,7 +248,7 @@ class TestCopyToFile(functional.FunctionalTest):
|
|||
path = "http://%s:%d/v1/images" % ("127.0.0.1", self.api_port)
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(response.status, 400, content)
|
||||
self.assertEqual(400, response.status, content)
|
||||
|
||||
expected = 'External sourcing not supported for store \'file\''
|
||||
msg = 'expected "%s" in "%s"' % (expected, content)
|
||||
|
@ -274,7 +274,7 @@ class TestCopyToFile(functional.FunctionalTest):
|
|||
path = "http://%s:%d/v1/images" % ("127.0.0.1", self.api_port)
|
||||
http = httplib2.Http()
|
||||
response, content = http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(response.status, 400, content)
|
||||
self.assertEqual(400, response.status, content)
|
||||
|
||||
expected = 'External sourcing not supported for store \'swift+config\''
|
||||
msg = 'expected "%s" in "%s"' % (expected, content)
|
||||
|
|
|
@ -60,10 +60,10 @@ class TestMiscellaneous(functional.FunctionalTest):
|
|||
body=image_data)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 2. REMOVE the image from the filesystem
|
||||
|
|
|
@ -156,10 +156,10 @@ class TestSSL(functional.FunctionalTest):
|
|||
body=image_data)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
image_id = data['image']['id']
|
||||
|
@ -195,22 +195,22 @@ class TestSSL(functional.FunctionalTest):
|
|||
'content-type': 'application/octet-stream'}
|
||||
|
||||
for expected_key, expected_value in expected_image_headers.items():
|
||||
self.assertEqual(response[expected_key], expected_value,
|
||||
self.assertEqual(expected_value, response[expected_key],
|
||||
"For key '%s' expected header value '%s'. "
|
||||
"Got '%s'" % (expected_key,
|
||||
expected_value,
|
||||
response[expected_key]))
|
||||
|
||||
for expected_key, expected_value in expected_std_headers.items():
|
||||
self.assertEqual(response[expected_key], expected_value,
|
||||
self.assertEqual(expected_value, response[expected_key],
|
||||
"For key '%s' expected header value '%s'. "
|
||||
"Got '%s'" % (expected_key,
|
||||
expected_value,
|
||||
response[expected_key]))
|
||||
|
||||
self.assertEqual("*" * FIVE_KB, content)
|
||||
self.assertEqual(hashlib.md5(content).hexdigest(),
|
||||
hashlib.md5("*" * FIVE_KB).hexdigest())
|
||||
self.assertEqual(hashlib.md5("*" * FIVE_KB).hexdigest(),
|
||||
hashlib.md5(content).hexdigest())
|
||||
|
||||
# 5. GET /images
|
||||
# Verify no public images
|
||||
|
@ -379,10 +379,10 @@ class TestSSL(functional.FunctionalTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertIsNone(data['image']['checksum'])
|
||||
self.assertEqual(data['image']['size'], 0)
|
||||
self.assertEqual(data['image']['container_format'], 'ovf')
|
||||
self.assertEqual(data['image']['disk_format'], 'raw')
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(0, data['image']['size'])
|
||||
self.assertEqual('ovf', data['image']['container_format'])
|
||||
self.assertEqual('raw', data['image']['disk_format'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
image_id = data['image']['id']
|
||||
|
@ -425,10 +425,10 @@ class TestSSL(functional.FunctionalTest):
|
|||
body=image_data)
|
||||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 5. HEAD image
|
||||
|
@ -506,7 +506,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 1. GET /images with no Accept: header
|
||||
# Verify version choices returned.
|
||||
|
@ -514,7 +514,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 2. GET /v1/images with no Accept: header
|
||||
# Verify empty images list returned.
|
||||
|
@ -522,7 +522,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(200, response.status)
|
||||
self.assertEqual(content, images_json)
|
||||
self.assertEqual(images_json, content)
|
||||
|
||||
# 3. GET / with Accept: unknown header
|
||||
# Verify version choices returned. Verify message in API log about
|
||||
|
@ -532,7 +532,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
headers = {'Accept': 'unknown'}
|
||||
response, content = https.request(path, 'GET', headers=headers)
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
self.assertTrue('Unknown version. Returning version choices'
|
||||
in open(self.api_server.log_file).read())
|
||||
|
||||
|
@ -543,7 +543,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
headers = {'Accept': 'application/vnd.openstack.images-v1'}
|
||||
response, content = https.request(path, 'GET', headers=headers)
|
||||
self.assertEqual(200, response.status)
|
||||
self.assertEqual(content, images_json)
|
||||
self.assertEqual(images_json, content)
|
||||
|
||||
# 5. GET /images with a Accept: application/vnd.openstack.compute-v1
|
||||
# header. Verify version choices returned. Verify message in API log
|
||||
|
@ -553,7 +553,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
headers = {'Accept': 'application/vnd.openstack.compute-v1'}
|
||||
response, content = https.request(path, 'GET', headers=headers)
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
self.assertTrue('Unknown version. Returning version choices'
|
||||
in open(self.api_server.log_file).read())
|
||||
|
||||
|
@ -563,7 +563,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(200, response.status)
|
||||
self.assertEqual(content, images_json)
|
||||
self.assertEqual(images_json, content)
|
||||
|
||||
# 7. GET /v1.a/images with no Accept: header
|
||||
# Verify versions list returned
|
||||
|
@ -571,7 +571,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 8. GET /va.1/images with no Accept: header
|
||||
# Verify version choices returned
|
||||
|
@ -579,7 +579,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 9. GET /versions with no Accept: header
|
||||
# Verify version choices returned
|
||||
|
@ -587,7 +587,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 10. GET /versions with a Accept: application/vnd.openstack.images-v1
|
||||
# header. Verify version choices returned.
|
||||
|
@ -596,7 +596,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
headers = {'Accept': 'application/vnd.openstack.images-v1'}
|
||||
response, content = https.request(path, 'GET', headers=headers)
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 11. GET /v1/versions with no Accept: header
|
||||
# Verify 404 returned
|
||||
|
@ -618,7 +618,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
# 13. GET /images with a Accept: application/vnd.openstack.compute-v3
|
||||
# header. Verify version choices returned. Verify message in API log
|
||||
|
@ -628,7 +628,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
headers = {'Accept': 'application/vnd.openstack.images-v3'}
|
||||
response, content = https.request(path, 'GET', headers=headers)
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
self.assertTrue('Unknown version. Returning version choices'
|
||||
in open(self.api_server.log_file).read())
|
||||
|
||||
|
@ -638,7 +638,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
https = httplib2.Http(disable_ssl_certificate_validation=True)
|
||||
response, content = https.request(path, 'GET')
|
||||
self.assertEqual(300, response.status)
|
||||
self.assertEqual(content, versions_json)
|
||||
self.assertEqual(versions_json, content)
|
||||
|
||||
self.stop_servers()
|
||||
|
||||
|
@ -707,7 +707,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
response, content = https.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['properties']['pants'], "are on")
|
||||
self.assertEqual("are on", data['image']['properties']['pants'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
headers = {'Content-Type': 'application/octet-stream',
|
||||
|
@ -723,7 +723,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
response, content = https.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['properties']['pants'], "are on")
|
||||
self.assertEqual("are on", data['image']['properties']['pants'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
headers = {'Content-Type': 'application/octet-stream',
|
||||
|
@ -739,7 +739,7 @@ class TestSSL(functional.FunctionalTest):
|
|||
response, content = https.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['properties']['pants'], "are off")
|
||||
self.assertEqual("are off", data['image']['properties']['pants'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
headers = {'Content-Type': 'application/octet-stream',
|
||||
|
|
|
@ -150,7 +150,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Image list should now have one entry
|
||||
path = self._url('/v2/images')
|
||||
|
@ -158,7 +158,7 @@ class TestImages(functional.FunctionalTest):
|
|||
self.assertEqual(200, response.status_code)
|
||||
images = jsonutils.loads(response.text)['images']
|
||||
self.assertEqual(1, len(images))
|
||||
self.assertEqual(images[0]['id'], image_id)
|
||||
self.assertEqual(image_id, images[0]['id'])
|
||||
|
||||
# Create another image (with two deployer-defined properties)
|
||||
path = self._url('/v2/images')
|
||||
|
@ -210,7 +210,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Image list should now have two entries
|
||||
path = self._url('/v2/images')
|
||||
|
@ -565,7 +565,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in six.iteritems(expected_image):
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Upload data to image
|
||||
path = self._url('/v2/images/%s/file' % image_id)
|
||||
|
@ -630,7 +630,7 @@ class TestImages(functional.FunctionalTest):
|
|||
}
|
||||
|
||||
for key, value in six.iteritems(expected_image):
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Upload data to image
|
||||
path = self._url('/v2/images/%s/file' % image_id)
|
||||
|
@ -696,7 +696,7 @@ class TestImages(functional.FunctionalTest):
|
|||
}
|
||||
|
||||
for key, value in six.iteritems(expected_image):
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, value, key)
|
||||
|
||||
# Upload data to image
|
||||
path = self._url('/v2/images/%s/file' % image_id)
|
||||
|
@ -926,7 +926,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Create an image for role spl_role with extra props
|
||||
path = self._url('/v2/images')
|
||||
|
@ -1074,7 +1074,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Create an image for role spl_role with extra props
|
||||
path = self._url('/v2/images')
|
||||
|
@ -1213,7 +1213,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
path = self._url('/v2/images')
|
||||
headers = self._headers({'content-type': 'application/json',
|
||||
'X-Roles': 'joe_soap'})
|
||||
|
@ -1241,7 +1241,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Verify both admin and unknown role can read properties marked with
|
||||
# '@'
|
||||
|
@ -1490,7 +1490,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
path = self._url('/v2/images')
|
||||
headers = self._headers({'content-type': 'application/json',
|
||||
'X-Roles': 'joe_soap'})
|
||||
|
@ -1518,7 +1518,7 @@ class TestImages(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/image',
|
||||
}
|
||||
for key, value in expected_image.items():
|
||||
self.assertEqual(image[key], value, key)
|
||||
self.assertEqual(value, image[key], key)
|
||||
|
||||
# Verify both admin and unknown role can read properties marked with
|
||||
# '@'
|
||||
|
@ -2024,76 +2024,76 @@ class TestImages(functional.FunctionalTest):
|
|||
if visibility is not None:
|
||||
path += '?visibility=%s' % visibility
|
||||
response = requests.get(path, headers=headers)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(200, response.status_code)
|
||||
return jsonutils.loads(response.text)['images']
|
||||
|
||||
# 1. Known user sees public and their own images
|
||||
images = list_images('tenant1')
|
||||
self.assertEqual(len(images), 5)
|
||||
self.assertEqual(5, len(images))
|
||||
for image in images:
|
||||
self.assertTrue(image['visibility'] == 'public'
|
||||
or 'tenant1' in image['name'])
|
||||
|
||||
# 2. Known user, visibility=public, sees all public images
|
||||
images = list_images('tenant1', visibility='public')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'public')
|
||||
self.assertEqual('public', image['visibility'])
|
||||
|
||||
# 3. Known user, visibility=private, sees only their private image
|
||||
images = list_images('tenant1', visibility='private')
|
||||
self.assertEqual(len(images), 1)
|
||||
self.assertEqual(1, len(images))
|
||||
image = images[0]
|
||||
self.assertEqual(image['visibility'], 'private')
|
||||
self.assertEqual('private', image['visibility'])
|
||||
self.assertTrue('tenant1' in image['name'])
|
||||
|
||||
# 4. Unknown user sees only public images
|
||||
images = list_images('none')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'public')
|
||||
self.assertEqual('public', image['visibility'])
|
||||
|
||||
# 5. Unknown user, visibility=public, sees only public images
|
||||
images = list_images('none', visibility='public')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'public')
|
||||
self.assertEqual('public', image['visibility'])
|
||||
|
||||
# 6. Unknown user, visibility=private, sees no images
|
||||
images = list_images('none', visibility='private')
|
||||
self.assertEqual(len(images), 0)
|
||||
self.assertEqual(0, len(images))
|
||||
|
||||
# 7. Unknown admin sees all images
|
||||
images = list_images('none', role='admin')
|
||||
self.assertEqual(len(images), 8)
|
||||
self.assertEqual(8, len(images))
|
||||
|
||||
# 8. Unknown admin, visibility=public, shows only public images
|
||||
images = list_images('none', role='admin', visibility='public')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'public')
|
||||
self.assertEqual('public', image['visibility'])
|
||||
|
||||
# 9. Unknown admin, visibility=private, sees only private images
|
||||
images = list_images('none', role='admin', visibility='private')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'private')
|
||||
self.assertEqual('private', image['visibility'])
|
||||
|
||||
# 10. Known admin sees all images
|
||||
images = list_images('admin', role='admin')
|
||||
self.assertEqual(len(images), 8)
|
||||
self.assertEqual(8, len(images))
|
||||
|
||||
# 11. Known admin, visibility=public, sees all public images
|
||||
images = list_images('admin', role='admin', visibility='public')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'public')
|
||||
self.assertEqual('public', image['visibility'])
|
||||
|
||||
# 12. Known admin, visibility=private, sees all private images
|
||||
images = list_images('admin', role='admin', visibility='private')
|
||||
self.assertEqual(len(images), 4)
|
||||
self.assertEqual(4, len(images))
|
||||
for image in images:
|
||||
self.assertEqual(image['visibility'], 'private')
|
||||
self.assertEqual('private', image['visibility'])
|
||||
|
||||
self.stop_servers()
|
||||
|
||||
|
@ -2110,7 +2110,7 @@ class TestImages(functional.FunctionalTest):
|
|||
# Returned image entity should have a generated id and status
|
||||
image = jsonutils.loads(response.text)
|
||||
image_id = image['id']
|
||||
self.assertEqual(image['status'], 'queued')
|
||||
self.assertEqual('queued', image['status'])
|
||||
self.assertNotIn('size', image)
|
||||
self.assertNotIn('virtual_size', image)
|
||||
|
||||
|
@ -2133,7 +2133,7 @@ class TestImages(functional.FunctionalTest):
|
|||
response = requests.get(path, headers=headers)
|
||||
self.assertEqual(200, response.status_code)
|
||||
image = jsonutils.loads(response.text)
|
||||
self.assertEqual(image['size'], 6)
|
||||
self.assertEqual(6, image['size'])
|
||||
|
||||
|
||||
class TestImagesWithRegistry(TestImages):
|
||||
|
@ -2439,9 +2439,9 @@ class TestImageLocationSelectionStrategy(functional.FunctionalTest):
|
|||
self.assertEqual(200, response.status_code)
|
||||
image = jsonutils.loads(response.text)
|
||||
self.assertTrue('locations' in image)
|
||||
self.assertEqual(image['locations'], values)
|
||||
self.assertEqual(values, image['locations'])
|
||||
self.assertTrue('direct_url' in image)
|
||||
self.assertEqual(image['direct_url'], values[0]['url'])
|
||||
self.assertEqual(values[0]['url'], image['direct_url'])
|
||||
|
||||
self.stop_servers()
|
||||
|
||||
|
@ -2500,9 +2500,9 @@ class TestImageLocationSelectionStrategy(functional.FunctionalTest):
|
|||
self.assertEqual(200, response.status_code)
|
||||
image = jsonutils.loads(response.text)
|
||||
self.assertTrue('locations' in image)
|
||||
self.assertEqual(image['locations'], values)
|
||||
self.assertEqual(values, image['locations'])
|
||||
self.assertTrue('direct_url' in image)
|
||||
self.assertEqual(image['direct_url'], values[0]['url'])
|
||||
self.assertEqual(values[0]['url'], image['direct_url'])
|
||||
|
||||
self.stop_servers()
|
||||
|
||||
|
@ -2680,9 +2680,9 @@ class TestImageMembers(functional.FunctionalTest):
|
|||
response = requests.get(path, headers=get_header('tenant1'))
|
||||
self.assertEqual(200, response.status_code)
|
||||
body = jsonutils.loads(response.text)
|
||||
self.assertEqual(body['status'], 'pending')
|
||||
self.assertEqual(body['image_id'], image_fixture[1]['id'])
|
||||
self.assertEqual(body['member_id'], TENANT3)
|
||||
self.assertEqual('pending', body['status'])
|
||||
self.assertEqual(image_fixture[1]['id'], body['image_id'])
|
||||
self.assertEqual(TENANT3, body['member_id'])
|
||||
|
||||
# Tenant 3, who is the member can get status of its own status
|
||||
path = self._url('/v2/images/%s/members/%s' % (image_fixture[1]['id'],
|
||||
|
@ -2690,9 +2690,9 @@ class TestImageMembers(functional.FunctionalTest):
|
|||
response = requests.get(path, headers=get_header(TENANT3))
|
||||
self.assertEqual(200, response.status_code)
|
||||
body = jsonutils.loads(response.text)
|
||||
self.assertEqual(body['status'], 'pending')
|
||||
self.assertEqual(body['image_id'], image_fixture[1]['id'])
|
||||
self.assertEqual(body['member_id'], TENANT3)
|
||||
self.assertEqual('pending', body['status'])
|
||||
self.assertEqual(image_fixture[1]['id'], body['image_id'])
|
||||
self.assertEqual(TENANT3, body['member_id'])
|
||||
|
||||
# Tenant 2, who not the owner cannot get status of image member
|
||||
path = self._url('/v2/images/%s/members/%s' % (image_fixture[1]['id'],
|
||||
|
|
|
@ -107,20 +107,20 @@ class TestTasks(functional.FunctionalTest):
|
|||
'schema': '/v2/schemas/task',
|
||||
}
|
||||
for key, value in expected_task.items():
|
||||
self.assertEqual(task[key], value, key)
|
||||
self.assertEqual(value, task[key], key)
|
||||
|
||||
# Tasks list should now have one entry
|
||||
path = self._url('/v2/tasks')
|
||||
response = requests.get(path, headers=self._headers())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(200, response.status_code)
|
||||
tasks = jsonutils.loads(response.text)['tasks']
|
||||
self.assertEqual(len(tasks), 1)
|
||||
self.assertEqual(tasks[0]['id'], task_id)
|
||||
self.assertEqual(1, len(tasks))
|
||||
self.assertEqual(task_id, tasks[0]['id'])
|
||||
|
||||
# Attempt to delete a task
|
||||
path = self._url('/v2/tasks/%s' % tasks[0]['id'])
|
||||
response = requests.delete(path, headers=self._headers())
|
||||
self.assertEqual(response.status_code, 405)
|
||||
self.assertEqual(405, response.status_code)
|
||||
self.assertIsNotNone(response.headers.get('Allow'))
|
||||
self.assertEqual('GET', response.headers.get('Allow'))
|
||||
|
||||
|
|
|
@ -53,10 +53,10 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
image_id = data['image']['id']
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 3. HEAD image
|
||||
|
@ -86,14 +86,14 @@ class TestApi(base.ApiTest):
|
|||
'content-type': 'application/octet-stream'}
|
||||
|
||||
for expected_key, expected_value in expected_image_headers.items():
|
||||
self.assertEqual(response[expected_key], expected_value,
|
||||
self.assertEqual(expected_value, response[expected_key],
|
||||
"For key '%s' expected header value '%s'. "
|
||||
"Got '%s'" % (expected_key,
|
||||
expected_value,
|
||||
response[expected_key]))
|
||||
|
||||
for expected_key, expected_value in expected_std_headers.items():
|
||||
self.assertEqual(response[expected_key], expected_value,
|
||||
self.assertEqual(expected_value, response[expected_key],
|
||||
"For key '%s' expected header value '%s'. "
|
||||
"Got '%s'" % (expected_key,
|
||||
expected_value,
|
||||
|
@ -257,10 +257,10 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertIsNone(data['image']['checksum'])
|
||||
self.assertEqual(data['image']['size'], 0)
|
||||
self.assertEqual(data['image']['container_format'], 'ovf')
|
||||
self.assertEqual(data['image']['disk_format'], 'raw')
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(0, data['image']['size'])
|
||||
self.assertEqual('ovf', data['image']['container_format'])
|
||||
self.assertEqual('raw', data['image']['disk_format'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
image_id = data['image']['id']
|
||||
|
@ -296,10 +296,10 @@ class TestApi(base.ApiTest):
|
|||
body=image_data)
|
||||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['checksum'],
|
||||
hashlib.md5(image_data).hexdigest())
|
||||
self.assertEqual(data['image']['size'], FIVE_KB)
|
||||
self.assertEqual(data['image']['name'], "Image1")
|
||||
self.assertEqual(hashlib.md5(image_data).hexdigest(),
|
||||
data['image']['checksum'])
|
||||
self.assertEqual(FIVE_KB, data['image']['size'])
|
||||
self.assertEqual("Image1", data['image']['name'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
|
||||
# 5. HEAD /images
|
||||
|
@ -427,7 +427,7 @@ class TestApi(base.ApiTest):
|
|||
response, content = self.http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['properties']['pants'], "are on")
|
||||
self.assertEqual("are on", data['image']['properties']['pants'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
image_ids.append(data['image']['id'])
|
||||
|
||||
|
@ -444,7 +444,7 @@ class TestApi(base.ApiTest):
|
|||
response, content = self.http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['properties']['pants'], "are on")
|
||||
self.assertEqual("are on", data['image']['properties']['pants'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
image_ids.append(data['image']['id'])
|
||||
|
||||
|
@ -461,7 +461,7 @@ class TestApi(base.ApiTest):
|
|||
response, content = self.http.request(path, 'POST', headers=headers)
|
||||
self.assertEqual(201, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(data['image']['properties']['pants'], "are off")
|
||||
self.assertEqual("are off", data['image']['properties']['pants'])
|
||||
self.assertTrue(data['image']['is_public'])
|
||||
image_ids.append(data['image']['id'])
|
||||
|
||||
|
@ -773,8 +773,8 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)['images']
|
||||
self.assertEqual(2, len(data))
|
||||
self.assertEqual(data[0]['id'], images[0]['id'])
|
||||
self.assertEqual(data[1]['id'], images[1]['id'])
|
||||
self.assertEqual(images[0]['id'], data[0]['id'])
|
||||
self.assertEqual(images[1]['id'], data[1]['id'])
|
||||
|
||||
# 4. GET /images with marker
|
||||
# Verify only two images were returned
|
||||
|
@ -784,8 +784,8 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)['images']
|
||||
self.assertEqual(2, len(data))
|
||||
self.assertEqual(data[0]['id'], images[1]['id'])
|
||||
self.assertEqual(data[1]['id'], images[2]['id'])
|
||||
self.assertEqual(images[1]['id'], data[0]['id'])
|
||||
self.assertEqual(images[2]['id'], data[1]['id'])
|
||||
|
||||
# 5. GET /images with marker and limit
|
||||
# Verify only one image was returned with the correct id
|
||||
|
@ -795,7 +795,7 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)['images']
|
||||
self.assertEqual(1, len(data))
|
||||
self.assertEqual(data[0]['id'], images[2]['id'])
|
||||
self.assertEqual(images[2]['id'], data[0]['id'])
|
||||
|
||||
# 6. GET /images/detail with marker and limit
|
||||
# Verify only one image was returned with the correct id
|
||||
|
@ -805,7 +805,7 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)['images']
|
||||
self.assertEqual(1, len(data))
|
||||
self.assertEqual(data[0]['id'], images[2]['id'])
|
||||
self.assertEqual(images[2]['id'], data[0]['id'])
|
||||
|
||||
# DELETE images
|
||||
for image_id in image_ids:
|
||||
|
@ -869,9 +869,9 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(3, len(data['images']))
|
||||
self.assertEqual(data['images'][0]['id'], image_ids[2])
|
||||
self.assertEqual(data['images'][1]['id'], image_ids[1])
|
||||
self.assertEqual(data['images'][2]['id'], image_ids[0])
|
||||
self.assertEqual(image_ids[2], data['images'][0]['id'])
|
||||
self.assertEqual(image_ids[1], data['images'][1]['id'])
|
||||
self.assertEqual(image_ids[0], data['images'][2]['id'])
|
||||
|
||||
# 3. GET /images sorted by name asc
|
||||
params = 'sort_key=name&sort_dir=asc'
|
||||
|
@ -880,9 +880,9 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(3, len(data['images']))
|
||||
self.assertEqual(data['images'][0]['id'], image_ids[1])
|
||||
self.assertEqual(data['images'][1]['id'], image_ids[0])
|
||||
self.assertEqual(data['images'][2]['id'], image_ids[2])
|
||||
self.assertEqual(image_ids[1], data['images'][0]['id'])
|
||||
self.assertEqual(image_ids[0], data['images'][1]['id'])
|
||||
self.assertEqual(image_ids[2], data['images'][2]['id'])
|
||||
|
||||
# 4. GET /images sorted by size desc
|
||||
params = 'sort_key=size&sort_dir=desc'
|
||||
|
@ -891,9 +891,9 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(3, len(data['images']))
|
||||
self.assertEqual(data['images'][0]['id'], image_ids[0])
|
||||
self.assertEqual(data['images'][1]['id'], image_ids[2])
|
||||
self.assertEqual(data['images'][2]['id'], image_ids[1])
|
||||
self.assertEqual(image_ids[0], data['images'][0]['id'])
|
||||
self.assertEqual(image_ids[2], data['images'][1]['id'])
|
||||
self.assertEqual(image_ids[1], data['images'][2]['id'])
|
||||
|
||||
# 5. GET /images sorted by size desc with a marker
|
||||
params = 'sort_key=size&sort_dir=desc&marker=%s' % image_ids[0]
|
||||
|
@ -902,8 +902,8 @@ class TestApi(base.ApiTest):
|
|||
self.assertEqual(200, response.status)
|
||||
data = jsonutils.loads(content)
|
||||
self.assertEqual(2, len(data['images']))
|
||||
self.assertEqual(data['images'][0]['id'], image_ids[2])
|
||||
self.assertEqual(data['images'][1]['id'], image_ids[1])
|
||||
self.assertEqual(image_ids[2], data['images'][0]['id'])
|
||||
self.assertEqual(image_ids[1], data['images'][1]['id'])
|
||||
|
||||
# 6. GET /images sorted by name asc with a marker
|
||||
params = 'sort_key=name&sort_dir=asc&marker=%s' % image_ids[2]
|
||||
|
|
|
@ -74,7 +74,7 @@ class TestTasksApi(base.ApiTest):
|
|||
headers=minimal_task_headers())
|
||||
content_dict = json.loads(content)
|
||||
|
||||
self.assertEqual(res.status, 200)
|
||||
self.assertEqual(200, res.status)
|
||||
res_tasks = content_dict['tasks']
|
||||
if len(res_tasks) != 0:
|
||||
for task in res_tasks:
|
||||
|
@ -521,7 +521,7 @@ class TestTasksApi(base.ApiTest):
|
|||
response, content = self.http.request(
|
||||
path, 'POST', headers=minimal_task_headers(task_owner),
|
||||
body=body_content)
|
||||
self.assertEqual(response.status, 201)
|
||||
self.assertEqual(201, response.status)
|
||||
|
||||
data = json.loads(content)
|
||||
task_id = data['id']
|
||||
|
@ -532,7 +532,7 @@ class TestTasksApi(base.ApiTest):
|
|||
response, content = self.http.request(path,
|
||||
'DELETE',
|
||||
headers=minimal_task_headers())
|
||||
self.assertEqual(response.status, 405)
|
||||
self.assertEqual(405, response.status)
|
||||
self.assertEqual('GET', response.webob_resp.headers.get('Allow'))
|
||||
self.assertEqual(('GET',), response.webob_resp.allow)
|
||||
self.assertEqual(('GET',), response.allow)
|
||||
|
@ -543,7 +543,7 @@ class TestTasksApi(base.ApiTest):
|
|||
response, content = self.http.request(path,
|
||||
'GET',
|
||||
headers=minimal_task_headers())
|
||||
self.assertEqual(response.status, 200)
|
||||
self.assertEqual(200, response.status)
|
||||
self.assertIsNotNone(content)
|
||||
|
||||
# NOTE(nikhil): wait for all task executions to finish before exiting
|
||||
|
|
|
@ -53,8 +53,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
"""
|
||||
|
||||
mock_images.return_value = []
|
||||
self.assertEqual(cache_manage.list_cached(mock.Mock(), ''),
|
||||
cache_manage.SUCCESS)
|
||||
self.assertEqual(cache_manage.SUCCESS,
|
||||
cache_manage.list_cached(mock.Mock(), ''))
|
||||
|
||||
@mock.patch.object(glance.image_cache.client.CacheClient,
|
||||
'get_queued_images')
|
||||
|
@ -79,12 +79,12 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
|
||||
mock_images.return_value = []
|
||||
|
||||
self.assertEqual(cache_manage.list_queued(mock.Mock(), ''),
|
||||
cache_manage.SUCCESS)
|
||||
self.assertEqual(cache_manage.SUCCESS,
|
||||
cache_manage.list_queued(mock.Mock(), ''))
|
||||
|
||||
def test_queue_image_without_index(self):
|
||||
self.assertEqual(cache_manage.queue_image(mock.Mock(), []),
|
||||
cache_manage.FAILURE)
|
||||
self.assertEqual(cache_manage.FAILURE,
|
||||
cache_manage.queue_image(mock.Mock(), []))
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'get_client')
|
||||
|
@ -95,8 +95,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
mock_confirm.return_value = False
|
||||
mock_options = mock.Mock()
|
||||
mock_options.force = False
|
||||
self.assertEqual(cache_manage.queue_image(mock_options, ['img_id']),
|
||||
cache_manage.SUCCESS)
|
||||
self.assertEqual(cache_manage.SUCCESS,
|
||||
cache_manage.queue_image(mock_options, ['img_id']))
|
||||
self.assertFalse(mock_client.called)
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
|
@ -111,16 +111,16 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
manager = mock.MagicMock()
|
||||
manager.attach_mock(mock_client, 'mock_client')
|
||||
|
||||
self.assertEqual(cache_manage.queue_image(mock_options, ['img_id']),
|
||||
cache_manage.SUCCESS)
|
||||
self.assertEqual(cache_manage.SUCCESS,
|
||||
cache_manage.queue_image(mock_options, ['img_id']))
|
||||
self.assertTrue(mock_client.called)
|
||||
self.assertIn(
|
||||
mock.call.mock_client().queue_image_for_caching('img_id'),
|
||||
manager.mock_calls)
|
||||
|
||||
def test_delete_cached_image_without_index(self):
|
||||
self.assertEqual(cache_manage.delete_cached_image(mock.Mock(), []),
|
||||
cache_manage.FAILURE)
|
||||
self.assertEqual(cache_manage.FAILURE,
|
||||
cache_manage.delete_cached_image(mock.Mock(), []))
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'get_client')
|
||||
|
@ -133,8 +133,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
mock_options = mock.Mock()
|
||||
mock_options.force = False
|
||||
self.assertEqual(
|
||||
cache_manage.delete_cached_image(mock_options, ['img_id']),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_cached_image(mock_options, ['img_id']))
|
||||
self.assertFalse(mock_client.called)
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
|
@ -151,8 +151,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
manager.attach_mock(mock_client, 'mock_client')
|
||||
|
||||
self.assertEqual(
|
||||
cache_manage.delete_cached_image(mock_options, ['img_id']),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_cached_image(mock_options, ['img_id']))
|
||||
|
||||
self.assertIn(
|
||||
mock.call.mock_client().delete_cached_image('img_id'),
|
||||
|
@ -169,8 +169,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
mock_options = mock.Mock()
|
||||
mock_options.force = False
|
||||
self.assertEqual(
|
||||
cache_manage.delete_all_cached_images(mock_options, None),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_all_cached_images(mock_options, None))
|
||||
self.assertFalse(mock_client.called)
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
|
@ -187,16 +187,16 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
manager.attach_mock(mock_client, 'mock_client')
|
||||
|
||||
self.assertEqual(
|
||||
cache_manage.delete_all_cached_images(mock_options, None),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_all_cached_images(mock_options, None))
|
||||
self.assertTrue(mock_client.called)
|
||||
self.assertIn(
|
||||
mock.call.mock_client().delete_all_cached_images(),
|
||||
manager.mock_calls)
|
||||
|
||||
def test_delete_queued_image_without_index(self):
|
||||
self.assertEqual(cache_manage.delete_queued_image(mock.Mock(), []),
|
||||
cache_manage.FAILURE)
|
||||
self.assertEqual(cache_manage.FAILURE,
|
||||
cache_manage.delete_queued_image(mock.Mock(), []))
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'get_client')
|
||||
|
@ -209,8 +209,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
mock_options = mock.Mock()
|
||||
mock_options.force = False
|
||||
self.assertEqual(
|
||||
cache_manage.delete_queued_image(mock_options, ['img_id']),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_queued_image(mock_options, ['img_id']))
|
||||
self.assertFalse(mock_client.called)
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
|
@ -227,8 +227,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
manager.attach_mock(mock_client, 'mock_client')
|
||||
|
||||
self.assertEqual(
|
||||
cache_manage.delete_queued_image(mock_options, ['img_id']),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_queued_image(mock_options, ['img_id']))
|
||||
self.assertTrue(mock_client.called)
|
||||
self.assertIn(
|
||||
mock.call.mock_client().delete_queued_image('img_id'),
|
||||
|
@ -245,8 +245,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
mock_options = mock.Mock()
|
||||
mock_options.force = False
|
||||
self.assertEqual(
|
||||
cache_manage.delete_all_queued_images(mock_options, None),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_all_queued_images(mock_options, None))
|
||||
self.assertFalse(mock_client.called)
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'user_confirm')
|
||||
|
@ -262,8 +262,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
manager.attach_mock(mock_client, 'mock_client')
|
||||
|
||||
self.assertEqual(
|
||||
cache_manage.delete_all_queued_images(mock_options, None),
|
||||
cache_manage.SUCCESS)
|
||||
cache_manage.SUCCESS,
|
||||
cache_manage.delete_all_queued_images(mock_options, None))
|
||||
self.assertTrue(mock_client.called)
|
||||
self.assertIn(
|
||||
mock.call.mock_client().delete_all_queued_images(),
|
||||
|
@ -273,15 +273,15 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
def test_catch_error_not_found(self, mock_function):
|
||||
mock_function.side_effect = exception.NotFound()
|
||||
|
||||
self.assertEqual(cache_manage.list_cached(mock.Mock(), None),
|
||||
cache_manage.FAILURE)
|
||||
self.assertEqual(cache_manage.FAILURE,
|
||||
cache_manage.list_cached(mock.Mock(), None))
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'get_client')
|
||||
def test_catch_error_forbidden(self, mock_function):
|
||||
mock_function.side_effect = exception.Forbidden()
|
||||
|
||||
self.assertEqual(cache_manage.list_cached(mock.Mock(), None),
|
||||
cache_manage.FAILURE)
|
||||
self.assertEqual(cache_manage.FAILURE,
|
||||
cache_manage.list_cached(mock.Mock(), None))
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'get_client')
|
||||
def test_catch_error_unhandled(self, mock_function):
|
||||
|
@ -289,8 +289,8 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
my_mock = mock.Mock()
|
||||
my_mock.debug = False
|
||||
|
||||
self.assertEqual(cache_manage.list_cached(my_mock, None),
|
||||
cache_manage.FAILURE)
|
||||
self.assertEqual(cache_manage.FAILURE,
|
||||
cache_manage.list_cached(my_mock, None))
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'get_client')
|
||||
def test_catch_error_unhandled_debug_mode(self, mock_function):
|
||||
|
@ -324,7 +324,7 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
|
||||
result = self.assertRaises(SystemExit, cache_manage.parse_options,
|
||||
oparser, [])
|
||||
self.assertEqual(result.code, 0)
|
||||
self.assertEqual(0, result.code)
|
||||
self.assertFalse(mock_lookup.called)
|
||||
|
||||
@mock.patch.object(optparse.OptionParser, 'print_usage')
|
||||
|
@ -334,7 +334,7 @@ class TestGlanceCmdManage(test_utils.BaseTestCase):
|
|||
|
||||
result = self.assertRaises(SystemExit, cache_manage.parse_options,
|
||||
oparser, ['-p', '1212'])
|
||||
self.assertEqual(result.code, 0)
|
||||
self.assertEqual(0, result.code)
|
||||
self.assertTrue(mock_printout.called)
|
||||
|
||||
@mock.patch.object(glance.cmd.cache_manage, 'lookup_command')
|
||||
|
|
|
@ -141,5 +141,5 @@ class TestMalformedRequest(test_utils.BaseTestCase):
|
|||
"""Test Glance redirects /v# to /v#/ with correct Location header"""
|
||||
req = webob.Request.blank('/v1.1')
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPFound.code)
|
||||
self.assertEqual(webob.exc.HTTPFound.code, res.status_int)
|
||||
self.assertEqual('http://localhost/v1/', res.location)
|
||||
|
|
|
@ -70,7 +70,7 @@ class TestClient(testtools.TestCase):
|
|||
headers = {"test": u'ni\xf1o'}
|
||||
resp = self.client.do_request('GET', '/v1/images/detail',
|
||||
headers=headers)
|
||||
self.assertEqual(resp, fake)
|
||||
self.assertEqual(fake, resp)
|
||||
|
||||
def test_http_encoding_params(self):
|
||||
httplib.HTTPConnection.request(
|
||||
|
@ -88,4 +88,4 @@ class TestClient(testtools.TestCase):
|
|||
params = {"test": u'ni\xf1o'}
|
||||
resp = self.client.do_request('GET', '/v1/images/detail',
|
||||
params=params)
|
||||
self.assertEqual(resp, fake)
|
||||
self.assertEqual(fake, resp)
|
||||
|
|
|
@ -197,7 +197,7 @@ class TestPropertyRulesWithRoles(base.IsolatedUnitTest):
|
|||
configuration file
|
||||
"""
|
||||
self.rules_checker = property_utils.PropertyRules(self.policy)
|
||||
self.assertEqual(property_utils.CONFIG.sections(), CONFIG_SECTIONS)
|
||||
self.assertEqual(CONFIG_SECTIONS, property_utils.CONFIG.sections())
|
||||
|
||||
def test_property_rules_loaded_in_order(self):
|
||||
"""
|
||||
|
|
|
@ -425,14 +425,14 @@ class TestUtils(test_utils.BaseTestCase):
|
|||
raise UnicodeError()
|
||||
|
||||
ret = utils.exception_to_str(Exception('error message'))
|
||||
self.assertEqual(ret, 'error message')
|
||||
self.assertEqual('error message', ret)
|
||||
|
||||
ret = utils.exception_to_str(Exception('\xa5 error message'))
|
||||
self.assertEqual(ret, ' error message')
|
||||
self.assertEqual(' error message', ret)
|
||||
|
||||
ret = utils.exception_to_str(FakeException('\xa5 error message'))
|
||||
self.assertEqual(ret, "Caught '%(exception)s' exception." %
|
||||
{'exception': 'FakeException'})
|
||||
self.assertEqual("Caught '%(exception)s' exception." %
|
||||
{'exception': 'FakeException'}, ret)
|
||||
|
||||
|
||||
class UUIDTestCase(test_utils.BaseTestCase):
|
||||
|
|
|
@ -65,8 +65,8 @@ class RequestTest(test_utils.BaseTestCase):
|
|||
request = wsgi.Request.blank('/tests/123')
|
||||
request.headers["Content-Range"] = 'bytes 10-99/*'
|
||||
range_ = request.get_content_range()
|
||||
self.assertEqual(range_.start, 10)
|
||||
self.assertEqual(range_.stop, 100) # non-inclusive
|
||||
self.assertEqual(10, range_.start)
|
||||
self.assertEqual(100, range_.stop) # non-inclusive
|
||||
self.assertIsNone(range_.length)
|
||||
|
||||
def test_content_range_invalid(self):
|
||||
|
@ -380,7 +380,7 @@ class JSONResponseSerializerTest(test_utils.BaseTestCase):
|
|||
fixture = set(["foo"])
|
||||
expected = '["foo"]'
|
||||
actual = wsgi.JSONResponseSerializer().to_json(fixture)
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_default(self):
|
||||
fixture = {"key": "value"}
|
||||
|
|
|
@ -74,9 +74,9 @@ class TestCacheMiddlewareRequestStashCacheInfo(testtools.TestCase):
|
|||
|
||||
def test_stash_cache_request_info(self):
|
||||
self.middleware._stash_request_info(self.request, 'asdf', 'GET', 'v2')
|
||||
self.assertEqual(self.request.environ['api.cache.image_id'], 'asdf')
|
||||
self.assertEqual(self.request.environ['api.cache.method'], 'GET')
|
||||
self.assertEqual(self.request.environ['api.cache.version'], 'v2')
|
||||
self.assertEqual('asdf', self.request.environ['api.cache.image_id'])
|
||||
self.assertEqual('GET', self.request.environ['api.cache.method'])
|
||||
self.assertEqual('v2', self.request.environ['api.cache.version'])
|
||||
|
||||
def test_fetch_cache_request_info(self):
|
||||
self.request.environ['api.cache.image_id'] = 'asdf'
|
||||
|
|
|
@ -166,7 +166,7 @@ class TestContext(utils.BaseTestCase):
|
|||
del local.store.context
|
||||
ctx = context.RequestContext()
|
||||
self.assertTrue(hasattr(local.store, 'context'))
|
||||
self.assertEqual(ctx, local.store.context)
|
||||
self.assertEqual(local.store.context, ctx)
|
||||
|
||||
def test_user_identity(self):
|
||||
ctx = context.RequestContext(user="user",
|
||||
|
|
|
@ -311,8 +311,8 @@ class TestImageRepo(test_utils.BaseTestCase):
|
|||
self.assertEqual(image.updated_at, image.created_at)
|
||||
self.image_repo.add(image)
|
||||
retreived_image = self.image_repo.get(image.image_id)
|
||||
self.assertEqual(retreived_image.name, 'added image')
|
||||
self.assertEqual(retreived_image.updated_at, image.updated_at)
|
||||
self.assertEqual('added image', retreived_image.name)
|
||||
self.assertEqual(image.updated_at, retreived_image.updated_at)
|
||||
|
||||
def test_save_image(self):
|
||||
image = self.image_repo.get(UUID1)
|
||||
|
@ -375,8 +375,8 @@ class TestEncryptedLocations(test_utils.BaseTestCase):
|
|||
self.assertNotEqual(db_data['locations'], ['foo', 'bar'])
|
||||
decrypted_locations = [crypt.urlsafe_decrypt(self.crypt_key, l['url'])
|
||||
for l in db_data['locations']]
|
||||
self.assertEqual(decrypted_locations,
|
||||
[l['url'] for l in self.foo_bar_location])
|
||||
self.assertEqual([l['url'] for l in self.foo_bar_location],
|
||||
decrypted_locations)
|
||||
|
||||
def test_encrypt_locations_on_save(self):
|
||||
image = self.image_factory.new_image(UUID1)
|
||||
|
@ -387,8 +387,8 @@ class TestEncryptedLocations(test_utils.BaseTestCase):
|
|||
self.assertNotEqual(db_data['locations'], ['foo', 'bar'])
|
||||
decrypted_locations = [crypt.urlsafe_decrypt(self.crypt_key, l['url'])
|
||||
for l in db_data['locations']]
|
||||
self.assertEqual(decrypted_locations,
|
||||
[l['url'] for l in self.foo_bar_location])
|
||||
self.assertEqual([l['url'] for l in self.foo_bar_location],
|
||||
decrypted_locations)
|
||||
|
||||
def test_decrypt_locations_on_get(self):
|
||||
url_loc = ['ping', 'pong']
|
||||
|
@ -407,7 +407,7 @@ class TestEncryptedLocations(test_utils.BaseTestCase):
|
|||
self.assertIn('id', image.locations[1])
|
||||
image.locations[0].pop('id')
|
||||
image.locations[1].pop('id')
|
||||
self.assertEqual(image.locations, orig_locations)
|
||||
self.assertEqual(orig_locations, image.locations)
|
||||
|
||||
def test_decrypt_locations_on_list(self):
|
||||
url_loc = ['ping', 'pong']
|
||||
|
@ -426,7 +426,7 @@ class TestEncryptedLocations(test_utils.BaseTestCase):
|
|||
self.assertIn('id', image.locations[1])
|
||||
image.locations[0].pop('id')
|
||||
image.locations[1].pop('id')
|
||||
self.assertEqual(image.locations, orig_locations)
|
||||
self.assertEqual(orig_locations, image.locations)
|
||||
|
||||
|
||||
class TestImageMemberRepo(test_utils.BaseTestCase):
|
||||
|
@ -493,10 +493,10 @@ class TestImageMemberRepo(test_utils.BaseTestCase):
|
|||
self.image_member_repo.add(image_member)
|
||||
retreived_image_member = self.image_member_repo.get(TENANT4)
|
||||
self.assertIsNotNone(retreived_image_member.id)
|
||||
self.assertEqual(retreived_image_member.image_id,
|
||||
image_member.image_id)
|
||||
self.assertEqual(retreived_image_member.member_id,
|
||||
image_member.member_id)
|
||||
self.assertEqual(image_member.image_id,
|
||||
retreived_image_member.image_id)
|
||||
self.assertEqual(image_member.member_id,
|
||||
retreived_image_member.member_id)
|
||||
self.assertEqual('pending', retreived_image_member.status)
|
||||
|
||||
def test_add_duplicate_image_member(self):
|
||||
|
@ -507,10 +507,10 @@ class TestImageMemberRepo(test_utils.BaseTestCase):
|
|||
self.image_member_repo.add(image_member)
|
||||
retreived_image_member = self.image_member_repo.get(TENANT4)
|
||||
self.assertIsNotNone(retreived_image_member.id)
|
||||
self.assertEqual(retreived_image_member.image_id,
|
||||
image_member.image_id)
|
||||
self.assertEqual(retreived_image_member.member_id,
|
||||
image_member.member_id)
|
||||
self.assertEqual(image_member.image_id,
|
||||
retreived_image_member.image_id)
|
||||
self.assertEqual(image_member.member_id,
|
||||
retreived_image_member.member_id)
|
||||
self.assertEqual('pending', retreived_image_member.status)
|
||||
|
||||
self.assertRaises(exception.Duplicate, self.image_member_repo.add,
|
||||
|
@ -680,7 +680,7 @@ class TestTaskRepo(test_utils.BaseTestCase):
|
|||
current_update_time = task.updated_at
|
||||
self.assertTrue(current_update_time > original_update_time)
|
||||
task = self.task_repo.get(UUID1)
|
||||
self.assertEqual(task.updated_at, current_update_time)
|
||||
self.assertEqual(current_update_time, task.updated_at)
|
||||
|
||||
def test_remove_task(self):
|
||||
task = self.task_repo.get(UUID1)
|
||||
|
@ -713,7 +713,7 @@ class RetryOnDeadlockTestCase(test_utils.BaseTestCase):
|
|||
try:
|
||||
api._image_update(None, {}, 'fake-id')
|
||||
except TestException:
|
||||
self.assertEqual(sess.call_count, 3)
|
||||
self.assertEqual(3, sess.call_count)
|
||||
|
||||
# Test retry on image destroy if db deadlock occurs
|
||||
self.attempts = 3
|
||||
|
@ -723,4 +723,4 @@ class RetryOnDeadlockTestCase(test_utils.BaseTestCase):
|
|||
try:
|
||||
api.image_destroy(None, 'fake-id')
|
||||
except TestException:
|
||||
self.assertEqual(sess.call_count, 3)
|
||||
self.assertEqual(3, sess.call_count)
|
||||
|
|
|
@ -193,12 +193,12 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
|
||||
def test_get_namespace(self):
|
||||
namespace = self.namespace_repo.get(NAMESPACE1)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE1)
|
||||
self.assertEqual(namespace.description, 'desc1')
|
||||
self.assertEqual(namespace.display_name, '1')
|
||||
self.assertEqual(namespace.owner, TENANT1)
|
||||
self.assertEqual(NAMESPACE1, namespace.namespace)
|
||||
self.assertEqual('desc1', namespace.description)
|
||||
self.assertEqual('1', namespace.display_name)
|
||||
self.assertEqual(TENANT1, namespace.owner)
|
||||
self.assertTrue(namespace.protected)
|
||||
self.assertEqual(namespace.visibility, 'private')
|
||||
self.assertEqual('private', namespace.visibility)
|
||||
|
||||
def test_get_namespace_not_found(self):
|
||||
fake_namespace = "fake_namespace"
|
||||
|
@ -234,10 +234,10 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
visibility='public',
|
||||
protected=True,
|
||||
owner=TENANT1)
|
||||
self.assertEqual(namespace['namespace'], 'added_namespace')
|
||||
self.assertEqual('added_namespace', namespace['namespace'])
|
||||
self.db.metadef_namespace_create(None, namespace)
|
||||
retrieved_namespace = self.namespace_repo.get(namespace['namespace'])
|
||||
self.assertEqual(retrieved_namespace.namespace, 'added_namespace')
|
||||
self.assertEqual('added_namespace', retrieved_namespace.namespace)
|
||||
|
||||
def test_save_namespace(self):
|
||||
namespace = self.namespace_repo.get(NAMESPACE1)
|
||||
|
@ -245,8 +245,8 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
namespace.description = 'save_desc'
|
||||
self.namespace_repo.save(namespace)
|
||||
namespace = self.namespace_repo.get(NAMESPACE1)
|
||||
self.assertEqual(namespace.display_name, 'save_name')
|
||||
self.assertEqual(namespace.description, 'save_desc')
|
||||
self.assertEqual('save_name', namespace.display_name)
|
||||
self.assertEqual('save_desc', namespace.description)
|
||||
|
||||
def test_remove_namespace(self):
|
||||
namespace = self.namespace_repo.get(NAMESPACE1)
|
||||
|
@ -265,8 +265,8 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
def test_get_property(self):
|
||||
property = self.property_repo.get(NAMESPACE1, PROPERTY1)
|
||||
namespace = self.namespace_repo.get(NAMESPACE1)
|
||||
self.assertEqual(property.name, PROPERTY1)
|
||||
self.assertEqual(property.namespace.namespace, namespace.namespace)
|
||||
self.assertEqual(PROPERTY1, property.name)
|
||||
self.assertEqual(namespace.namespace, property.namespace.namespace)
|
||||
|
||||
def test_get_property_not_found(self):
|
||||
exc = self.assertRaises(exception.NotFound,
|
||||
|
@ -296,18 +296,18 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
# property_factory when property primary key in DB
|
||||
# will be changed from Integer to UUID
|
||||
property = _db_property_fixture(name='added_property')
|
||||
self.assertEqual(property['name'], 'added_property')
|
||||
self.assertEqual('added_property', property['name'])
|
||||
self.db.metadef_property_create(self.context, NAMESPACE1, property)
|
||||
retrieved_property = self.property_repo.get(NAMESPACE1,
|
||||
'added_property')
|
||||
self.assertEqual(retrieved_property.name, 'added_property')
|
||||
self.assertEqual('added_property', retrieved_property.name)
|
||||
|
||||
def test_add_property_namespace_forbidden(self):
|
||||
# NOTE(pawel-koniszewski): Change db_property_fixture to
|
||||
# property_factory when property primary key in DB
|
||||
# will be changed from Integer to UUID
|
||||
property = _db_property_fixture(name='added_property')
|
||||
self.assertEqual(property['name'], 'added_property')
|
||||
self.assertEqual('added_property', property['name'])
|
||||
self.assertRaises(exception.Forbidden, self.db.metadef_property_create,
|
||||
self.context, NAMESPACE3, property)
|
||||
|
||||
|
@ -316,7 +316,7 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
# property_factory when property primary key in DB
|
||||
# will be changed from Integer to UUID
|
||||
property = _db_property_fixture(name='added_property')
|
||||
self.assertEqual(property['name'], 'added_property')
|
||||
self.assertEqual('added_property', property['name'])
|
||||
self.assertRaises(exception.NotFound, self.db.metadef_property_create,
|
||||
self.context, 'not_a_namespace', property)
|
||||
|
||||
|
@ -325,8 +325,8 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
property.schema = '{"save": "schema"}'
|
||||
self.property_repo.save(property)
|
||||
property = self.property_repo.get(NAMESPACE1, PROPERTY1)
|
||||
self.assertEqual(property.name, PROPERTY1)
|
||||
self.assertEqual(property.schema, '{"save": "schema"}')
|
||||
self.assertEqual(PROPERTY1, property.name)
|
||||
self.assertEqual('{"save": "schema"}', property.schema)
|
||||
|
||||
def test_remove_property(self):
|
||||
property = self.property_repo.get(NAMESPACE1, PROPERTY1)
|
||||
|
@ -344,11 +344,11 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
def test_get_object(self):
|
||||
object = self.object_repo.get(NAMESPACE1, OBJECT1)
|
||||
namespace = self.namespace_repo.get(NAMESPACE1)
|
||||
self.assertEqual(object.name, OBJECT1)
|
||||
self.assertEqual(object.description, 'desc1')
|
||||
self.assertEqual(object.required, ['[]'])
|
||||
self.assertEqual(object.properties, {})
|
||||
self.assertEqual(object.namespace.namespace, namespace.namespace)
|
||||
self.assertEqual(OBJECT1, object.name)
|
||||
self.assertEqual('desc1', object.description)
|
||||
self.assertEqual(['[]'], object.required)
|
||||
self.assertEqual({}, object.properties)
|
||||
self.assertEqual(namespace.namespace, object.namespace.namespace)
|
||||
|
||||
def test_get_object_not_found(self):
|
||||
exc = self.assertRaises(exception.NotFound, self.object_repo.get,
|
||||
|
@ -375,18 +375,18 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
# object_factory when object primary key in DB
|
||||
# will be changed from Integer to UUID
|
||||
object = _db_object_fixture(name='added_object')
|
||||
self.assertEqual(object['name'], 'added_object')
|
||||
self.assertEqual('added_object', object['name'])
|
||||
self.db.metadef_object_create(self.context, NAMESPACE1, object)
|
||||
retrieved_object = self.object_repo.get(NAMESPACE1,
|
||||
'added_object')
|
||||
self.assertEqual(retrieved_object.name, 'added_object')
|
||||
self.assertEqual('added_object', retrieved_object.name)
|
||||
|
||||
def test_add_object_namespace_forbidden(self):
|
||||
# NOTE(pawel-koniszewski): Change db_object_fixture to
|
||||
# object_factory when object primary key in DB
|
||||
# will be changed from Integer to UUID
|
||||
object = _db_object_fixture(name='added_object')
|
||||
self.assertEqual(object['name'], 'added_object')
|
||||
self.assertEqual('added_object', object['name'])
|
||||
self.assertRaises(exception.Forbidden, self.db.metadef_object_create,
|
||||
self.context, NAMESPACE3, object)
|
||||
|
||||
|
@ -395,7 +395,7 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
# object_factory when object primary key in DB
|
||||
# will be changed from Integer to UUID
|
||||
object = _db_object_fixture(name='added_object')
|
||||
self.assertEqual(object['name'], 'added_object')
|
||||
self.assertEqual('added_object', object['name'])
|
||||
self.assertRaises(exception.NotFound, self.db.metadef_object_create,
|
||||
self.context, 'not-a-namespace', object)
|
||||
|
||||
|
@ -405,9 +405,9 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
object.description = 'save_desc'
|
||||
self.object_repo.save(object)
|
||||
object = self.object_repo.get(NAMESPACE1, OBJECT1)
|
||||
self.assertEqual(object.name, OBJECT1)
|
||||
self.assertEqual(object.required, ['save_req'])
|
||||
self.assertEqual(object.description, 'save_desc')
|
||||
self.assertEqual(OBJECT1, object.name)
|
||||
self.assertEqual(['save_req'], object.required)
|
||||
self.assertEqual('save_desc', object.description)
|
||||
|
||||
def test_remove_object(self):
|
||||
object = self.object_repo.get(NAMESPACE1, OBJECT1)
|
||||
|
@ -425,4 +425,4 @@ class TestMetadefRepo(test_utils.BaseTestCase):
|
|||
def test_list_resource_type(self):
|
||||
resource_type = self.resource_type_repo.list(
|
||||
filters={'namespace': NAMESPACE1})
|
||||
self.assertEqual(len(resource_type), 0)
|
||||
self.assertEqual(0, len(resource_type))
|
||||
|
|
|
@ -60,9 +60,9 @@ class TestProxyRepoPlain(test_utils.BaseTestCase):
|
|||
self.fake_repo.result = base_result
|
||||
method = getattr(self.proxy_repo, name)
|
||||
proxy_result = method(*args, **kwargs)
|
||||
self.assertEqual(proxy_result, base_result)
|
||||
self.assertEqual(self.fake_repo.args, args)
|
||||
self.assertEqual(self.fake_repo.kwargs, kwargs)
|
||||
self.assertEqual(base_result, proxy_result)
|
||||
self.assertEqual(args, self.fake_repo.args)
|
||||
self.assertEqual(kwargs, self.fake_repo.kwargs)
|
||||
|
||||
def test_get(self):
|
||||
self._test_method('get', 'snarf', 'abcd')
|
||||
|
@ -93,11 +93,11 @@ class TestProxyRepoWrapping(test_utils.BaseTestCase):
|
|||
method = getattr(self.proxy_repo, name)
|
||||
proxy_result = method(*args, **kwargs)
|
||||
self.assertIsInstance(proxy_result, FakeProxy)
|
||||
self.assertEqual(proxy_result.base, base_result)
|
||||
self.assertEqual(base_result, proxy_result.base)
|
||||
self.assertEqual(0, len(proxy_result.args))
|
||||
self.assertEqual({'a': 1}, proxy_result.kwargs)
|
||||
self.assertEqual(self.fake_repo.args, args)
|
||||
self.assertEqual(self.fake_repo.kwargs, kwargs)
|
||||
self.assertEqual(args, self.fake_repo.args)
|
||||
self.assertEqual(kwargs, self.fake_repo.kwargs)
|
||||
|
||||
def test_get(self):
|
||||
self.fake_repo.result = 'snarf'
|
||||
|
|
|
@ -267,8 +267,8 @@ class ImageCacheTestCase(object):
|
|||
for x in xrange(3):
|
||||
self.assertTrue(self.cache.queue_image(x))
|
||||
|
||||
self.assertEqual(self.cache.get_queued_images(),
|
||||
['0', '1', '2'])
|
||||
self.assertEqual(['0', '1', '2'],
|
||||
self.cache.get_queued_images())
|
||||
|
||||
def test_open_for_write_good(self):
|
||||
"""
|
||||
|
@ -326,7 +326,7 @@ class ImageCacheTestCase(object):
|
|||
checksum = None
|
||||
caching_iter = self.cache.get_caching_iter(image_id, checksum,
|
||||
iter(data))
|
||||
self.assertEqual(list(caching_iter), data)
|
||||
self.assertEqual(data, list(caching_iter))
|
||||
|
||||
image_id = '1'
|
||||
self.assertFalse(self.cache.is_cached(image_id))
|
||||
|
@ -377,7 +377,7 @@ class ImageCacheTestCase(object):
|
|||
checksum = None
|
||||
caching_iter = self.cache.get_caching_iter(image_id, checksum,
|
||||
iter(data))
|
||||
self.assertEqual(caching_iter.next(), 'a')
|
||||
self.assertEqual('a', caching_iter.next())
|
||||
|
||||
image_id = '1'
|
||||
self.assertFalse(self.cache.is_cached(image_id))
|
||||
|
@ -532,7 +532,7 @@ class TestImageCacheNoDep(test_utils.BaseTestCase):
|
|||
data = ['a', 'b', 'c', 'Fail', 'd', 'e', 'f']
|
||||
|
||||
caching_iter = cache.get_caching_iter('dummy_id', None, iter(data))
|
||||
self.assertEqual(list(caching_iter), data)
|
||||
self.assertEqual(data, list(caching_iter))
|
||||
|
||||
def test_get_caching_iter_when_open_fails(self):
|
||||
|
||||
|
@ -550,4 +550,4 @@ class TestImageCacheNoDep(test_utils.BaseTestCase):
|
|||
data = ['a', 'b', 'c', 'd', 'e', 'f']
|
||||
|
||||
caching_iter = cache.get_caching_iter('dummy_id', None, iter(data))
|
||||
self.assertEqual(list(caching_iter), data)
|
||||
self.assertEqual(data, list(caching_iter))
|
||||
|
|
|
@ -92,10 +92,10 @@ class TestStoreImage(utils.BaseTestCase):
|
|||
image = glance.location.ImageProxy(self.image_stub, {},
|
||||
self.store_api, self.store_utils)
|
||||
location = image.locations[0]
|
||||
self.assertEqual(image.status, 'active')
|
||||
self.assertEqual('active', image.status)
|
||||
self.store_api.get_from_backend(location['url'], context={})
|
||||
image.delete()
|
||||
self.assertEqual(image.status, 'deleted')
|
||||
self.assertEqual('deleted', image.status)
|
||||
self.assertRaises(glance_store.NotFound,
|
||||
self.store_api.get_from_backend, location['url'], {})
|
||||
|
||||
|
@ -140,7 +140,7 @@ class TestStoreImage(utils.BaseTestCase):
|
|||
image = glance.location.ImageProxy(image_stub, context,
|
||||
self.store_api, self.store_utils)
|
||||
image.set_data('YYYY', 4)
|
||||
self.assertEqual(image.size, 4)
|
||||
self.assertEqual(4, image.size)
|
||||
# NOTE(markwash): FakeStore returns image_id for location
|
||||
self.assertEqual(UUID2, image.locations[0]['url'])
|
||||
self.assertEqual('Z', image.checksum)
|
||||
|
@ -173,7 +173,7 @@ class TestStoreImage(utils.BaseTestCase):
|
|||
image = glance.location.ImageProxy(image_stub, context,
|
||||
self.store_api, self.store_utils)
|
||||
image.set_data('YYYY', None)
|
||||
self.assertEqual(image.size, 4)
|
||||
self.assertEqual(4, image.size)
|
||||
# NOTE(markwash): FakeStore returns image_id for location
|
||||
self.assertEqual(UUID2, image.locations[0]['url'])
|
||||
self.assertEqual('Z', image.checksum)
|
||||
|
|
|
@ -50,11 +50,11 @@ class TestStoreLocation(base.StoreClearingUnitTest):
|
|||
image1 = FakeImageProxy()
|
||||
locations = glance.location.StoreLocations(image1, [])
|
||||
locations.insert(0, loc2)
|
||||
self.assertEqual(image1.size, 1)
|
||||
self.assertEqual(1, image1.size)
|
||||
|
||||
# Test for set_attr of _locations_proxy
|
||||
image2 = FakeImageProxy()
|
||||
locations = glance.location.StoreLocations(image2, [loc1])
|
||||
locations[0] = loc2
|
||||
self.assertIn(loc2, locations)
|
||||
self.assertEqual(image2.size, 1)
|
||||
self.assertEqual(1, image2.size)
|
||||
|
|
|
@ -1578,9 +1578,9 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
res = self.image_status.pop(0)
|
||||
|
||||
self.assertEqual(200, res.status_int)
|
||||
self.assertEqual(res.headers['x-image-meta-status'], status)
|
||||
self.assertEqual(res.headers['x-image-meta-deleted'],
|
||||
str(check_deleted))
|
||||
self.assertEqual(status, res.headers['x-image-meta-status'])
|
||||
self.assertEqual(str(check_deleted),
|
||||
res.headers['x-image-meta-deleted'])
|
||||
|
||||
def _upload_safe_kill_common(self, mocks):
|
||||
fixture_headers = {'x-image-meta-store': 'file',
|
||||
|
@ -2532,7 +2532,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.headers['X-Auth-Token'] = 'user:tenant:_member_'
|
||||
req.headers['min_ram'] = '1024M'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, 403)
|
||||
self.assertEqual(403, res.status_int)
|
||||
|
||||
def test_show_image_restricted_download_for_custom_property(self):
|
||||
rules = {
|
||||
|
@ -2545,7 +2545,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.headers['X-Auth-Token'] = 'user:tenant:_member_'
|
||||
req.headers['x_test_key'] = 'test_1234'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, 403)
|
||||
self.assertEqual(403, res.status_int)
|
||||
|
||||
def test_delete_image(self):
|
||||
req = webob.Request.blank("/images/%s" % UUID2)
|
||||
|
@ -2558,7 +2558,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req = webob.Request.blank("/images/%s" % UUID2)
|
||||
req.method = 'GET'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, 404, res.body)
|
||||
self.assertEqual(404, res.status_int, res.body)
|
||||
|
||||
req = webob.Request.blank("/images/%s" % UUID2)
|
||||
req.method = 'HEAD'
|
||||
|
@ -2753,7 +2753,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.method = 'GET'
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, res.status_int)
|
||||
|
||||
def test_get_image_members_not_existing(self):
|
||||
"""
|
||||
|
@ -2938,7 +2938,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.body = jsonutils.dumps(dict(memberships=fixture))
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, res.status_int)
|
||||
|
||||
def test_replace_members_allowed_by_policy(self):
|
||||
rules = {"modify_member": '@'}
|
||||
|
@ -2953,7 +2953,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.body = jsonutils.dumps(dict(memberships=fixture))
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
|
||||
self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)
|
||||
|
||||
def test_add_member_unauthorized(self):
|
||||
"""
|
||||
|
@ -3027,7 +3027,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.method = 'PUT'
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, res.status_int)
|
||||
|
||||
def test_add_member_allowed_by_policy(self):
|
||||
rules = {"modify_member": '@'}
|
||||
|
@ -3038,7 +3038,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.method = 'PUT'
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
|
||||
self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)
|
||||
|
||||
def test_get_members_of_deleted_image_raises_404(self):
|
||||
"""
|
||||
|
@ -3053,7 +3053,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.method = 'GET'
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNotFound.code)
|
||||
self.assertEqual(webob.exc.HTTPNotFound.code, res.status_int)
|
||||
self.assertIn(
|
||||
'Image with identifier %s has been deleted.' % UUID2, res.body)
|
||||
|
||||
|
@ -3072,7 +3072,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.method = 'DELETE'
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNotFound.code)
|
||||
self.assertEqual(webob.exc.HTTPNotFound.code, res.status_int)
|
||||
self.assertIn(
|
||||
'Image with identifier %s has been deleted.' % UUID2, res.body)
|
||||
|
||||
|
@ -3099,7 +3099,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.content_type = 'application/json'
|
||||
req.body = jsonutils.dumps(dict(memberships=fixture))
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNotFound.code)
|
||||
self.assertEqual(webob.exc.HTTPNotFound.code, res.status_int)
|
||||
self.assertIn(
|
||||
'Image with identifier %s has been deleted.' % UUID2, res.body)
|
||||
|
||||
|
@ -3161,7 +3161,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
|
||||
# Assert the member list was not changed
|
||||
memb_list = jsonutils.loads(res.body)['members']
|
||||
self.assertEqual(memb_list, original_members)
|
||||
self.assertEqual(original_members, memb_list)
|
||||
|
||||
def test_replace_members_of_image_unlimited(self):
|
||||
self.config(image_member_quota=-1)
|
||||
|
@ -3182,7 +3182,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
self.assertEqual(200, res.status_int)
|
||||
|
||||
memb_list = jsonutils.loads(res.body)['members']
|
||||
self.assertEqual(memb_list, fixture)
|
||||
self.assertEqual(fixture, memb_list)
|
||||
|
||||
def test_create_member_to_deleted_image_raises_404(self):
|
||||
"""
|
||||
|
@ -3199,7 +3199,7 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req.method = 'PUT'
|
||||
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNotFound.code)
|
||||
self.assertEqual(webob.exc.HTTPNotFound.code, res.status_int)
|
||||
self.assertIn(
|
||||
'Image with identifier %s has been deleted.' % UUID2, res.body)
|
||||
|
||||
|
@ -3274,10 +3274,10 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req = webob.Request.blank('/images/%s/members/pattieblack' % UUID2)
|
||||
req.method = 'PUT'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
|
||||
self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)
|
||||
req.method = 'DELETE'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
|
||||
self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)
|
||||
|
||||
def test_delete_member_forbidden_by_policy(self):
|
||||
rules = {"delete_member": '!', "modify_member": '@'}
|
||||
|
@ -3287,10 +3287,10 @@ class TestGlanceAPI(base.IsolatedUnitTest):
|
|||
req = webob.Request.blank('/images/%s/members/pattieblack' % UUID2)
|
||||
req.method = 'PUT'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)
|
||||
self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)
|
||||
req.method = 'DELETE'
|
||||
res = req.get_response(self.api)
|
||||
self.assertEqual(res.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, res.status_int)
|
||||
|
||||
|
||||
class TestImageSerializer(base.IsolatedUnitTest):
|
||||
|
@ -3385,8 +3385,8 @@ class TestImageSerializer(base.IsolatedUnitTest):
|
|||
self.serializer.meta(response, FIXTURE)
|
||||
self.assertNotEqual(type(FIXTURE['image_meta']['name']),
|
||||
type(response.headers['x-image-meta-name']))
|
||||
self.assertEqual(response.headers['x-image-meta-name'].decode('utf-8'),
|
||||
FIXTURE['image_meta']['name'])
|
||||
self.assertEqual(FIXTURE['image_meta']['name'],
|
||||
response.headers['x-image-meta-name'].decode('utf-8'))
|
||||
for key, value in six.iteritems(exp_headers):
|
||||
self.assertEqual(value, response.headers[key])
|
||||
|
||||
|
@ -3491,7 +3491,7 @@ class TestImageSerializer(base.IsolatedUnitTest):
|
|||
tmp_image_meta = glance.api.v1.images.redact_loc(image_meta)
|
||||
|
||||
self.assertEqual(image_meta, copy_image_meta)
|
||||
self.assertEqual(tmp_image_meta, redacted_image_meta)
|
||||
self.assertEqual(redacted_image_meta, tmp_image_meta)
|
||||
|
||||
def test_noop_redact_location(self):
|
||||
"""Check no-op location redaction does not change original metadata"""
|
||||
|
@ -3501,8 +3501,8 @@ class TestImageSerializer(base.IsolatedUnitTest):
|
|||
tmp_image_meta = glance.api.v1.images.redact_loc(image_meta)
|
||||
|
||||
self.assertEqual(image_meta, copy_image_meta)
|
||||
self.assertEqual(tmp_image_meta, redacted_image_meta)
|
||||
self.assertEqual(image_meta, redacted_image_meta)
|
||||
self.assertEqual(redacted_image_meta, tmp_image_meta)
|
||||
self.assertEqual(redacted_image_meta, image_meta)
|
||||
|
||||
|
||||
class TestFilterValidator(base.IsolatedUnitTest):
|
||||
|
@ -3602,7 +3602,7 @@ class TestAPIProtectedProps(base.IsolatedUnitTest):
|
|||
another_request.headers[k] = v
|
||||
another_request.get_response(self.api)
|
||||
output = another_request.get_response(self.api)
|
||||
self.assertEqual(output.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, output.status_int)
|
||||
self.assertIn("Property '%s' is protected" %
|
||||
"x_owner_foo", output.body)
|
||||
|
||||
|
@ -3795,7 +3795,7 @@ class TestAPIProtectedProps(base.IsolatedUnitTest):
|
|||
for k, v in six.iteritems(headers):
|
||||
another_request.headers[k] = v
|
||||
output = another_request.get_response(self.api)
|
||||
self.assertEqual(output.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, output.status_int)
|
||||
self.assertIn("Property '%s' is protected" %
|
||||
"x_owner_foo", output.body)
|
||||
|
||||
|
@ -3814,7 +3814,7 @@ class TestAPIProtectedProps(base.IsolatedUnitTest):
|
|||
for k, v in six.iteritems(headers):
|
||||
another_request.headers[k] = v
|
||||
output = another_request.get_response(self.api)
|
||||
self.assertEqual(output.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, output.status_int)
|
||||
self.assertIn("Property '%s' is protected" %
|
||||
"x_owner_foo", output.body)
|
||||
|
||||
|
@ -3831,7 +3831,7 @@ class TestAPIProtectedProps(base.IsolatedUnitTest):
|
|||
for k, v in six.iteritems(headers):
|
||||
another_request.headers[k] = v
|
||||
output = another_request.get_response(self.api)
|
||||
self.assertEqual(output.status_int, webob.exc.HTTPForbidden.code)
|
||||
self.assertEqual(webob.exc.HTTPForbidden.code, output.status_int)
|
||||
self.assertIn("Property '%s' is protected" %
|
||||
"spl_update_only_prop", output.body)
|
||||
|
||||
|
|
|
@ -775,7 +775,7 @@ class TestRegistryV1Client(base.IsolatedUnitTest, test_utils.RegistryAPIMixIn):
|
|||
# Verify one less image
|
||||
new_num_images = len(self.client.get_images())
|
||||
|
||||
self.assertEqual(new_num_images, orig_num_images - 1)
|
||||
self.assertEqual(orig_num_images - 1, new_num_images)
|
||||
|
||||
def test_delete_image_not_existing(self):
|
||||
"""Check that one cannot delete non-existing image."""
|
||||
|
|
|
@ -124,8 +124,8 @@ class TestUploadUtils(base.StoreClearingUnitTest):
|
|||
actual_meta, location_data = upload_utils.upload_data_to_store(
|
||||
req, image_meta, image_data, store, notifier)
|
||||
|
||||
self.assertEqual(location_data['url'], location)
|
||||
self.assertEqual(actual_meta, image_meta.update(update_data))
|
||||
self.assertEqual(location, location_data['url'])
|
||||
self.assertEqual(image_meta.update(update_data), actual_meta)
|
||||
mock_update_image_metadata.assert_called_once_with(
|
||||
req.context, image_meta['id'], update_data,
|
||||
from_state='saving')
|
||||
|
|
|
@ -209,7 +209,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
namespace in output['namespaces']])
|
||||
expected = set([NAMESPACE1, NAMESPACE2, NAMESPACE3, NAMESPACE5,
|
||||
NAMESPACE6])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_namespace_index_visibility_public(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -220,7 +220,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
actual = set([namespace.namespace for namespace
|
||||
in output['namespaces']])
|
||||
expected = set([NAMESPACE3, NAMESPACE5, NAMESPACE6])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_namespace_index_resource_type(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -231,40 +231,40 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
actual = set([namespace.namespace for namespace
|
||||
in output['namespaces']])
|
||||
expected = set([NAMESPACE1, NAMESPACE3])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_namespace_show(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
output = self.namespace_controller.show(request, NAMESPACE1)
|
||||
output = output.to_dict()
|
||||
self.assertEqual(output['namespace'], NAMESPACE1)
|
||||
self.assertEqual(output['owner'], TENANT1)
|
||||
self.assertEqual(NAMESPACE1, output['namespace'])
|
||||
self.assertEqual(TENANT1, output['owner'])
|
||||
self.assertTrue(output['protected'])
|
||||
self.assertEqual(output['visibility'], 'private')
|
||||
self.assertEqual('private', output['visibility'])
|
||||
|
||||
def test_namespace_show_with_related_resources(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
output = self.namespace_controller.show(request, NAMESPACE3)
|
||||
output = output.to_dict()
|
||||
self.assertEqual(output['namespace'], NAMESPACE3)
|
||||
self.assertEqual(output['owner'], TENANT3)
|
||||
self.assertEqual(NAMESPACE3, output['namespace'])
|
||||
self.assertEqual(TENANT3, output['owner'])
|
||||
self.assertFalse(output['protected'])
|
||||
self.assertEqual(output['visibility'], 'public')
|
||||
self.assertEqual('public', output['visibility'])
|
||||
|
||||
self.assertEqual(2, len(output['properties']))
|
||||
actual = set([property for property in output['properties']])
|
||||
expected = set([PROPERTY1, PROPERTY2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
self.assertEqual(2, len(output['objects']))
|
||||
actual = set([object.name for object in output['objects']])
|
||||
expected = set([OBJECT1, OBJECT2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
self.assertEqual(1, len(output['resource_type_associations']))
|
||||
actual = set([rt.name for rt in output['resource_type_associations']])
|
||||
expected = set([RESOURCE_TYPE1])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_namespace_show_with_property_prefix(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -359,10 +359,10 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
||||
namespace.namespace = NAMESPACE4
|
||||
namespace = self.namespace_controller.create(request, namespace)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
|
||||
namespace = self.namespace_controller.show(request, NAMESPACE4)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
|
||||
def test_namespace_create_different_owner(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -380,10 +380,10 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
namespace.namespace = NAMESPACE4
|
||||
namespace.owner = TENANT4
|
||||
namespace = self.namespace_controller.create(request, namespace)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
|
||||
namespace = self.namespace_controller.show(request, NAMESPACE4)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
|
||||
def test_namespace_create_with_related_resources(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -410,32 +410,32 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
namespace.objects = [object1, object2]
|
||||
|
||||
output = self.namespace_controller.create(request, namespace)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
output = output.to_dict()
|
||||
|
||||
self.assertEqual(2, len(output['properties']))
|
||||
actual = set([property for property in output['properties']])
|
||||
expected = set([PROPERTY1, PROPERTY2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
self.assertEqual(2, len(output['objects']))
|
||||
actual = set([object.name for object in output['objects']])
|
||||
expected = set([OBJECT1, OBJECT2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
output = self.namespace_controller.show(request, NAMESPACE4)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
output = output.to_dict()
|
||||
|
||||
self.assertEqual(2, len(output['properties']))
|
||||
actual = set([property for property in output['properties']])
|
||||
expected = set([PROPERTY1, PROPERTY2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
self.assertEqual(2, len(output['objects']))
|
||||
actual = set([object.name for object in output['objects']])
|
||||
expected = set([OBJECT1, OBJECT2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_namespace_create_conflict(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -495,10 +495,10 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
namespace.namespace = NAMESPACE4
|
||||
namespace = self.namespace_controller.update(request, namespace,
|
||||
NAMESPACE1)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
|
||||
namespace = self.namespace_controller.show(request, NAMESPACE4)
|
||||
self.assertEqual(namespace.namespace, NAMESPACE4)
|
||||
self.assertEqual(NAMESPACE4, namespace.namespace)
|
||||
|
||||
self.assertRaises(webob.exc.HTTPNotFound,
|
||||
self.namespace_controller.show, request, NAMESPACE1)
|
||||
|
@ -517,7 +517,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
self.assertEqual(2, len(output.properties))
|
||||
actual = set([property for property in output.properties])
|
||||
expected = set([PROPERTY1, PROPERTY2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_property_index_empty(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
||||
|
@ -532,7 +532,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
def test_property_show(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
output = self.property_controller.show(request, NAMESPACE3, PROPERTY1)
|
||||
self.assertEqual(output.name, PROPERTY1)
|
||||
self.assertEqual(PROPERTY1, output.name)
|
||||
|
||||
def test_property_show_specific_resource_type(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -569,7 +569,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
||||
is_admin=True)
|
||||
output = self.property_controller.show(request, NAMESPACE1, PROPERTY1)
|
||||
self.assertEqual(output.name, PROPERTY1)
|
||||
self.assertEqual(PROPERTY1, output.name)
|
||||
|
||||
def test_property_delete(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -624,15 +624,15 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
property.title = 'title'
|
||||
property = self.property_controller.create(request, NAMESPACE1,
|
||||
property)
|
||||
self.assertEqual(property.name, PROPERTY2)
|
||||
self.assertEqual(property.type, 'string')
|
||||
self.assertEqual(property.title, 'title')
|
||||
self.assertEqual(PROPERTY2, property.name)
|
||||
self.assertEqual('string', property.type)
|
||||
self.assertEqual('title', property.title)
|
||||
|
||||
property = self.property_controller.show(request, NAMESPACE1,
|
||||
PROPERTY2)
|
||||
self.assertEqual(property.name, PROPERTY2)
|
||||
self.assertEqual(property.type, 'string')
|
||||
self.assertEqual(property.title, 'title')
|
||||
self.assertEqual(PROPERTY2, property.name)
|
||||
self.assertEqual('string', property.type)
|
||||
self.assertEqual('title', property.title)
|
||||
|
||||
def test_property_create_conflict(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -668,15 +668,15 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
property.title = 'title'
|
||||
property = self.property_controller.create(request, NAMESPACE1,
|
||||
property)
|
||||
self.assertEqual(property.name, PROPERTY2)
|
||||
self.assertEqual(property.type, 'string')
|
||||
self.assertEqual(property.title, 'title')
|
||||
self.assertEqual(PROPERTY2, property.name)
|
||||
self.assertEqual('string', property.type)
|
||||
self.assertEqual('title', property.title)
|
||||
|
||||
property = self.property_controller.show(request, NAMESPACE1,
|
||||
PROPERTY2)
|
||||
self.assertEqual(property.name, PROPERTY2)
|
||||
self.assertEqual(property.type, 'string')
|
||||
self.assertEqual(property.title, 'title')
|
||||
self.assertEqual(PROPERTY2, property.name)
|
||||
self.assertEqual('string', property.type)
|
||||
self.assertEqual('title', property.title)
|
||||
|
||||
def test_property_create_non_existing_namespace(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -700,15 +700,15 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
property.title = 'title123'
|
||||
property = self.property_controller.update(request, NAMESPACE3,
|
||||
PROPERTY1, property)
|
||||
self.assertEqual(property.name, PROPERTY1)
|
||||
self.assertEqual(property.type, 'string123')
|
||||
self.assertEqual(property.title, 'title123')
|
||||
self.assertEqual(PROPERTY1, property.name)
|
||||
self.assertEqual('string123', property.type)
|
||||
self.assertEqual('title123', property.title)
|
||||
|
||||
property = self.property_controller.show(request, NAMESPACE3,
|
||||
PROPERTY1)
|
||||
self.assertEqual(property.name, PROPERTY1)
|
||||
self.assertEqual(property.type, 'string123')
|
||||
self.assertEqual(property.title, 'title123')
|
||||
self.assertEqual(PROPERTY1, property.name)
|
||||
self.assertEqual('string123', property.type)
|
||||
self.assertEqual('title123', property.title)
|
||||
|
||||
def test_property_update_name(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -720,15 +720,15 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
property.title = 'title'
|
||||
property = self.property_controller.update(request, NAMESPACE3,
|
||||
PROPERTY1, property)
|
||||
self.assertEqual(property.name, PROPERTY3)
|
||||
self.assertEqual(property.type, 'string')
|
||||
self.assertEqual(property.title, 'title')
|
||||
self.assertEqual(PROPERTY3, property.name)
|
||||
self.assertEqual('string', property.type)
|
||||
self.assertEqual('title', property.title)
|
||||
|
||||
property = self.property_controller.show(request, NAMESPACE3,
|
||||
PROPERTY2)
|
||||
self.assertEqual(property.name, PROPERTY2)
|
||||
self.assertEqual(property.type, 'string')
|
||||
self.assertEqual(property.title, 'title')
|
||||
self.assertEqual(PROPERTY2, property.name)
|
||||
self.assertEqual('string', property.type)
|
||||
self.assertEqual('title', property.title)
|
||||
|
||||
def test_property_update_conflict(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -773,7 +773,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
self.assertEqual(2, len(output['objects']))
|
||||
actual = set([object.name for object in output['objects']])
|
||||
expected = set([OBJECT1, OBJECT2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_object_index_empty(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -789,7 +789,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
def test_object_show(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
output = self.object_controller.show(request, NAMESPACE3, OBJECT1)
|
||||
self.assertEqual(output.name, OBJECT1)
|
||||
self.assertEqual(OBJECT1, output.name)
|
||||
|
||||
def test_object_show_non_existing(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -806,7 +806,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
is_admin=True)
|
||||
|
||||
output = self.object_controller.show(request, NAMESPACE1, OBJECT1)
|
||||
self.assertEqual(output.name, OBJECT1)
|
||||
self.assertEqual(OBJECT1, output.name)
|
||||
|
||||
def test_object_delete(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -858,14 +858,14 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
object.required = []
|
||||
object.properties = {}
|
||||
object = self.object_controller.create(request, object, NAMESPACE1)
|
||||
self.assertEqual(object.name, OBJECT2)
|
||||
self.assertEqual(object.required, [])
|
||||
self.assertEqual(object.properties, {})
|
||||
self.assertEqual(OBJECT2, object.name)
|
||||
self.assertEqual([], object.required)
|
||||
self.assertEqual({}, object.properties)
|
||||
|
||||
object = self.object_controller.show(request, NAMESPACE1, OBJECT2)
|
||||
self.assertEqual(object.name, OBJECT2)
|
||||
self.assertEqual(object.required, [])
|
||||
self.assertEqual(object.properties, {})
|
||||
self.assertEqual(OBJECT2, object.name)
|
||||
self.assertEqual([], object.required)
|
||||
self.assertEqual({}, object.properties)
|
||||
|
||||
def test_object_create_conflict(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -912,14 +912,14 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
object.required = []
|
||||
object.properties = {}
|
||||
object = self.object_controller.create(request, object, NAMESPACE1)
|
||||
self.assertEqual(object.name, OBJECT2)
|
||||
self.assertEqual(object.required, [])
|
||||
self.assertEqual(object.properties, {})
|
||||
self.assertEqual(OBJECT2, object.name)
|
||||
self.assertEqual([], object.required)
|
||||
self.assertEqual({}, object.properties)
|
||||
|
||||
object = self.object_controller.show(request, NAMESPACE1, OBJECT2)
|
||||
self.assertEqual(object.name, OBJECT2)
|
||||
self.assertEqual(object.required, [])
|
||||
self.assertEqual(object.properties, {})
|
||||
self.assertEqual(OBJECT2, object.name)
|
||||
self.assertEqual([], object.required)
|
||||
self.assertEqual({}, object.properties)
|
||||
|
||||
def test_object_update(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -929,12 +929,12 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
object.description = 'description'
|
||||
object = self.object_controller.update(request, object, NAMESPACE3,
|
||||
OBJECT1)
|
||||
self.assertEqual(object.name, OBJECT1)
|
||||
self.assertEqual(object.description, 'description')
|
||||
self.assertEqual(OBJECT1, object.name)
|
||||
self.assertEqual('description', object.description)
|
||||
|
||||
property = self.object_controller.show(request, NAMESPACE3, OBJECT1)
|
||||
self.assertEqual(property.name, OBJECT1)
|
||||
self.assertEqual(object.description, 'description')
|
||||
self.assertEqual(OBJECT1, property.name)
|
||||
self.assertEqual('description', object.description)
|
||||
|
||||
def test_object_update_name(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -943,10 +943,10 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
object.name = OBJECT2
|
||||
object = self.object_controller.update(request, object, NAMESPACE1,
|
||||
OBJECT1)
|
||||
self.assertEqual(object.name, OBJECT2)
|
||||
self.assertEqual(OBJECT2, object.name)
|
||||
|
||||
object = self.object_controller.show(request, NAMESPACE1, OBJECT2)
|
||||
self.assertEqual(object.name, OBJECT2)
|
||||
self.assertEqual(OBJECT2, object.name)
|
||||
|
||||
def test_object_update_conflict(self):
|
||||
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
||||
|
@ -989,7 +989,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
actual = set([type.name for type in
|
||||
output.resource_types])
|
||||
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2, RESOURCE_TYPE4])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_resource_type_show(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -998,7 +998,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
self.assertEqual(1, len(output.resource_type_associations))
|
||||
actual = set([rt.name for rt in output.resource_type_associations])
|
||||
expected = set([RESOURCE_TYPE1])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_resource_type_show_empty(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -1020,7 +1020,7 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
self.assertEqual(2, len(output.resource_type_associations))
|
||||
actual = set([rt.name for rt in output.resource_type_associations])
|
||||
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_resource_type_show_non_existing_namespace(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -1075,14 +1075,14 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
rt.name = RESOURCE_TYPE2
|
||||
rt.prefix = 'pref'
|
||||
rt = self.rt_controller.create(request, rt, NAMESPACE1)
|
||||
self.assertEqual(rt.name, RESOURCE_TYPE2)
|
||||
self.assertEqual(rt.prefix, 'pref')
|
||||
self.assertEqual(RESOURCE_TYPE2, rt.name)
|
||||
self.assertEqual('pref', rt.prefix)
|
||||
|
||||
output = self.rt_controller.show(request, NAMESPACE1)
|
||||
self.assertEqual(2, len(output.resource_type_associations))
|
||||
actual = set([x.name for x in output.resource_type_associations])
|
||||
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_resource_type_association_create_conflict(self):
|
||||
request = unit_test_utils.get_fake_request()
|
||||
|
@ -1133,11 +1133,11 @@ class TestMetadefsControllers(base.IsolatedUnitTest):
|
|||
rt.name = RESOURCE_TYPE2
|
||||
rt.prefix = 'pref'
|
||||
rt = self.rt_controller.create(request, rt, NAMESPACE1)
|
||||
self.assertEqual(rt.name, RESOURCE_TYPE2)
|
||||
self.assertEqual(rt.prefix, 'pref')
|
||||
self.assertEqual(RESOURCE_TYPE2, rt.name)
|
||||
self.assertEqual('pref', rt.prefix)
|
||||
|
||||
output = self.rt_controller.show(request, NAMESPACE1)
|
||||
self.assertEqual(2, len(output.resource_type_associations))
|
||||
actual = set([x.name for x in output.resource_type_associations])
|
||||
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
||||
self.assertEqual(actual, expected)
|
||||
self.assertEqual(expected, actual)
|
||||
|
|
Loading…
Reference in New Issue