def test_create_baymodel_with_no_network_driver(self, mock_keypair_exists,
mock_image_data):
mock_keypair_exists.return_value = None
with mock.patch.object(self.dbapi,
'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['network_driver'],
response.json['network_driver'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['image_id'], response.json['image_id'])
self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_policy_disallow_create(self):
bdict = apiutils.baymodel_post_data(name='bay_model_example_A')
self._common_policy_check("baymodel:create",
self.post_json,
'/baymodels',
bdict,
expect_errors=True)
def test_create_baymodel_with_no_exist_image_name(self, mock_keypair_exists, mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.side_effect = exception.ResourceNotFound("test-img")
bdict = apiutils.baymodel_post_data()
del bdict["uuid"]
response = self.post_json("/baymodels", bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def _test_create_baymodel_network_driver_attr(self, baymodel_dict,
baymodel_config_dict,
expect_errors,
mock_keypair_exists,
mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
for k, v in baymodel_config_dict.items():
cfg.CONF.set_override(k, v, 'baymodel')
with mock.patch.object(self.dbapi,
'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
bdict = apiutils.baymodel_post_data(**baymodel_dict)
response = self.post_json('/baymodels',
bdict,
expect_errors=expect_errors)
if expect_errors:
self.assertEqual(400, response.status_int)
else:
expected_driver = bdict.get('network_driver')
if not expected_driver:
expected_driver = (
cfg.CONF.baymodel.swarm_default_network_driver)
self.assertEqual(expected_driver,
response.json['network_driver'])
self.assertEqual(bdict['image_id'], response.json['image_id'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_generate_uuid(self):
cdict = apiutils.baymodel_post_data()
del cdict['uuid']
response = self.post_json('/baymodels', cdict)
self.assertEqual(cdict['image_id'],
response.json['image_id'])
self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_with_no_os_distro_image(self,
mock_image_data):
mock_image_data.side_effect = exception.OSDistroFieldNotFound('img')
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(400, response.status_int)
def test_create_baymodel_with_no_exist_image_name(self,
mock_image_data):
mock_image_data.side_effect = exception.ResourceNotFound('test-img')
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_with_invalid_docker_volume_size(self):
with mock.patch.object(self.dbapi,
'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
cdict = apiutils.baymodel_post_data(docker_volume_size='docker')
self.assertRaises(AppError, self.post_json, '/baymodels', cdict)
self.assertFalse(cc_mock.called)
def test_create_baymodel_with_multi_image_name(self, mock_keypair_exists, mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.side_effect = exception.Conflict("Multiple images")
bdict = apiutils.baymodel_post_data()
del bdict["uuid"]
response = self.post_json("/baymodels", bdict, expect_errors=True)
self.assertEqual(409, response.status_int)
def test_create_baymodel_generate_uuid(self, mock_image_data):
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data()
del bdict["uuid"]
response = self.post_json("/baymodels", bdict)
self.assertEqual(bdict["image_id"], response.json["image_id"])
self.assertTrue(utils.is_uuid_like(response.json["uuid"]))
def test_create_baymodel_with_dns(self, mock_keypair_exists, mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data()
response = self.post_json("/baymodels", bdict)
self.assertEqual(201, response.status_int)
self.assertEqual(bdict["dns_nameserver"], response.json["dns_nameserver"])
def test_create_baymodel_with_no_exist_image_name(self,
mock_image_data):
mock_image_data.side_effect = exception.ResourceNotFound('test-img')
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_with_os_distro_image(self, mock_keypair_exists, mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data()
del bdict["uuid"]
response = self.post_json("/baymodels", bdict, expect_errors=True)
self.assertEqual(201, response.status_int)
def test_create_baymodel_with_no_os_distro_image(self,
mock_image_data):
mock_image_data.side_effect = exception.OSDistroFieldNotFound('img')
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(400, response.status_int)
def test_create_baymodel_with_multi_image_name(self,
mock_image_data):
mock_image_data.side_effect = exception.Conflict('Multiple images')
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(409, response.status_int)
def test_create_baymodel_with_os_distro_image(self, mock_image_data):
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(201, response.status_int)
def _test_create_baymodel_network_driver_attr(self,
baymodel_dict,
baymodel_config_dict,
expect_errors,
mock_keypair_exists,
mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
for k, v in baymodel_config_dict.items():
cfg.CONF.set_override(k, v, 'baymodel')
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
bdict = apiutils.baymodel_post_data(**baymodel_dict)
response = self.post_json('/baymodels', bdict,
expect_errors=expect_errors)
if expect_errors:
self.assertEqual(400, response.status_int)
else:
expected_driver = bdict.get('network_driver')
if not expected_driver:
expected_driver = (
cfg.CONF.baymodel.swarm_default_network_driver)
self.assertEqual(expected_driver,
response.json['network_driver'])
self.assertEqual(bdict['image_id'],
response.json['image_id'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_with_multi_image_name(self,
mock_image_data):
mock_image_data.side_effect = exception.Conflict('Multiple images')
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(409, response.status_int)
def test_create_baymodel_with_dns(self, mock_image_data):
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict)
self.assertEqual(201, response.status_int)
self.assertEqual(bdict['dns_nameserver'],
response.json['dns_nameserver'])
def test_create_baymodel_public_fail(self, mock_policy, mock_keypair_exists, mock_image_data):
with mock.patch.object(self.dbapi, "create_baymodel", wraps=self.dbapi.create_baymodel):
mock_keypair_exists.return_value = None
# make policy enforcement fail
mock_policy.return_value = False
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data(public=True)
self.assertRaises(AppError, self.post_json, "/baymodels", bdict)
def test_create_baymodel_with_docker_volume_size(self, mock_image_data):
with mock.patch.object(self.dbapi, "create_baymodel", wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data(docker_volume_size=99)
response = self.post_json("/baymodels", bdict)
self.assertEqual(bdict["docker_volume_size"], response.json["docker_volume_size"])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn("id", cc_mock.call_args[0][0])
def test_create_baymodel_with_no_exist_external_network(self,
mock_image_data):
self.mock_valid_os_res.side_effect = exception.NetworkNotFound("test")
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(400, response.status_int)
def test_create_baymodel_with_os_distro_image(self,
mock_image_data):
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(201, response.status_int)
def test_create_baymodel_with_no_exist_external_network(self,
mock_image_data):
self.mock_valid_os_res.side_effect = exception.NetworkNotFound("test")
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(400, response.status_int)
def test_create_baymodel_with_no_os_distro_image(self, mock_keypair_exists,
mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {'name': 'mock_name'}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_with_no_exist_image_name(self, mock_glance_client):
mock_images = []
mock_glance = mock.MagicMock()
mock_glance.images.list.return_value = mock_images
mock_glance_client.return_value = mock_glance
bdict = apiutils.baymodel_post_data()
del bdict["uuid"]
response = self.post_json("/baymodels", bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_with_invalid_docker_volume_size(self,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
cdict = apiutils.baymodel_post_data(docker_volume_size='docker')
self.assertRaises(AppError, self.post_json, '/baymodels', cdict)
self.assertFalse(cc_mock.called)
def test_create_baymodel_set_project_id_and_user_id(self, mock_keypair_exists, mock_image_data):
with mock.patch.object(self.dbapi, "create_baymodel", wraps=self.dbapi.create_baymodel) as cc_mock:
mock_keypair_exists.return_value = None
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data()
self.post_json("/baymodels", bdict)
cc_mock.assert_called_once_with(mock.ANY)
self.assertEqual(self.context.project_id, cc_mock.call_args[0][0]["project_id"])
self.assertEqual(self.context.user_id, cc_mock.call_args[0][0]["user_id"])
def _create_baymodel_raises_app_error(self, **kwargs):
# Create mock for db and image data
with mock.patch.object(self.dbapi, "create_baymodel", wraps=self.dbapi.create_baymodel) as cc_mock, mock.patch(
"magnum.api.attr_validator.validate_image"
) as mock_image_data:
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data(**kwargs)
self.assertRaises(AppError, self.post_json, "/baymodels", bdict)
self.assertFalse(cc_mock.called)
def test_create_baymodel_with_labels(self, mock_keypair_exists, mock_image_data):
with mock.patch.object(self.dbapi, "create_baymodel", wraps=self.dbapi.create_baymodel) as cc_mock:
mock_keypair_exists.return_value = None
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data(labels={"key1": "val1", "key2": "val2"})
response = self.post_json("/baymodels", bdict)
self.assertEqual(bdict["labels"], response.json["labels"])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn("id", cc_mock.call_args[0][0])
def test_create_baymodel_generate_uuid(self, mock_image_data):
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['image_id'],
response.json['image_id'])
self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_with_no_exist_keypair(self,
mock_keypair_exists,
mock_image_data):
mock_keypair_exists.side_effect = exception.KeyPairNotFound("Test")
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_with_image_name(self, mock_glance_client):
mock_images = [{'name': 'mock_name', 'os_distro': 'fedora-atomic'}]
mock_glance = mock.MagicMock()
mock_glance.images.list.return_value = mock_images
mock_glance_client.return_value = mock_glance
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(201, response.status_int)
def test_create_baymodel_with_external_network(self,
mock_image_data):
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict)
self.assertEqual(201, response.status_int)
self.assertEqual(bdict['external_network_id'],
response.json['external_network_id'])
def test_create_baymodel_with_no_os_distro_image(self,
mock_keypair_exists,
mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {'name': 'mock_name'}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_doesnt_contain_id(self):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
cdict = apiutils.baymodel_post_data(image_id='my-image')
response = self.post_json('/baymodels', cdict)
self.assertEqual(cdict['image_id'], response.json['image_id'])
cc_mock.assert_called_once_with(mock.ANY)
# Check that 'id' is not in first arg of positional args
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel_with_docker_volume_size(self):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
cdict = apiutils.baymodel_post_data(docker_volume_size=99)
response = self.post_json('/baymodels', cdict)
self.assertEqual(cdict['docker_volume_size'],
response.json['docker_volume_size'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel_doesnt_contain_id(self, mock_image_data):
with mock.patch.object(self.dbapi, "create_baymodel", wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"}
bdict = apiutils.baymodel_post_data(image_id="my-image")
response = self.post_json("/baymodels", bdict)
self.assertEqual(bdict["image_id"], response.json["image_id"])
cc_mock.assert_called_once_with(mock.ANY)
# Check that 'id' is not in first arg of positional args
self.assertNotIn("id", cc_mock.call_args[0][0])
def test_create_baymodel_with_image_name(self, mock_glance_client):
mock_images = [{"name": "mock_name", "os_distro": "fedora-atomic"}]
mock_glance = mock.MagicMock()
mock_glance.images.list.return_value = mock_images
mock_glance_client.return_value = mock_glance
bdict = apiutils.baymodel_post_data()
del bdict["uuid"]
response = self.post_json("/baymodels", bdict, expect_errors=True)
self.assertEqual(201, response.status_int)
def test_create_baymodel_doesnt_contain_id(self):
with mock.patch.object(self.dbapi,
'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
cdict = apiutils.baymodel_post_data(image_id='my-image')
response = self.post_json('/baymodels', cdict)
self.assertEqual(cdict['image_id'], response.json['image_id'])
cc_mock.assert_called_once_with(mock.ANY)
# Check that 'id' is not in first arg of positional args
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel_with_docker_volume_size(self):
with mock.patch.object(self.dbapi,
'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
cdict = apiutils.baymodel_post_data(docker_volume_size=99)
response = self.post_json('/baymodels', cdict)
self.assertEqual(cdict['docker_volume_size'],
response.json['docker_volume_size'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel_with_no_exist_image_name(self,
mock_glance_client):
mock_images = []
mock_glance = mock.MagicMock()
mock_glance.images.list.return_value = mock_images
mock_glance_client.return_value = mock_glance
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_public_fail(self, mock_policy,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel):
# make policy enforcement fail
mock_policy.return_value = False
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data(public=True)
self.assertRaises(AppError, self.post_json, '/baymodels', bdict)
def test_create_baymodel_public_fail(self, mock_policy,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel):
# make policy enforcement fail
mock_policy.return_value = False
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data(public=True)
self.assertRaises(AppError, self.post_json, '/baymodels', bdict)
def test_create_baymodel_without_name(self, mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel):
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
bdict.pop('name')
resp = self.post_json('/baymodels', bdict)
self.assertEqual(201, resp.status_int)
self.assertIsNotNone(resp.json['name'])
def test_create_baymodel_generate_uuid(self, mock_image_data):
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['image_id'], response.json['image_id'])
self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_with_image_name(self, mock_glance_client):
mock_images = [{'name': 'mock_name',
'os_distro': 'fedora-atomic'}]
mock_glance = mock.MagicMock()
mock_glance.images.list.return_value = mock_images
mock_glance_client.return_value = mock_glance
bdict = apiutils.baymodel_post_data()
del bdict['uuid']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(201, response.status_int)
def test_create_baymodel_with_no_exist_keypair(self, mock_keypair_exists,
mock_image_data):
mock_keypair_exists.side_effect = exception.KeyPairNotFound("Test")
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def _create_baymodel_raises_app_error(self, **kwargs):
# Create mock for db and image data
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock,\
mock.patch('magnum.api.attr_validator.validate_image')\
as mock_image_data:
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data(**kwargs)
self.assertRaises(AppError, self.post_json, '/baymodels', bdict)
self.assertFalse(cc_mock.called)
def test_create_baymodel_with_no_exist_keypair(self, mock_image_data,
mock_nova_client):
mock_nova = mock.MagicMock()
mock_nova.keypairs.get.side_effect = nova_exc.NotFound("Test")
mock_nova_client.return_value = mock_nova
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(404, response.status_int)
def test_create_baymodel_doesnt_contain_id(self,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data(image_id='my-image')
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['image_id'], response.json['image_id'])
cc_mock.assert_called_once_with(mock.ANY)
# Check that 'id' is not in first arg of positional args
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel_with_no_volume_driver(self,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['volume_driver'],
response.json['volume_driver'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel_with_dns(self, mock_keypair_exists,
mock_image_data):
mock_keypair_exists.return_value = None
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data()
response = self.post_json('/baymodels', bdict)
self.assertEqual(201, response.status_int)
self.assertEqual(bdict['dns_nameserver'],
response.json['dns_nameserver'])
def test_create_baymodel_set_project_id_and_user_id(self,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data()
self.post_json('/baymodels', bdict)
cc_mock.assert_called_once_with(mock.ANY)
self.assertEqual(self.context.project_id,
cc_mock.call_args[0][0]['project_id'])
self.assertEqual(self.context.user_id,
cc_mock.call_args[0][0]['user_id'])
def test_create_baymodel_public_not_set(self, mock_policy,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data(public=False)
response = self.post_json('/baymodels', bdict)
self.assertFalse(response.json['public'])
# policy enforcement is called only once for enforce_wsgi
self.assertEqual(1, mock_policy.call_count)
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
self.assertFalse(cc_mock.call_args[0][0]['public'])
def test_create_baymodel_public_success(self, mock_policy,
mock_image_data):
with mock.patch.object(self.dbapi, 'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_policy.return_value = True
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
bdict = apiutils.baymodel_post_data(public=True)
response = self.post_json('/baymodels', bdict)
self.assertTrue(response.json['public'])
mock_policy.assert_called_with(mock.ANY, "baymodel:publish",
None, do_raise=False)
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
self.assertTrue(cc_mock.call_args[0][0]['public'])
def test_create_baymodel(self, mock_utcnow):
cdict = apiutils.baymodel_post_data()
test_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = test_time
response = self.post_json('/baymodels', cdict)
self.assertEqual(201, response.status_int)
# Check location header
self.assertIsNotNone(response.location)
expected_location = '/v1/baymodels/%s' % cdict['uuid']
self.assertEqual(
urlparse.urlparse(response.location).path, expected_location)
self.assertEqual(cdict['uuid'], response.json['uuid'])
self.assertNotIn('updated_at', response.json.keys)
return_created_at = timeutils.parse_isotime(
response.json['created_at']).replace(tzinfo=None)
self.assertEqual(test_time, return_created_at)
def test_create_baymodel_with_labels(self, mock_keypair_exists,
mock_image_data):
with mock.patch.object(self.dbapi,
'create_baymodel',
wraps=self.dbapi.create_baymodel) as cc_mock:
mock_keypair_exists.return_value = None
mock_image_data.return_value = {
'name': 'mock_name',
'os_distro': 'fedora-atomic'
}
bdict = apiutils.baymodel_post_data(labels={
'key1': 'val1',
'key2': 'val2'
})
response = self.post_json('/baymodels', bdict)
self.assertEqual(bdict['labels'], response.json['labels'])
cc_mock.assert_called_once_with(mock.ANY)
self.assertNotIn('id', cc_mock.call_args[0][0])
def test_create_baymodel(self, mock_utcnow,
mock_image_data):
bdict = apiutils.baymodel_post_data()
test_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = test_time
mock_image_data.return_value = {'name': 'mock_name',
'os_distro': 'fedora-atomic'}
response = self.post_json('/baymodels', bdict)
self.assertEqual(201, response.status_int)
# Check location header
self.assertIsNotNone(response.location)
expected_location = '/v1/baymodels/%s' % bdict['uuid']
self.assertEqual(expected_location,
urlparse.urlparse(response.location).path)
self.assertEqual(bdict['uuid'], response.json['uuid'])
self.assertNotIn('updated_at', response.json.keys)
return_created_at = timeutils.parse_isotime(
response.json['created_at']).replace(tzinfo=None)
self.assertEqual(test_time, return_created_at)
def test_create_baymodel_without_keypair_id(self):
bdict = apiutils.baymodel_post_data()
del bdict['keypair_id']
response = self.post_json('/baymodels', bdict, expect_errors=True)
self.assertEqual(400, response.status_int)
