def _encryption_update_bad_body(self, update_body, msg):
# Create Volume Type and Encryption
volume_type = self._default_volume_type
res = self._create_type_and_encryption(volume_type)
# Update Encryption
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=json.dumps(update_body),
req_headers='application/json',
url='/v2/fake/types/%s/encryption/fake_type_id')
res_dict = json.loads(res.body)
expected = {
'badRequest': {
'code': 400,
'message': (msg)
}
}
# Confirm Failure
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def destroy(context, id):
"""Marks volume types as deleted."""
if id is None:
msg = _("id cannot be None")
raise exception.InvalidVolumeType(reason=msg)
else:
db.volume_type_destroy(context, id)
def test_update_item(self):
volume_type = self._default_volume_type
# Create Encryption Specs
create_body = {"encryption": {'cipher': 'cipher',
'control_location': 'front-end',
'key_size': 128,
'provider': 'fake_provider',
'volume_type_id': volume_type['id']}}
self._create_type_and_encryption(volume_type, create_body)
# Update Encryption Specs
update_body = {"encryption": {'key_size': 512,
'provider': 'fake_provider2'}}
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=json.dumps(update_body),
req_headers='application/json',
url='/v2/fake/types/%s/encryption/fake_type_id')
res_dict = json.loads(res.body)
self.assertEqual(512, res_dict['encryption']['key_size'])
self.assertEqual('fake_provider2', res_dict['encryption']['provider'])
# Get Encryption Specs
res = self._get_response(volume_type)
res_dict = json.loads(res.body)
# Confirm Encryption Specs
self.assertEqual(512, res_dict['key_size'])
self.assertEqual('fake_provider2', res_dict['provider'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_encryption_type_exists(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
body = {"encryption": {'cipher': 'cipher',
'control_location': 'front-end',
'key_size': 128,
'provider': 'fake_provider',
'volume_type_id': volume_type['id']}}
# Try to create encryption specs for a volume type
# that already has them.
res = self._get_response(volume_type, req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
expected = {
'badRequest': {
'code': 400,
'message': ('Volume type encryption for type '
'fake_type_id already exists.')
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_encryption_type_exists(self):
self.stubs.Set(db, "volume_type_encryption_get", return_volume_type_encryption)
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
body = {
"encryption": {
"cipher": "cipher",
"control_location": "front-end",
"key_size": 128,
"provider": "fake_provider",
"volume_type_id": volume_type["id"],
}
}
# Try to create encryption specs for a volume type
# that already has them.
res = self._get_response(
volume_type, req_method="POST", req_body=json.dumps(body), req_headers="application/json"
)
res_dict = json.loads(res.body)
expected = {
"badRequest": {"code": 400, "message": ("Volume type encryption for type " "fake_type_id already exists.")}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def tearDown(self):
# Remove the volume type from the database
db.volume_type_destroy(context.get_admin_context(),
self.vol_type1['id'])
db.volume_type_destroy(context.get_admin_context(),
self.vol_type2_noextra['id'])
super(VolumeTypeExtraSpecsTestCase, self).tearDown()
def destroy(context, id):
"""Marks volume types as deleted."""
if id is None:
msg = _("id cannot be None")
raise exception.InvalidVolumeType(reason=msg)
else:
elevated = context if context.is_admin else context.elevated()
db.volume_type_destroy(elevated, id)
def test_create_group_from_group(self, mock_policy, mock_volume_get_all,
mock_rpc_create_group_from_src,
mock_group_get,
mock_volume_api_create,
mock_mapping_create,
mock_get_volume_type):
vol_type = utils.create_volume_type(self.ctxt,
name = 'fake_volume_type')
mock_get_volume_type.return_value = vol_type
grp = utils.create_group(self.ctxt, group_type_id = fake.GROUP_TYPE_ID,
volume_type_ids = [vol_type['id']],
availability_zone = 'nova',
status = fields.GroupStatus.CREATING)
mock_group_get.return_value = grp
vol = utils.create_volume(
self.ctxt,
availability_zone = grp.availability_zone,
volume_type_id = fake.VOLUME_TYPE_ID,
group_id = grp.id)
mock_volume_get_all.return_value = [vol]
grp2 = utils.create_group(self.ctxt,
group_type_id = fake.GROUP_TYPE_ID,
volume_type_ids = [vol_type['id']],
availability_zone = 'nova',
source_group_id = grp.id,
status = fields.GroupStatus.CREATING)
vol2 = utils.create_volume(
self.ctxt,
availability_zone = grp.availability_zone,
volume_type_id = vol_type['id'],
group_id = grp2.id,
source_volid = vol.id)
self.group_api._create_group_from_source_group(self.ctxt, grp2,
grp.id)
mock_volume_api_create.assert_called_once_with(
self.ctxt, 1, None, None,
availability_zone = grp.availability_zone,
source_group = grp,
group = grp2,
source_volume = vol,
volume_type = vol_type)
mock_rpc_create_group_from_src.assert_called_once_with(
self.ctxt, grp2, None, grp)
vol2.destroy()
grp2.destroy()
vol.destroy()
grp.destroy()
db.volume_type_destroy(self.ctxt, vol_type['id'])
def test_show_provider(self):
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type, url="/v2/fake/types/%s/encryption/provider")
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
self.assertEqual("fake_provider", res_dict["provider"])
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_show_item_not_found(self):
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type, url="/v2/fake/types/%s/encryption/fake")
res_dict = json.loads(res.body)
self.assertEqual(404, res.status_code)
expected = {"itemNotFound": {"code": 404, "message": ("The resource could not be found.")}}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_show_provider(self):
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type,
url='/v2/%s/types/%s/encryption/provider')
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.OK, res.status_code)
self.assertEqual('fake_provider', res_dict['provider'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_key_size(self):
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type,
url='/v2/fake/types/%s/encryption/key_size')
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
self.assertEqual(256, res_dict['key_size'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_provider(self):
self.stubs.Set(db, "volume_type_encryption_get", return_volume_type_encryption)
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type, url="/v2/fake/types/%s/encryption/provider")
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
self.assertEqual("fake_provider", res_dict["provider"])
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def _encryption_create_bad_body(self, body, msg="Create body is not valid."):
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(
volume_type, req_method="POST", req_body=json.dumps(body), req_headers="application/json"
)
res_dict = json.loads(res.body)
expected = {"badRequest": {"code": 400, "message": (msg)}}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_delete(self):
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
# Test that before create, there's nothing with a get
res = self._get_response(
volume_type, req_method="GET", req_headers="application/json", url="/v2/fake/types/%s/encryption"
)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
body = {
"encryption": {
"cipher": "cipher",
"key_size": 128,
"control_location": "front-end",
"provider": "fake_provider",
"volume_type_id": volume_type["id"],
}
}
# Create, and test that get returns something
res = self._get_response(
volume_type, req_method="POST", req_body=json.dumps(body), req_headers="application/json"
)
res_dict = json.loads(res.body)
res = self._get_response(
volume_type, req_method="GET", req_headers="application/json", url="/v2/fake/types/%s/encryption"
)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual(volume_type["id"], res_dict["volume_type_id"])
# Delete, and test that get returns nothing
res = self._get_response(
volume_type,
req_method="DELETE",
req_headers="application/json",
url="/v2/fake/types/%s/encryption/provider",
)
self.assertEqual(202, res.status_code)
self.assertEqual(0, len(res.body))
res = self._get_response(
volume_type, req_method="GET", req_headers="application/json", url="/v2/fake/types/%s/encryption"
)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_show_item_not_found(self):
self.stubs.Set(db, "volume_type_encryption_get", return_volume_type_encryption)
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type, url="/v2/fake/types/%s/encryption/fake")
res_dict = json.loads(res.body)
self.assertEqual(404, res.status_code)
expected = {"itemNotFound": {"code": 404, "message": ("The resource could not be found.")}}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def _encryption_create_bad_body(self, body):
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type, req_method='POST',
req_body=jsonutils.dump_as_bytes(body),
req_headers='application/json')
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.BAD_REQUEST,
res_dict['badRequest']['code'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _create(self, cipher, control_location, key_size, provider):
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
body = {"encryption": {'cipher': cipher,
'control_location': control_location,
'key_size': key_size,
'provider': provider,
'volume_type_id': volume_type['id']}}
self.assertEqual(len(test_notifier.NOTIFICATIONS), 0)
res = self._get_response(volume_type)
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
# Confirm that volume type has no encryption information
# before create.
self.assertEqual('{}', res.body)
# Create encryption specs for the volume type
# with the defined body.
res = self._get_response(volume_type, req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
self.assertEqual(len(test_notifier.NOTIFICATIONS), 1)
# check response
self.assertIn('encryption', res_dict)
self.assertEqual(cipher, res_dict['encryption']['cipher'])
self.assertEqual(control_location,
res_dict['encryption']['control_location'])
self.assertEqual(key_size, res_dict['encryption']['key_size'])
self.assertEqual(provider, res_dict['encryption']['provider'])
self.assertEqual(volume_type['id'],
res_dict['encryption']['volume_type_id'])
# check database
encryption = db.volume_type_encryption_get(context.get_admin_context(),
volume_type['id'])
self.assertIsNotNone(encryption)
self.assertEqual(cipher, encryption['cipher'])
self.assertEqual(key_size, encryption['key_size'])
self.assertEqual(provider, encryption['provider'])
self.assertEqual(volume_type['id'], encryption['volume_type_id'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_index(self):
self.stubs.Set(db, "volume_type_encryption_get", return_volume_type_encryption)
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
expected = stub_volume_type_encryption()
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_index(self):
self.mock_object(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type)
self.assertEqual(http_client.OK, res.status_code)
res_dict = jsonutils.loads(res.body)
expected = fake_volume_type_encryption()
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_index(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
expected = stub_volume_type_encryption()
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _create(self, cipher, control_location, key_size, provider):
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
body = {
"encryption": {
"cipher": cipher,
"control_location": control_location,
"key_size": key_size,
"provider": provider,
"volume_type_id": volume_type["id"],
}
}
self.assertEqual(len(test_notifier.NOTIFICATIONS), 0)
res = self._get_response(volume_type)
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
# Confirm that volume type has no encryption information
# before create.
self.assertEqual("{}", res.body)
# Create encryption specs for the volume type
# with the defined body.
res = self._get_response(
volume_type, req_method="POST", req_body=json.dumps(body), req_headers="application/json"
)
res_dict = json.loads(res.body)
self.assertEqual(len(test_notifier.NOTIFICATIONS), 1)
# check response
self.assertIn("encryption", res_dict)
self.assertEqual(cipher, res_dict["encryption"]["cipher"])
self.assertEqual(control_location, res_dict["encryption"]["control_location"])
self.assertEqual(key_size, res_dict["encryption"]["key_size"])
self.assertEqual(provider, res_dict["encryption"]["provider"])
self.assertEqual(volume_type["id"], res_dict["encryption"]["volume_type_id"])
# check database
encryption = db.volume_type_encryption_get(context.get_admin_context(), volume_type["id"])
self.assertIsNotNone(encryption)
self.assertEqual(cipher, encryption["cipher"])
self.assertEqual(key_size, encryption["key_size"])
self.assertEqual(provider, encryption["provider"])
self.assertEqual(volume_type["id"], encryption["volume_type_id"])
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_delete(self):
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
# Test that before create, there's nothing with a get
res = self._get_response(volume_type, req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
body = {"encryption": {'cipher': 'cipher',
'key_size': 128,
'control_location': 'front-end',
'provider': 'fake_provider',
'volume_type_id': volume_type['id']}}
# Create, and test that get returns something
res = self._get_response(volume_type, req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
res = self._get_response(volume_type, req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual(volume_type['id'], res_dict['volume_type_id'])
# Delete, and test that get returns nothing
res = self._get_response(volume_type, req_method='DELETE',
req_headers='application/json',
url='/v2/fake/types/%s/encryption/provider')
self.assertEqual(202, res.status_code)
self.assertEqual(0, len(res.body))
res = self._get_response(volume_type, req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def destroy(context, id):
"""Marks volume types as deleted."""
if id is None:
msg = _("id cannot be None")
raise exception.InvalidVolumeType(reason=msg)
elevated = context if context.is_admin else context.elevated()
return db.volume_type_destroy(elevated, id)
def test_create_xml(self):
volume_type = {"id": "fake_type_id", "name": "fake_type"}
db.volume_type_create(context.get_admin_context(), volume_type)
ctxt = context.RequestContext("fake", "fake", is_admin=True)
req = webob.Request.blank("/v2/fake/types/%s/encryption" % volume_type["id"])
req.method = "POST"
req.body = '<encryption provider="test_provider" ' 'cipher="cipher" control_location="front-end" />'
req.headers["Content-Type"] = "application/xml"
req.headers["Accept"] = "application/xml"
res = req.get_response(fakes.wsgi_app(fake_auth_context=ctxt))
self.assertEqual(res.status_int, 200)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def _encryption_create_bad_body(self,
body,
msg='Create body is not valid.'):
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type,
req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
expected = {'badRequest': {'code': 400, 'message': (msg)}}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _create(self, cipher, control_location, key_size, provider):
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
body = {"encryption": {'cipher': cipher,
'control_location': control_location,
'key_size': key_size,
'provider': provider,
'volume_type_id': volume_type['id']}}
self.assertEqual(0, len(self.notifier.notifications))
res = self._get_response(volume_type)
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.OK, res.status_code)
# Confirm that volume type has no encryption information
# before create.
self.assertEqual(b'{}', res.body)
# Create encryption specs for the volume type
# with the defined body.
res = self._get_response(volume_type, req_method='POST',
req_body=jsonutils.dump_as_bytes(body),
req_headers='application/json')
res_dict = jsonutils.loads(res.body)
self.assertEqual(1, len(self.notifier.notifications))
# check response
self.assertIn('encryption', res_dict)
self.assertEqual(cipher, res_dict['encryption']['cipher'])
self.assertEqual(control_location,
res_dict['encryption']['control_location'])
self.assertEqual(key_size, res_dict['encryption']['key_size'])
self.assertEqual(provider, res_dict['encryption']['provider'])
self.assertEqual(volume_type['id'],
res_dict['encryption']['volume_type_id'])
# check database
encryption = db.volume_type_encryption_get(context.get_admin_context(),
volume_type['id'])
self.assertIsNotNone(encryption)
self.assertEqual(cipher, encryption['cipher'])
self.assertEqual(key_size, encryption['key_size'])
self.assertEqual(provider, encryption['provider'])
self.assertEqual(volume_type['id'], encryption['volume_type_id'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _create(self, cipher, control_location, key_size, provider):
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
body = {"encryption": {'cipher': cipher,
'control_location': control_location,
'key_size': key_size,
'provider': provider,
'volume_type_id': volume_type['id']}}
self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
res = self._get_response(volume_type)
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
# Confirm that volume type has no encryption information
# before create.
self.assertEqual('{}', res.body)
# Create encryption specs for the volume type
# with the defined body.
res = self._get_response(volume_type, req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
# check response
self.assertIn('encryption', res_dict)
self.assertEqual(cipher, res_dict['encryption']['cipher'])
self.assertEqual(control_location,
res_dict['encryption']['control_location'])
self.assertEqual(key_size, res_dict['encryption']['key_size'])
self.assertEqual(provider, res_dict['encryption']['provider'])
self.assertEqual(volume_type['id'],
res_dict['encryption']['volume_type_id'])
# check database
encryption = db.volume_type_encryption_get(context.get_admin_context(),
volume_type['id'])
self.assertIsNotNone(encryption)
self.assertEqual(cipher, encryption['cipher'])
self.assertEqual(key_size, encryption['key_size'])
self.assertEqual(provider, encryption['provider'])
self.assertEqual(volume_type['id'], encryption['volume_type_id'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_provider(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type,
url='/v2/fake/types/%s/encryption/provider')
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
self.assertEqual('fake_provider', res_dict['provider'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_provider(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type,
url='/v2/fake/types/%s/encryption/provider')
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_code)
self.assertEqual('fake_provider', res_dict['provider'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_item_not_found(self):
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type,
url='/v2/fake/types/%s/encryption/fake')
res_dict = json.loads(res.body)
self.assertEqual(404, res.status_code)
expected = {
'itemNotFound': {
'code': 404,
'message': ('The resource could not be found.')
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_encryption_type_exists(self):
volume_type = self._default_volume_type
body = {"encryption": stub_volume_type_encryption()}
self._create_type_and_encryption(volume_type, body)
# Try to create encryption specs for a volume type
# that already has them.
res = self._get_response(
volume_type, req_method="POST", req_body=json.dumps(body), req_headers="application/json"
)
res_dict = json.loads(res.body)
expected = {
"badRequest": {"code": 400, "message": ("Volume type encryption for type " "fake_type_id already exists.")}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type["id"])
def test_update_item(self, mock_validate_integer):
mock_validate_integer.return_value = 512
volume_type = self._default_volume_type
# Create Encryption Specs
create_body = {
"encryption": {
'cipher': 'cipher',
'control_location': 'front-end',
'key_size': 128,
'provider': 'fake_provider',
'volume_type_id': volume_type['id']
}
}
self._create_type_and_encryption(volume_type, create_body)
# Update Encryption Specs
update_body = {
"encryption": {
'key_size': 512,
'provider': 'fake_provider2'
}
}
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=jsonutils.dump_as_bytes(update_body),
req_headers='application/json',
url='/v2/%s/types/%s/encryption/' +
fake.ENCRYPTION_KEY_ID)
res_dict = jsonutils.loads(res.body)
self.assertEqual(512, res_dict['encryption']['key_size'])
self.assertEqual('fake_provider2', res_dict['encryption']['provider'])
# Get Encryption Specs
res = self._get_response(volume_type)
res_dict = jsonutils.loads(res.body)
# Confirm Encryption Specs
self.assertEqual(512, res_dict['key_size'])
self.assertEqual('fake_provider2', res_dict['provider'])
self.assertTrue(mock_validate_integer.called)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_index(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
expected = stub_volume_type_encryption()
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _encryption_update_bad_body(self, update_body):
# Create Volume Type and Encryption
volume_type = self._default_volume_type
res = self._create_type_and_encryption(volume_type)
# Update Encryption
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=jsonutils.dump_as_bytes(update_body),
req_headers='application/json',
url='/v2/%s/types/%s/encryption/' +
fake.ENCRYPTION_KEY_ID)
res_dict = jsonutils.loads(res.body)
# Confirm Failure
self.assertEqual(http_client.BAD_REQUEST,
res_dict['badRequest']['code'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_xml(self):
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
ctxt = context.RequestContext('fake', 'fake', is_admin=True)
req = webob.Request.blank('/v2/fake/types/%s/encryption'
% volume_type['id'])
req.method = 'POST'
req.body = ('<encryption provider="test_provider" '
'cipher="cipher" control_location="front-end" />')
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app(fake_auth_context=ctxt))
self.assertEqual(res.status_int, 200)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_item_not_found(self):
volume_type = self._default_volume_type
self._create_type_and_encryption(volume_type)
res = self._get_response(volume_type,
url='/v2/%s/types/%s/encryption/fake')
res_dict = jsonutils.loads(res.body)
self.assertEqual(HTTPStatus.NOT_FOUND, res.status_code)
expected = {
'itemNotFound': {
'code': HTTPStatus.NOT_FOUND,
'message': ('Volume type encryption for type %s does not '
'exist.' % volume_type['id'])
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _encryption_update_bad_body(self, update_body):
# Create Volume Type and Encryption
volume_type = self._default_volume_type
res = self._create_type_and_encryption(volume_type)
# Update Encryption
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=jsonutils.dump_as_bytes(update_body),
req_headers='application/json',
url='/v3/%s/types/%s/encryption/' +
fake.ENCRYPTION_KEY_ID)
res_dict = jsonutils.loads(res.body)
# Confirm Failure
self.assertEqual(HTTPStatus.BAD_REQUEST,
res_dict['badRequest']['code'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_volume_exists(self):
# Create the volume type and a volume with the volume type.
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
db.volume_create(
context.get_admin_context(), {
'id': fake.VOLUME_ID,
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy',
'volume_type_id': volume_type['id']
})
body = {
"encryption": {
'cipher': 'cipher',
'key_size': 128,
'control_location': 'front-end',
'provider': 'fake_provider',
'volume_type_id': volume_type['id']
}
}
# Try to create encryption specs for a volume type
# with a volume.
res = self._get_response(volume_type,
req_method='POST',
req_body=jsonutils.dump_as_bytes(body),
req_headers='application/json')
res_dict = jsonutils.loads(res.body)
expected = {
'badRequest': {
'code':
400,
'message': ('Cannot create encryption specs. '
'Volume type in use.')
}
}
self.assertEqual(expected, res_dict)
db.volume_destroy(context.get_admin_context(), fake.VOLUME_ID)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def destroy(context, id):
"""Marks volume types as deleted."""
if id is None:
msg = _("id cannot be None")
raise exception.InvalidVolumeType(reason=msg)
vol_type = get_volume_type(context, id)
if vol_type['name'] == DEFAULT_VOLUME_TYPE:
raise exception.VolumeTypeDefault(vol_type['name'])
elevated = context if context.is_admin else context.elevated()
return db.volume_type_destroy(elevated, id)
def _encryption_update_bad_body(self, update_body, msg):
# Create Volume Type and Encryption
volume_type = self._default_volume_type
res = self._create_type_and_encryption(volume_type)
# Update Encryption
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=jsonutils.dump_as_bytes(update_body),
req_headers='application/json',
url='/v2/%s/types/%s/encryption/' +
fake.ENCRYPTION_KEY_ID)
res_dict = jsonutils.loads(res.body)
expected = {'badRequest': {'code': 400, 'message': (msg)}}
# Confirm Failure
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_delete(self):
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
# Test that before create, there's nothing with a get
res = self._get_response(volume_type)
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
body = {"encryption": {'cipher': 'cipher',
'key_size': 128,
'control_location': 'front-end',
'provider': 'fake_provider',
'volume_type_id': volume_type['id']}}
# Create, and test that get returns something
res = self._get_response(volume_type, req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
res = self._get_response(volume_type, req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual(volume_type['id'], res_dict['volume_type_id'])
# Delete, and test that get returns nothing
res = self._get_response(volume_type, req_method='DELETE',
req_headers='application/json',
url='/v2/fake/types/%s/encryption/provider')
self.assertEqual(202, res.status_code)
self.assertEqual(0, len(res.body))
res = self._get_response(volume_type, req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_update_item(self):
volume_type = self._default_volume_type
# Create Encryption Specs
create_body = {
"encryption": {
'cipher': 'cipher',
'control_location': 'front-end',
'key_size': 128,
'provider': 'fake_provider',
'volume_type_id': volume_type['id']
}
}
self._create_type_and_encryption(volume_type, create_body)
# Update Encryption Specs
update_body = {
"encryption": {
'key_size': 512,
'provider': 'fake_provider2'
}
}
res = self.\
_get_response(volume_type, req_method='PUT',
req_body=json.dumps(update_body),
req_headers='application/json',
url='/v2/fake/types/%s/encryption/fake_type_id')
res_dict = json.loads(res.body)
self.assertEqual(512, res_dict['encryption']['key_size'])
self.assertEqual('fake_provider2', res_dict['encryption']['provider'])
# Get Encryption Specs
res = self._get_response(volume_type)
res_dict = json.loads(res.body)
# Confirm Encryption Specs
self.assertEqual(512, res_dict['key_size'])
self.assertEqual('fake_provider2', res_dict['provider'])
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_delete_with_no_encryption(self):
volume_type = self._default_volume_type
# create a volume type
db.volume_type_create(context.get_admin_context(), volume_type)
# without creating encryption type, try to delete
# and check if 404 is raised.
res = self._get_response(volume_type, req_method='DELETE',
req_headers='application/json',
url='/v2/fake/types/%s/encryption/provider')
self.assertEqual(404, res.status_code)
expected = {
"itemNotFound": {
"message": "Volume type encryption for type "
"fake_type_id does not exist.",
"code": 404
}
}
self.assertEqual(expected, jsonutils.loads(res.body))
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_encryption_type_exists(self):
volume_type = self._default_volume_type
body = {"encryption": fake_volume_type_encryption()}
self._create_type_and_encryption(volume_type, body)
# Try to create encryption specs for a volume type
# that already has them.
res = self._get_response(volume_type, req_method='POST',
req_body=jsonutils.dump_as_bytes(body),
req_headers='application/json')
res_dict = jsonutils.loads(res.body)
expected = {
'badRequest': {
'code': HTTPStatus.BAD_REQUEST,
'message': ('Volume type encryption for type '
'%s already exists.' % fake.VOLUME_TYPE_ID)
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_encryption_type_exists(self):
volume_type = self._default_volume_type
body = {"encryption": stub_volume_type_encryption()}
self._create_type_and_encryption(volume_type, body)
# Try to create encryption specs for a volume type
# that already has them.
res = self._get_response(volume_type, req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
expected = {
'badRequest': {
'code': 400,
'message': ('Volume type encryption for type '
'fake_type_id already exists.')
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_encryption_type_exists(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
body = {
"encryption": {
'cipher': 'cipher',
'control_location': 'front-end',
'key_size': 128,
'provider': 'fake_provider',
'volume_type_id': volume_type['id']
}
}
# Try to create encryption specs for a volume type
# that already has them.
res = self._get_response(volume_type,
req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res_dict = json.loads(res.body)
expected = {
'badRequest': {
'code':
400,
'message': ('Volume type encryption for type '
'fake_type_id already exists.')
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_show_item_not_found(self):
self.stubs.Set(db, 'volume_type_encryption_get',
return_volume_type_encryption)
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
res = self._get_response(volume_type,
url='/v2/fake/types/%s/encryption/fake')
res_dict = json.loads(res.body)
self.assertEqual(404, res.status_code)
expected = {
'itemNotFound': {
'code': 404,
'message': ('The resource could not be found.')
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def destroy(context, id):
"""Marks volume types as deleted.
There must exist at least one volume type (i.e. the default type) in
the deployment.
This method achieves that by ensuring:
1) the default_volume_type is set and is a valid one
2) the type requested to delete isn't the default type
:raises VolumeTypeDefaultDeletionError: when the type requested to
delete is the default type
"""
if id is None:
msg = _("id cannot be None")
raise exception.InvalidVolumeType(reason=msg)
projects_with_default_type = db.get_all_projects_with_default_type(
context.elevated(), id)
if len(projects_with_default_type) > 0:
# don't allow delete if the type requested is a project default
project_list = [p.project_id for p in projects_with_default_type]
LOG.exception(
'Default type with %(volume_type_id)s is associated '
'with projects %(projects)s', {
'volume_type_id': id,
'projects': project_list
})
raise exception.VolumeTypeDefaultDeletionError(volume_type_id=id)
# Default type *must* be set in order to delete any volume type.
# If the default isn't set, the following call will raise
# VolumeTypeDefaultMisconfiguredError exception which will error out the
# delete operation.
default_type = get_default_volume_type()
# don't allow delete if the type requested is the conf default type
if id == default_type.get('id'):
raise exception.VolumeTypeDefaultDeletionError(volume_type_id=id)
elevated = context if context.is_admin else context.elevated()
return db.volume_type_destroy(elevated, id)
def test_delete_with_volume_in_use(self):
# Create the volume type and volumes with the volume type.
volume_type = {
'id': 'fake_type_id',
'name': 'fake_type',
}
db.volume_type_create(context.get_admin_context(), volume_type)
db.volume_create(
context.get_admin_context(), {
'id': 'fake_id',
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy',
'volume_type_id': volume_type['id']
})
db.volume_create(
context.get_admin_context(), {
'id': 'fake_id2',
'display_description': 'Test Desc2',
'size': 2,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy',
'volume_type_id': volume_type['id']
})
body = {
"encryption": {
'cipher': 'cipher',
'key_size': 128,
'control_location': 'front-end',
'provider': 'fake_provider',
'volume_type_id': volume_type['id']
}
}
# Create encryption with volume type, and test with GET
res = self._get_response(volume_type,
req_method='POST',
req_body=json.dumps(body),
req_headers='application/json')
res = self._get_response(volume_type,
req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual(volume_type['id'], res_dict['volume_type_id'])
# Delete, and test that there is an error since volumes exist
res = self._get_response(volume_type,
req_method='DELETE',
req_headers='application/json',
url='/v2/fake/types/%s/encryption/provider')
self.assertEqual(400, res.status_code)
res_dict = json.loads(res.body)
expected = {
'badRequest': {
'code': 400,
'message': 'Cannot delete encryption specs. '
'Volume type in use.'
}
}
self.assertEqual(expected, res_dict)
# Delete the volumes
db.volume_destroy(context.get_admin_context(), 'fake_id')
db.volume_destroy(context.get_admin_context(), 'fake_id2')
# Delete, and test that get returns nothing
res = self._get_response(volume_type,
req_method='DELETE',
req_headers='application/json',
url='/v2/fake/types/%s/encryption/provider')
self.assertEqual(202, res.status_code)
self.assertEqual(0, len(res.body))
res = self._get_response(volume_type,
req_method='GET',
req_headers='application/json',
url='/v2/fake/types/%s/encryption')
self.assertEqual(200, res.status_code)
res_dict = json.loads(res.body)
self.assertEqual({}, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def _cleanup(self):
self.group1.destroy()
self.group2.destroy()
self.group3.destroy()
db.volume_type_destroy(self.ctxt, self.volume_type1.id)
def test_delete_with_volume_in_use(self):
# Create the volume type
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
body = {
"encryption": {
'cipher': 'cipher',
'key_size': 128,
'control_location': 'front-end',
'provider': 'fake_provider'
}
}
# Create encryption with volume type, and test with GET
res = self._get_response(volume_type,
req_method='POST',
req_body=jsonutils.dump_as_bytes(body),
req_headers='application/json')
res = self._get_response(volume_type,
req_method='GET',
req_headers='application/json',
url='/v3/%s/types/%s/encryption')
self.assertEqual(HTTPStatus.OK, res.status_code)
res_dict = jsonutils.loads(res.body)
self.assertEqual(volume_type['id'], res_dict['volume_type_id'])
# Create volumes with the volume type
db.volume_create(
context.get_admin_context(), {
'id': fake.VOLUME_ID,
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy',
'volume_type_id': volume_type['id']
})
db.volume_create(
context.get_admin_context(), {
'id': fake.VOLUME2_ID,
'display_description': 'Test Desc2',
'size': 2,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy',
'volume_type_id': volume_type['id']
})
# Delete, and test that there is an error since volumes exist
res = self._get_response(volume_type,
req_method='DELETE',
req_headers='application/json',
url='/v3/%s/types/%s/encryption/provider')
self.assertEqual(HTTPStatus.BAD_REQUEST, res.status_code)
res_dict = jsonutils.loads(res.body)
expected = {
'badRequest': {
'code': HTTPStatus.BAD_REQUEST,
'message': 'Cannot delete encryption specs. '
'Volume type in use.'
}
}
self.assertEqual(expected, res_dict)
# Delete the volumes
db.volume_destroy(context.get_admin_context(), fake.VOLUME_ID)
db.volume_destroy(context.get_admin_context(), fake.VOLUME2_ID)
# Delete, and test that get returns nothing
res = self._get_response(volume_type,
req_method='DELETE',
req_headers='application/json',
url='/v3/%s/types/%s/encryption/provider')
self.assertEqual(HTTPStatus.ACCEPTED, res.status_code)
self.assertEqual(0, len(res.body))
res = self._get_response(volume_type,
req_method='GET',
req_headers='application/json',
url='/v3/%s/types/%s/encryption')
self.assertEqual(HTTPStatus.OK, res.status_code)
res_dict = jsonutils.loads(res.body)
self.assertEqual({}, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_group_from_snap(self, mock_volume_get_all,
mock_rpc_create_group_from_src,
mock_snap_get_all, mock_group_snap_get,
mock_volume_api_create,
mock_mapping_create, mock_get_volume_type):
vol_type = utils.create_volume_type(self.ctxt, name='fake_volume_type')
mock_get_volume_type.return_value = vol_type
grp_snap = utils.create_group_snapshot(
self.ctxt,
fake.GROUP_ID,
group_type_id=fake.GROUP_TYPE_ID,
status=fields.GroupStatus.CREATING)
mock_group_snap_get.return_value = grp_snap
vol1 = utils.create_volume(self.ctxt,
availability_zone='nova',
volume_type_id=vol_type['id'],
group_id=fake.GROUP_ID)
snap = utils.create_snapshot(self.ctxt,
vol1.id,
volume_type_id=vol_type['id'],
status=fields.GroupStatus.CREATING)
mock_snap_get_all.return_value = [snap]
name = "test_group"
description = "this is a test group"
grp = utils.create_group(self.ctxt,
group_type_id=fake.GROUP_TYPE_ID,
volume_type_ids=[vol_type['id']],
availability_zone='nova',
name=name,
description=description,
group_snapshot_id=grp_snap.id,
status=fields.GroupStatus.CREATING)
vol2 = utils.create_volume(self.ctxt,
availability_zone=grp.availability_zone,
volume_type_id=vol_type['id'],
group_id=grp.id,
snapshot_id=snap.id)
mock_volume_get_all.return_value = [vol2]
self.group_api._create_group_from_group_snapshot(
self.ctxt, grp, grp_snap.id)
mock_volume_api_create.assert_called_once_with(
self.ctxt,
1,
None,
None,
availability_zone=grp.availability_zone,
group_snapshot=grp_snap,
group=grp,
snapshot=snap,
volume_type=vol_type)
mock_rpc_create_group_from_src.assert_called_once_with(
self.ctxt, grp, grp_snap)
vol2.destroy()
grp.destroy()
snap.destroy()
vol1.destroy()
grp_snap.destroy()
db.volume_type_destroy(self.ctxt, vol_type['id'])
