def test_get_server_fault_by_server(self):
"""Ensure we can retrieve faults for server."""
uuids = [uuidutils.generate_uuid(), uuidutils.generate_uuid()]
fault_codes = [404, 500]
expected = {}
# Create faults
for uuid in uuids:
utils.create_test_server(self.ctxt, server_uuid=uuid)
expected[uuid] = []
for code in fault_codes:
fault = utils.create_test_server_fault(self.ctxt,
server_uuid=uuid,
code=code)
# We expect the faults to be returned ordered by created_at in
# descending order, so insert the newly created fault at the
# front of our list.
expected[uuid].insert(0, fault)
# Ensure faults are saved
faults = self.dbapi.server_fault_get_by_server_uuids(self.ctxt, uuids)
ignored_keys = ['created_at', 'updated_at', 'id']
self.assertEqual(len(expected), len(faults))
for uuid in uuids:
self._assertEqualOrderedListOfObjects(expected[uuid], faults[uuid],
ignored_keys)
def test_remove_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
uuid = uuidutils.generate_uuid()
server = utils.create_test_server(name='test3',
extra=extra,
uuid=uuid,
description="foobar")
# Removing one item from the collection
response = self.patch_json('/servers/%s' % server.uuid, [{
'path': '/metadata/foo2',
'op': 'remove'
}],
headers=self.headers)
self.assertEqual('application/json', response.content_type)
self.assertEqual(http_client.OK, response.status_code)
result = self.get_json('/servers/%s' % server.uuid,
headers=self.headers)
extra.pop("foo2")
self.assertEqual(extra, result['metadata'])
# Removing the collection
response = self.patch_json('/servers/%s' % server.uuid, [{
'path': '/metadata',
'op': 'remove'
}],
headers=self.headers)
self.assertEqual(http_client.OK, response.status_code)
result = self.get_json('/servers/%s' % server.uuid,
headers=self.headers)
self.assertEqual({}, result['metadata'])
# Assert nothing else was changed
self.assertEqual(server.uuid, result['uuid'])
self.assertEqual(server.description, result['description'])
def setUp(self):
super(TestServerAuthorization, self).setUp()
project_id = "0abcdef1-2345-6789-abcd-ef123456abc1"
# evil_project is an wicked tenant, is used for unauthorization test.
self.evil_project = "0abcdef1-2345-6789-abcd-ef123456abc9"
self.server1 = utils.create_test_server(name="T1",
project_id=project_id)
def test_server_update(self):
server = utils.create_test_server()
old_extra = server.extra
new_extra = {'foo': 'bar'}
self.assertNotEqual(old_extra, new_extra)
res = self.dbapi.server_update(self.context, server.uuid,
{'extra': new_extra})
self.assertEqual(new_extra, res.extra)
def test_tags_get_destroyed_after_destroying_a_server_by_uuid(self):
server = utils.create_test_server(id=124)
tag = utils.create_test_server_tag(self.context, server_id=server.id)
self.assertTrue(
self.dbapi.server_tag_exists(self.context, server.id, tag.tag))
self.dbapi.server_destroy(self.context, server.uuid)
self.assertRaises(exception.ServerNotFound,
self.dbapi.server_tag_exists, self.context,
server.id, tag.tag)
def test_delete_server_faults_on_server_destroy(self):
server = utils.create_test_server(self.ctxt)
fault = utils.create_test_server_fault(self.ctxt,
server_uuid=server.uuid)
faults = self.dbapi.server_fault_get_by_server_uuids(
self.ctxt, [server.uuid])
self.assertEqual(1, len(faults[server.uuid]))
self._assertEqualObjects(fault, faults[server.uuid][0])
self.dbapi.server_destroy(self.ctxt, server.uuid)
faults = self.dbapi.server_fault_get_by_server_uuids(
self.ctxt, [server.uuid])
self.assertEqual(0, len(faults[server.uuid]))
def test_remove_singular(self):
uuid = uuidutils.generate_uuid()
server = utils.create_test_server(name='test2',
uuid=uuid,
extra={'a': 'b'})
response = self.patch_json('/servers/%s' % server.uuid, [{
'path': '/description',
'op': 'remove'
}],
headers=self.headers)
self.assertEqual('application/json', response.content_type)
self.assertEqual(http_client.OK, response.status_code)
result = self.get_json('/servers/%s' % server.uuid,
headers=self.headers)
self.assertIsNone(result['description'])
# Assert nothing else was changed
self.assertEqual(server.uuid, result['uuid'])
self.assertEqual(server.extra, result['metadata'])
def test_replace_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
uuid = uuidutils.generate_uuid()
server = utils.create_test_server(name='test1', uuid=uuid, extra=extra)
new_value = 'new value'
response = self.patch_json('/servers/%s' % server.uuid,
[{
'path': '/metadata/foo2',
'value': new_value,
'op': 'replace'
}],
headers=self.headers)
self.assertEqual('application/json', response.content_type)
self.assertEqual(http_client.OK, response.status_code)
result = self.get_json('/servers/%s' % server.uuid,
headers=self.headers)
extra["foo2"] = new_value
self.assertEqual(extra, result['metadata'])
def setUp(self):
super(TestPatch, self).setUp()
self.server = utils.create_test_server(name="patch_server")
self.context.tenant = self.server.project_id
self.headers = self.gen_headers(self.context, roles="no-admin")
def setUp(self):
super(DbServerTagTestCase, self).setUp()
self.server = utils.create_test_server()
def test_server_get_all(self):
servers_project_1 = []
servers_project_2 = []
servers_project_all = []
for i in range(0, 3):
server = utils.create_test_server(uuid=uuidutils.generate_uuid(),
project_id='project_1',
name=str(i))
servers_project_1.append(server)
for i in range(3, 5):
server = utils.create_test_server(uuid=uuidutils.generate_uuid(),
project_id='project_2',
name=str(i))
servers_project_2.append(server)
servers_project_all.extend(servers_project_1)
servers_project_all.extend(servers_project_2)
# Set project_only to False
# get all servers from all projects
res = self.dbapi.server_get_all(self.context, project_only=False)
for i, item in enumerate(res):
self.assertEqual(servers_project_all[i].uuid, item.uuid)
# Filter by server name test
res = self.dbapi.server_get_all(self.context,
project_only=False,
filters={"name": "1"})
self.assertEqual(len(res), 1)
self.assertEqual(res[0].name, "1")
# Filter by server status test
res = self.dbapi.server_get_all(self.context,
project_only=False,
filters={"status": "active"})
for i, item in enumerate(res):
self.assertEqual(item.status, "active")
# Filter by flavor_uuid test
res = self.dbapi.server_get_all(
self.context,
project_only=False,
filters={"flavor_uuid": servers_project_all[0].flavor_uuid})
for i, item in enumerate(res):
self.assertEqual(item.flavor_uuid,
servers_project_all[0].flavor_uuid)
# Filter by image_uuid test
res = self.dbapi.server_get_all(
self.context,
project_only=False,
filters={"image_uuid": servers_project_all[0].image_uuid})
for i, item in enumerate(res):
self.assertEqual(item.image_uuid,
servers_project_all[0].image_uuid)
# Set project_only to True
# get servers from current project (project_1)
self.context.tenant = 'project_1'
res = self.dbapi.server_get_all(self.context, project_only=True)
res_uuids = [r.uuid for r in res]
uuids_project_1 = [r.uuid for r in servers_project_1]
six.assertCountEqual(self, uuids_project_1, res_uuids)
# Set project_only to True
# get servers from current project (project_2)
self.context.tenant = 'project_2'
res = self.dbapi.server_get_all(self.context, project_only=True)
res_uuids = [r.uuid for r in res]
uuids_project_2 = [r.uuid for r in servers_project_2]
six.assertCountEqual(self, uuids_project_2, res_uuids)
def test_server_create_with_same_uuid(self):
utils.create_test_server(uuid='uuid', name='server1')
self.assertRaises(exception.ServerAlreadyExists,
utils.create_test_server,
uuid='uuid',
name='server2')
def test_server_create(self):
utils.create_test_server()
def test_server_update_with_invalid_parameter_value(self):
server = utils.create_test_server()
self.assertRaises(exception.InvalidParameterValue,
self.dbapi.server_update, self.context, server.uuid,
{'uuid': '12345678-9999-0000-aaaa-123456789012'})
def test_server_destroy(self):
server = utils.create_test_server()
self.dbapi.server_destroy(self.context, server.uuid)
self.assertRaises(exception.ServerNotFound, self.dbapi.server_get,
self.context, server.uuid)
def test_save_after_refresh(self):
db_server = utils.create_test_server(context=self.ctxt)
server = objects.Server.get(self.context, db_server.uuid)
server.refresh(self.context)
server.name = 'refresh'
server.save(self.context)
def test_server_get_by_uuid(self):
server = utils.create_test_server()
res = self.dbapi.server_get(self.context, server.uuid)
self.assertEqual(server.uuid, res.uuid)
