def test_delete_multiple_bay_by_name(self):
obj_utils.create_test_bay(self.context, name="test_bay", uuid=utils.generate_uuid())
obj_utils.create_test_bay(self.context, name="test_bay", uuid=utils.generate_uuid())
response = self.delete("/bays/test_bay", expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual("application/json", response.content_type)
self.assertTrue(response.json["error_message"])
def test_get_pod_list_with_filters(self):
bay1 = utils.get_test_bay(id=11, uuid=magnum_utils.generate_uuid())
bay2 = utils.get_test_bay(id=12, uuid=magnum_utils.generate_uuid())
self.dbapi.create_bay(bay1)
self.dbapi.create_bay(bay2)
pod1 = utils.create_test_pod(
name="pod-one", uuid=magnum_utils.generate_uuid(), bay_uuid=bay1["uuid"], status="status1"
)
pod2 = utils.create_test_pod(
name="pod-two", uuid=magnum_utils.generate_uuid(), bay_uuid=bay2["uuid"], status="status2"
)
res = self.dbapi.get_pod_list(self.context, filters={"bay_uuid": bay1["uuid"]})
self.assertEqual([pod1.id], [r.id for r in res])
res = self.dbapi.get_pod_list(self.context, filters={"bay_uuid": bay2["uuid"]})
self.assertEqual([pod2.id], [r.id for r in res])
res = self.dbapi.get_pod_list(self.context, filters={"name": "pod-one"})
self.assertEqual([pod1.id], [r.id for r in res])
res = self.dbapi.get_pod_list(self.context, filters={"name": "bad-pod"})
self.assertEqual([], [r.id for r in res])
res = self.dbapi.get_pod_list(self.context, filters={"status": "status1"})
self.assertEqual([pod1.id], [r.id for r in res])
res = self.dbapi.get_pod_list(self.context, filters={"status": "status2"})
self.assertEqual([pod2.id], [r.id for r in res])
def test_get_x509keypair_list_with_filters(self):
bay1 = utils.get_test_bay(id=1, uuid=magnum_utils.generate_uuid())
bay2 = utils.get_test_bay(id=2, uuid=magnum_utils.generate_uuid())
self.dbapi.create_bay(bay1)
self.dbapi.create_bay(bay2)
x509keypair1 = utils.create_test_x509keypair(
name='x509keypair-one',
uuid=magnum_utils.generate_uuid(),
bay_uuid=bay1['uuid'])
x509keypair2 = utils.create_test_x509keypair(
name='x509keypair-two',
uuid=magnum_utils.generate_uuid(),
bay_uuid=bay2['uuid'])
x509keypair3 = utils.create_test_x509keypair(
name='x509keypair-three',
bay_uuid=bay2['uuid'])
res = self.dbapi.get_x509keypair_list(
self.context, filters={'bay_uuid': bay1['uuid']})
self.assertEqual([x509keypair1.id], [r.id for r in res])
res = self.dbapi.get_x509keypair_list(
self.context, filters={'bay_uuid': bay2['uuid']})
self.assertEqual([x509keypair2.id, x509keypair3.id],
[r.id for r in res])
res = self.dbapi.get_x509keypair_list(
self.context, filters={'name': 'x509keypair-one'})
self.assertEqual([x509keypair1.id], [r.id for r in res])
res = self.dbapi.get_x509keypair_list(
self.context, filters={'name': 'bad-x509keypair'})
self.assertEqual([], [r.id for r in res])
def test_get_container_list_with_filters(self):
container1 = utils.create_test_container(
name='container-one',
uuid=magnum_utils.generate_uuid(),
bay_uuid=magnum_utils.generate_uuid())
container2 = utils.create_test_container(
name='container-two',
uuid=magnum_utils.generate_uuid(),
bay_uuid=magnum_utils.generate_uuid())
res = self.dbapi.get_container_list(self.context,
filters={'name': 'container-one'})
self.assertEqual([container1.id], [r.id for r in res])
res = self.dbapi.get_container_list(self.context,
filters={'name': 'container-two'})
self.assertEqual([container2.id], [r.id for r in res])
res = self.dbapi.get_container_list(self.context,
filters={'name': 'bad-container'})
self.assertEqual([], [r.id for r in res])
res = self.dbapi.get_container_list(
self.context,
filters={'bay_uuid': container1.bay_uuid})
self.assertEqual([container1.id], [r.id for r in res])
def test_get_baymodel_list_with_filters(self):
bm1 = self._create_test_baymodel(
id=1,
name='bm-one',
uuid=magnum_utils.generate_uuid(),
image_id='image1')
bm2 = self._create_test_baymodel(
id=2,
name='bm-two',
uuid=magnum_utils.generate_uuid(),
image_id='image2')
res = self.dbapi.get_baymodel_list(self.context,
filters={'name': 'bm-one'})
self.assertEqual([bm1['id']], [r.id for r in res])
res = self.dbapi.get_baymodel_list(self.context,
filters={'name': 'bad-name'})
self.assertEqual([], [r.id for r in res])
res = self.dbapi.get_baymodel_list(self.context,
filters={'image_id': 'image1'})
self.assertEqual([bm1['id']], [r.id for r in res])
res = self.dbapi.get_baymodel_list(self.context,
filters={'image_id': 'image2'})
self.assertEqual([bm2['id']], [r.id for r in res])
def test_get_one_by_name_multiple_service(self):
obj_utils.create_test_service(self.context, name="test_service", uuid=utils.generate_uuid())
obj_utils.create_test_service(self.context, name="test_service", uuid=utils.generate_uuid())
response = self.get_json("/services/test_service", expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual("application/json", response.content_type)
self.assertTrue(response.json["error_message"])
def test_update_node_already_associated(self):
node = utils.create_test_node()
new_i_uuid_one = magnum_utils.generate_uuid()
self.dbapi.update_node(node.id, {'ironic_node_id': new_i_uuid_one})
new_i_uuid_two = magnum_utils.generate_uuid()
self.assertRaises(exception.NodeAssociated,
self.dbapi.update_node, node.id,
{'ironic_node_id': new_i_uuid_two})
def test_policy_disallow_delete(self):
service = obj_utils.create_test_service(self.context,
desc='test_service',
uuid=utils.generate_uuid())
self._common_policy_check(
'service:delete', self.delete,
'/services/%s/%s' % (service.uuid, utils.generate_uuid()),
expect_errors=True)
def setUp(self):
super(TestPatch, self).setUp()
self.bay = obj_utils.create_test_bay(self.context,
uuid=utils.generate_uuid())
self.bay2 = obj_utils.create_test_bay(self.context,
uuid=utils.generate_uuid())
self.service = obj_utils.create_test_service(self.context,
bay_uuid=self.bay.uuid)
def test_update_node_instance_already_associated(self):
node1 = utils.create_test_node(uuid=magnum_utils.generate_uuid())
new_i_uuid = magnum_utils.generate_uuid()
self.dbapi.update_node(node1.id, {'ironic_node_id': new_i_uuid})
node2 = utils.create_test_node(uuid=magnum_utils.generate_uuid())
self.assertRaises(exception.InstanceAssociated,
self.dbapi.update_node, node2.id,
{'ironic_node_id': new_i_uuid})
def test_create_node_instance_already_associated(self):
instance_uuid = magnum_utils.generate_uuid()
utils.create_test_node(uuid=magnum_utils.generate_uuid(),
ironic_node_id=instance_uuid)
self.assertRaises(exception.InstanceAssociated,
utils.create_test_node,
uuid=magnum_utils.generate_uuid(),
ironic_node_id=instance_uuid)
def test_policy_disallow_delete(self):
rc = obj_utils.create_test_rc(self.context,
name='test_rc',
uuid=utils.generate_uuid())
self._common_policy_check(
'rc:delete', self.delete,
'/rcs/%s/%s' % (rc.uuid, utils.generate_uuid()),
expect_errors=True)
def test_policy_disallow_delete(self):
pod = obj_utils.create_test_pod(self.context,
name='test_pod',
uuid=utils.generate_uuid())
self._common_policy_check(
'pod:delete', self.delete,
'/pods/%s/%s' % (pod.uuid, utils.generate_uuid()),
expect_errors=True)
def test_get_one_by_name_multiple_service(self, mock_service_show):
obj_utils.create_test_service(self.context, name="test_service", uuid=utils.generate_uuid())
obj_utils.create_test_service(self.context, name="test_service", uuid=utils.generate_uuid())
err = rest.ApiException(status=500)
mock_service_show.side_effect = err
response = self.get_json("/services/test_service/5d12f6fd-a196-4bf0-ae4c-1f639a523a52", expect_errors=True)
self.assertEqual(500, response.status_int)
self.assertEqual("application/json", response.content_type)
self.assertTrue(response.json["error_message"])
def test_get_one_by_name_multiple_bay(self):
obj_utils.create_test_bay(self.context, name='test_bay',
uuid=utils.generate_uuid())
obj_utils.create_test_bay(self.context, name='test_bay',
uuid=utils.generate_uuid())
response = self.get_json('/bays/test_bay', expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_delete_multiple_service_by_name(self):
obj_utils.create_test_service(self.context, name='test_service',
uuid=utils.generate_uuid())
obj_utils.create_test_service(self.context, name='test_service',
uuid=utils.generate_uuid())
response = self.delete('/services/test_service', expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_get_baymodel_by_name_multiple_baymodel(self):
self._create_test_baymodel(id=1, name='bm',
uuid=magnum_utils.generate_uuid(),
image_id='image1')
self._create_test_baymodel(id=2, name='bm',
uuid=magnum_utils.generate_uuid(),
image_id='image2')
self.assertRaises(exception.Conflict, self.dbapi.get_baymodel_by_name,
self.context, 'bm')
def test_policy_disallow_update(self):
pod = obj_utils.create_test_pod(self.context,
desc='test pod',
uuid=utils.generate_uuid())
self._common_policy_check(
'pod:update', self.patch_json,
'/pods/%s/%s' % (pod.uuid, utils.generate_uuid()),
[{'path': '/desc', 'value': 'new test pod', 'op': 'replace'}],
expect_errors=True)
def test_delete_multiple_rc_by_name(self):
obj_utils.create_test_rc(self.context, name='test_rc',
uuid=utils.generate_uuid())
obj_utils.create_test_rc(self.context, name='test_rc',
uuid=utils.generate_uuid())
response = self.delete(
'/rcs/test_rc/5d12f6fd-a196-4bf0-ae4c-1f639a523a5',
expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_delete_multiple_pod_by_name(self, mock_pod_delete):
obj_utils.create_test_pod(self.context, name='test_pod',
uuid=utils.generate_uuid())
obj_utils.create_test_pod(self.context, name='test_pod',
uuid=utils.generate_uuid())
err = rest.ApiException(status=400)
mock_pod_delete.side_effect = err
response = self.delete('/pods/test_pod', expect_errors=True)
self.assertEqual(400, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['errors'])
def test_policy_disallow_update(self):
rc = obj_utils.create_test_rc(self.context,
desc='test rc',
uuid=utils.generate_uuid())
new_image = 'rc_example_B_image'
self._common_policy_check(
'rc:update', self.patch_json,
'/rcs/%s/%s' % (rc.uuid, utils.generate_uuid()),
[{'path': '/images/0', 'value': new_image, 'op': 'replace'}],
expect_errors=True)
def test_policy_disallow_update(self):
service = obj_utils.create_test_service(self.context,
desc='test service',
uuid=utils.generate_uuid())
self._common_policy_check(
'service:update', self.patch_json,
'/services/%s' % service.uuid,
[{'path': '/bay_uuid',
'value': utils.generate_uuid(),
'op': 'replace'}])
def test_get_one_by_name_multiple_pod(self):
obj_utils.create_test_pod(self.context, name='test_pod',
uuid=utils.generate_uuid())
obj_utils.create_test_pod(self.context, name='test_pod',
uuid=utils.generate_uuid())
response = self.get_json(
'/pods/test_pod/5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_get_bay_list_by_admin_all_tenants(self):
uuids = []
for i in range(1, 6):
bay = utils.create_test_bay(
uuid=magnum_utils.generate_uuid(),
project_id=magnum_utils.generate_uuid(),
user_id=magnum_utils.generate_uuid())
uuids.append(six.text_type(bay['uuid']))
ctx = context.make_admin_context()
res = self.dbapi.get_bay_list(ctx, opts={'get_all_tenants': True})
res_uuids = [r.uuid for r in res]
self.assertEqual(sorted(uuids), sorted(res_uuids))
def test_replace_ok_by_name_multiple_bay(self, mock_utcnow):
test_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = test_time
obj_utils.create_test_bay(self.context, name="test_bay", uuid=utils.generate_uuid())
obj_utils.create_test_bay(self.context, name="test_bay", uuid=utils.generate_uuid())
response = self.patch_json(
"/bays/test_bay", [{"path": "/name", "value": "test_bay", "op": "replace"}], expect_errors=True
)
self.assertEqual("application/json", response.content_type)
self.assertEqual(409, response.status_code)
def test_JSONEncodedDict_default_value(self):
# Create pod w/o labels
pod1_id = magnum_utils.generate_uuid()
self.dbapi.create_pod({'uuid': pod1_id})
pod1 = sa_api.model_query(models.Pod).filter_by(uuid=pod1_id).one()
self.assertEqual({}, pod1.labels)
# Create pod with labels
pod2_id = magnum_utils.generate_uuid()
self.dbapi.create_pod({'uuid': pod2_id, 'labels': {'bar': 'foo'}})
pod2 = sa_api.model_query(models.Pod).filter_by(uuid=pod2_id).one()
self.assertEqual('foo', pod2.labels['bar'])
def test_get_x509keypair_list_by_admin_all_tenants(self):
uuids = []
for i in range(1, 6):
x509keypair = utils.create_test_x509keypair(
uuid=magnum_utils.generate_uuid(),
project_id=magnum_utils.generate_uuid(),
user_id=magnum_utils.generate_uuid())
uuids.append(six.text_type(x509keypair['uuid']))
ctx = context.make_admin_context(all_tenants=True)
res = self.dbapi.get_x509keypair_list(ctx)
res_uuids = [r.uuid for r in res]
self.assertEqual(sorted(uuids), sorted(res_uuids))
def test_JSONEncodedList_default_value(self):
# Create pod w/o images
pod1_id = magnum_utils.generate_uuid()
self.dbapi.create_pod({'uuid': pod1_id})
pod1 = sa_api.model_query(models.Pod).filter_by(uuid=pod1_id).one()
self.assertEqual([], pod1.images)
# Create pod with images
pod2_id = magnum_utils.generate_uuid()
self.dbapi.create_pod({'uuid': pod2_id,
'images': ['myimage1', 'myimage2']})
pod2 = sa_api.model_query(models.Pod).filter_by(uuid=pod2_id).one()
self.assertEqual(['myimage1', 'myimage2'], pod2.images)
def test_get_one_by_name_multiple_pod(self, mock_pod_show):
obj_utils.create_test_pod(self.context, name='test_pod',
uuid=utils.generate_uuid())
obj_utils.create_test_pod(self.context, name='test_pod',
uuid=utils.generate_uuid())
err = rest.ApiException(status=500)
mock_pod_show.side_effect = err
response = self.get_json(
'/pods/test_pod/5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
expect_errors=True)
self.assertEqual(500, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['errors'])
def test_delete_multiple_service_by_name(self, mock_service_delete):
obj_utils.create_test_service(self.context, name='test_service',
uuid=utils.generate_uuid())
obj_utils.create_test_service(self.context, name='test_service',
uuid=utils.generate_uuid())
err = rest.ApiException(status=409)
mock_service_delete.side_effect = err
response = self.delete(
'/services/test_service/5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
expect_errors=True)
self.assertEqual(500, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['errors'])
def test_delete_pod_not_found(self):
uuid = utils.generate_uuid()
response = self.delete('/pods/%s/%s' % (uuid, self.pod.bay_uuid),
expect_errors=True)
self.assertEqual(404, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_get_pod_that_does_not_exist(self):
self.assertRaises(exception.PodNotFound, self.dbapi.get_pod_by_id,
self.context, 999)
self.assertRaises(exception.PodNotFound, self.dbapi.get_pod_by_uuid,
self.context, magnum_utils.generate_uuid())
self.assertRaises(exception.PodNotFound, self.dbapi.get_pod_by_name,
'bad-name')
def test_policy_disallow_delete(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid())
self._common_policy_check("node:delete",
self.delete,
'/nodes/%s' % node.uuid,
expect_errors=True)
def test_update_node_associate_and_disassociate(self):
node = utils.create_test_node()
new_i_uuid = magnum_utils.generate_uuid()
res = self.dbapi.update_node(node.id, {'ironic_node_id': new_i_uuid})
self.assertEqual(new_i_uuid, res.ironic_node_id)
res = self.dbapi.update_node(node.id, {'ironic_node_id': None})
self.assertIsNone(res.ironic_node_id)
def test_create_bay_with_non_existent_baymodel_id(self, mock_valid_os_res):
bdict = apiutils.bay_post_data(baymodel_id=utils.generate_uuid())
mock_valid_os_res.return_value = None
response = self.post_json('/bays', bdict, expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(400, response.status_int)
self.assertTrue(response.json['error_message'])
def test_detail_with_pagination_marker(self):
bm_list = []
for id_ in range(4):
baymodel = obj_utils.create_test_baymodel(
self.context, id=id_, uuid=utils.generate_uuid())
bm_list.append(baymodel)
response = self.get_json('/baymodels/detail?limit=3&marker=%s' %
bm_list[2].uuid)
self.assertEqual(1, len(response['baymodels']))
self.assertEqual(bm_list[-1].uuid, response['baymodels'][0]['uuid'])
for key in ("flavor_id", "master_flavor_id", "dns_nameserver",
"keypair_id", "external_network_id", "fixed_network",
"docker_volume_size", "ssh_authorized_key", "coe"):
self.assertIn(key, response['baymodels'][0])
self.assertIn('flavor_id', response['baymodels'][0])
self.assertIn('master_flavor_id', response['baymodels'][0])
self.assertIn('dns_nameserver', response['baymodels'][0])
self.assertIn('keypair_id', response['baymodels'][0])
self.assertIn('external_network_id', response['baymodels'][0])
self.assertIn('fixed_network', response['baymodels'][0])
self.assertIn('docker_volume_size', response['baymodels'][0])
self.assertIn('ssh_authorized_key', response['baymodels'][0])
self.assertIn('coe', response['baymodels'][0])
self.assertIn('http_proxy', response['baymodels'][0])
self.assertIn('https_proxy', response['baymodels'][0])
self.assertIn('no_proxy', response['baymodels'][0])
def test_get_rc_list_bay_not_exist(self):
rc = self.dbapi.get_rc_list(self.context,
filters={'bay_uuid': self.bay.uuid})
self.assertEqual(1, len(rc))
rc = self.dbapi.get_rc_list(
self.context, filters={'bay_uuid': magnum_utils.generate_uuid()})
self.assertEqual(0, len(rc))
def test_remove_singular(self):
baymodel = obj_utils.create_test_baymodel(self.context,
uuid=utils.generate_uuid())
response = self.get_json('/baymodels/%s' % baymodel.uuid)
self.assertIsNotNone(response['image_id'])
response = self.patch_json('/baymodels/%s' % baymodel.uuid,
[{
'path': '/image_id',
'op': 'remove'
}])
self.assertEqual('application/json', response.content_type)
self.assertEqual(200, response.status_code)
response = self.get_json('/baymodels/%s' % baymodel.uuid)
self.assertIsNone(response['image_id'])
# Assert nothing else was changed
self.assertEqual(baymodel.uuid, response['uuid'])
self.assertEqual(baymodel.name, response['name'])
self.assertEqual(baymodel.apiserver_port, response['apiserver_port'])
self.assertEqual(self.baymodel.fixed_network,
response['fixed_network'])
self.assertEqual(self.baymodel.docker_volume_size,
response['docker_volume_size'])
self.assertEqual(self.baymodel.ssh_authorized_key,
response['ssh_authorized_key'])
self.assertEqual(self.baymodel.coe, response['coe'])
def test_detail_containers_with_pagination_marker(self,
mock_container_list,
mock_container_show):
container_list = []
for id_ in range(4):
test_container = utils.create_test_container(
id=id_, uuid=comm_utils.generate_uuid())
container_list.append(
objects.Container(self.context, **test_container))
mock_container_list.return_value = container_list[-1:]
mock_container_show.return_value = container_list[-1]
response = self.app.get('/v1/containers/detail?limit=3&marker=%s' %
container_list[2].uuid)
self.assertEqual(200, response.status_int)
actual_containers = response.json['containers']
self.assertEqual(1, len(actual_containers))
self.assertEqual(container_list[-1].uuid,
actual_containers[0].get('uuid'))
self.assertIn('name', actual_containers[0])
self.assertIn('bay_uuid', actual_containers[0])
self.assertIn('status', actual_containers[0])
self.assertIn('image', actual_containers[0])
self.assertIn('command', actual_containers[0])
self.assertIn('memory', actual_containers[0])
def test_get_bay_list_baymodel_not_exist(self):
utils.create_test_bay()
self.assertEqual(1, len(self.dbapi.get_bay_list(self.context)))
res = self.dbapi.get_bay_list(
self.context,
filters={'baymodel_id': magnum_utils.generate_uuid()})
self.assertEqual(0, len(res))
def test_links(self):
uuid = utils.generate_uuid()
obj_utils.create_test_pod(self.context, id=1, uuid=uuid)
response = self.get_json(
'/pods/%s/%s' % (uuid, '5d12f6fd-a196-4bf0-ae4c-1f639a523a52'))
self.assertIn('links', response.keys())
self.assertEqual(2, len(response['links']))
self.assertIn(uuid, response['links'][0]['href'])
def test_get_container_list_with_filters(self):
container1 = utils.create_test_container(
name='container-one', uuid=magnum_utils.generate_uuid())
container2 = utils.create_test_container(
name='container-two', uuid=magnum_utils.generate_uuid())
res = self.dbapi.get_container_list(self.context,
filters={'name': 'container-one'})
self.assertEqual([container1.id], [r.id for r in res])
res = self.dbapi.get_container_list(self.context,
filters={'name': 'container-two'})
self.assertEqual([container2.id], [r.id for r in res])
res = self.dbapi.get_container_list(self.context,
filters={'name': 'bad-container'})
self.assertEqual([], [r.id for r in res])
def setUp(self):
super(TestPatch, self).setUp()
obj_utils.create_test_bay(self.context, coe='kubernetes')
self.rc = obj_utils.create_test_rc(self.context,
images=['rc_example_A_image'])
self.another_bay = obj_utils.create_test_bay(
self.context, uuid=utils.generate_uuid())
self.manifest = '''{
def test_get_node_list(self):
uuids = []
for i in range(1, 6):
node = utils.create_test_node(uuid=magnum_utils.generate_uuid())
uuids.append(six.text_type(node['uuid']))
res = self.dbapi.get_node_list(self.context)
res_uuids = [r.uuid for r in res]
self.assertEqual(sorted(uuids), sorted(res_uuids))
def test_links(self, mock_pod_show):
uuid = utils.generate_uuid()
pod = obj_utils.create_test_pod(self.context, id=1, uuid=uuid)
mock_pod_show.return_value = pod
response = self.get_json('/pods/%s/%s' % (uuid, pod.bay_uuid))
self.assertIn('links', response.keys())
self.assertEqual(2, len(response['links']))
self.assertIn(uuid, response['links'][0]['href'])
def test_get_service_list_with_filters(self):
bay1 = utils.get_test_bay(id=11, uuid=magnum_utils.generate_uuid())
bay2 = utils.get_test_bay(id=12, uuid=magnum_utils.generate_uuid())
self.dbapi.create_bay(bay1)
self.dbapi.create_bay(bay2)
service1 = utils.create_test_service(name='service-one',
uuid=magnum_utils.generate_uuid(),
bay_uuid=bay1['uuid'],
ports=[{
'port': 8000
}])
service2 = utils.create_test_service(name='service-two',
uuid=magnum_utils.generate_uuid(),
bay_uuid=bay2['uuid'],
ports=[{
'port': 8001
}])
res = self.dbapi.get_service_list(self.context,
filters={'bay_uuid': bay1['uuid']})
self.assertEqual([service1.id], [r.id for r in res])
res = self.dbapi.get_service_list(self.context,
filters={'bay_uuid': bay2['uuid']})
self.assertEqual([service2.id], [r.id for r in res])
res = self.dbapi.get_service_list(self.context,
filters={'name': 'service-one'})
self.assertEqual([service1.id], [r.id for r in res])
res = self.dbapi.get_service_list(self.context,
filters={'name': 'bad-service'})
self.assertEqual([], [r.id for r in res])
res = self.dbapi.get_service_list(self.context,
filters={'ports': [{
'port': 8000
}]})
self.assertEqual([service1.id], [r.id for r in res])
res = self.dbapi.get_service_list(self.context,
filters={'ports': [{
'port': 8001
}]})
self.assertEqual([service2.id], [r.id for r in res])
def test_collection_links(self, mock_rc_list):
for id_ in range(5):
rc = obj_utils.create_test_rc(self.context,
id=id_,
uuid=utils.generate_uuid())
mock_rc_list.return_value = [rc]
response = self.get_json('/rcs/?limit=1')
self.assertEqual(1, len(response['rcs']))
def test_destroy_baymodel_by_uuid(self):
uuid = magnum_utils.generate_uuid()
utils.create_test_baymodel(uuid=uuid)
self.assertIsNotNone(
self.dbapi.get_baymodel_by_uuid(self.context, uuid))
self.dbapi.destroy_baymodel(uuid)
self.assertRaises(exception.BayModelNotFound,
self.dbapi.get_baymodel_by_uuid, self.context, uuid)
def test_get_bay_list(self):
uuids = []
for i in range(1, 6):
bay = utils.create_test_bay(uuid=magnum_utils.generate_uuid())
uuids.append(six.text_type(bay['uuid']))
res = self.dbapi.get_bay_list(self.context)
res_uuids = [r.uuid for r in res]
self.assertEqual(uuids.sort(), res_uuids.sort())
def test_replace_ok_by_name_multiple_service(self, mock_utcnow):
test_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = test_time
obj_utils.create_test_service(self.context, name='test_service',
uuid=utils.generate_uuid())
obj_utils.create_test_service(self.context, name='test_service',
uuid=utils.generate_uuid())
response = self.patch_json(
'/services/test_service/5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
[{'path': '/bay_uuid',
'value': self.bay2.uuid,
'op': 'replace'}],
expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(409, response.status_code)
def test_collection_links(self, mock_rc_list):
for id_ in range(5):
rc = obj_utils.create_test_rc(self.context, id=id_,
uuid=utils.generate_uuid())
mock_rc_list.return_value = [rc]
response = self.get_json('/rcs/?limit=1&bay_ident=5d12f6fd-a196-4bf0'
'-ae4c-1f639a523a52')
self.assertEqual(1, len(response['rcs']))
def test_replace_non_existent_node(self):
response = self.patch_json('/nodes/%s' % utils.generate_uuid(),
[{'path': '/image_id', 'value': 'Ubuntu',
'op': 'replace'}],
expect_errors=True)
self.assertEqual(404, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_replace_ok_by_name_multiple_pod(self, mock_utcnow):
test_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = test_time
obj_utils.create_test_pod(self.context,
name='test_pod',
uuid=utils.generate_uuid())
obj_utils.create_test_pod(self.context,
name='test_pod',
uuid=utils.generate_uuid())
response = self.patch_json('/pods/test_pod', [{
'path': '/desc',
'op': 'remove'
}],
expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(409, response.status_code)
def test_replace_ok_by_name_multiple_rc(self, mock_utcnow):
new_image = 'rc_example_B_image'
test_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = test_time
obj_utils.create_test_rc(self.context, name='test_rc',
uuid=utils.generate_uuid())
obj_utils.create_test_rc(self.context, name='test_rc',
uuid=utils.generate_uuid())
response = self.patch_json(
'/rcs/test_rc/5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
[{'path': '/images/0',
'value': new_image,
'op': 'replace'}],
expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(400, response.status_code)
def test_replace_non_existent_baymodel_id(self):
response = self.patch_json('/bays/%s' % self.bay.uuid,
[{'path': '/baymodel_id',
'value': utils.generate_uuid(),
'op': 'replace'}],
expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(400, response.status_code)
self.assertTrue(response.json['error_message'])
def test_collection_links(self, mock_pod_list):
for id_ in range(5):
pod = obj_utils.create_test_pod(self.context,
id=id_,
uuid=utils.generate_uuid())
mock_pod_list.return_value = [pod]
response = self.get_json('/pods/?limit=1&bay_ident=5d12f6fd-a196-'
'4bf0-ae4c-1f639a523a52')
self.assertEqual(1, len(response['pods']))
def test_get_service_list(self):
uuids = [self.service.uuid]
for i in range(1, 6):
service = utils.create_test_service(
bay_uuid=self.bay.uuid, uuid=magnum_utils.generate_uuid())
uuids.append(six.text_type(service.uuid))
res = self.dbapi.get_service_list(self.context)
res_uuids = [r.uuid for r in res]
self.assertEqual(sorted(uuids), sorted(res_uuids))
def test_collection_links(self):
for id_ in range(5):
obj_utils.create_test_node(self.context, id=id_,
uuid=utils.generate_uuid())
response = self.get_json('/nodes/?limit=3')
self.assertEqual(3, len(response['nodes']))
next_marker = response['nodes'][-1]['uuid']
self.assertIn(next_marker, response['next'])
def test_collection_links_default_limit(self, mock_pod_list):
cfg.CONF.set_override('max_limit', 3, 'api')
for id_ in range(5):
pod = obj_utils.create_test_pod(self.context, id=id_,
uuid=utils.generate_uuid())
mock_pod_list.return_value = [pod]
response = self.get_json('/pods?bay_ident=5d12f6fd-a196-4bf0-ae4c-'
'1f639a523a52')
self.assertEqual(1, len(response['pods']))
def test_delete_pod_not_found(self, mock_pod_delete):
uuid = utils.generate_uuid()
err = rest.ApiException(status=404)
mock_pod_delete.side_effect = err
response = self.delete('/pods/%s/%s' % (uuid, self.pod.bay_uuid),
expect_errors=True)
self.assertEqual(500, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['errors'])
