def test_revert_to_snapshot(self, version):
api_version = api_versions.APIVersion(version)
cs = fakes.FakeClient(api_version)
manager = volumes.VolumeManager(cs)
fake_snapshot = volume_snapshots.Snapshot(manager, {
'id': 12345,
'name': 'fake-snapshot'
},
loaded=True)
fake_volume = volumes.Volume(manager, {
'id': 1234,
'name': 'sample-volume'
},
loaded=True)
expected = {'revert': {'snapshot_id': 12345}}
if version == '3.40':
fake_volume.revert_to_snapshot(fake_snapshot)
cs.assert_called_anytime('POST',
'/volumes/1234/action',
body=expected)
else:
self.assertRaises(exceptions.VersionNotFoundForAPIMethod,
fake_volume.revert_to_snapshot, fake_snapshot)
def test_volume_manager_upload_to_image(self):
expected = {
'os-volume_upload_image': {
'force': False,
'container_format': 'bare',
'disk_format': 'raw',
'image_name': 'name',
'visibility': 'public',
'protected': True
}
}
api_version = api_versions.APIVersion('3.1')
cs = fakes.FakeClient(api_version)
manager = volumes.VolumeManager(cs)
fake_volume = volumes.Volume(manager, {
'id': 1234,
'name': 'sample-volume'
},
loaded=True)
fake_volume.upload_to_image(False,
'name',
'bare',
'raw',
visibility='public',
protected=True)
cs.assert_called_anytime('POST', '/volumes/1234/action', body=expected)
def test_get_log_levels(self):
expected = {'binary': 'cinder-api', 'server': 'host1',
'prefix': 'sqlalchemy.'}
cs = fakes.FakeClient(version_header='3.32')
result = cs.services.get_log_levels(expected['binary'],
expected['server'],
expected['prefix'])
cs.assert_called('PUT', '/os-services/get-log', body=expected)
expected = [services.LogLevel(cs.services,
{'binary': 'cinder-api', 'host': 'host1',
'prefix': 'prefix1', 'level': 'DEBUG'},
loaded=True),
services.LogLevel(cs.services,
{'binary': 'cinder-api', 'host': 'host1',
'prefix': 'prefix2', 'level': 'INFO'},
loaded=True),
services.LogLevel(cs.services,
{'binary': 'cinder-volume',
'host': 'host@backend#pool',
'prefix': 'prefix3',
'level': 'WARNING'},
loaded=True),
services.LogLevel(cs.services,
{'binary': 'cinder-volume',
'host': 'host@backend#pool',
'prefix': 'prefix4', 'level': 'ERROR'},
loaded=True)]
# Since it will be sorted by the prefix we can compare them directly
self.assertListEqual(expected, result)
def test_create_volume(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.13'))
vol = cs.volumes.create(1, group_id='1234', volume_type='5678')
expected = {
'volume': {
'status': 'creating',
'description': None,
'availability_zone': None,
'source_volid': None,
'snapshot_id': None,
'size': 1,
'user_id': None,
'name': None,
'imageRef': None,
'attach_status': 'detached',
'volume_type': '5678',
'project_id': None,
'metadata': {},
'source_replica': None,
'consistencygroup_id': None,
'multiattach': False,
'group_id': '1234',
'backup_id': None
}
}
cs.assert_called('POST', '/volumes', body=expected)
self._assert_request_id(vol)
def test_get_pools_filter_by_name(self, detail):
cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.33'))
vol = cs.volumes.get_pools(detail, {'name': 'pool1'})
request_url = '/scheduler-stats/get_pools?name=pool1'
if detail:
request_url = '/scheduler-stats/get_pools?detail=True&name=pool1'
cs.assert_called('GET', request_url)
self._assert_request_id(vol)
def test_update(self):
cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.9'))
b = cs.backups.get('1234')
backup = b.update(name='new-name')
cs.assert_called('PUT', '/backups/1234',
{'backup': {
'name': 'new-name'
}})
self._assert_request_id(backup)
def test_create_attachment(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.27'))
att = cs.attachments.create(
'e84fda45-4de4-4ce4-8f39-fc9d3b0aa05e',
{},
'557ad76c-ce54-40a3-9e91-c40d21665cc3',
'null')
cs.assert_called('POST', '/attachments')
self.assertEqual(fakes.fake_attachment['attachment'], att)
def test_set_log_levels(self):
expected = {'level': 'debug', 'binary': 'cinder-api',
'server': 'host1', 'prefix': 'sqlalchemy.'}
cs = fakes.FakeClient(version_header='3.32')
cs.services.set_log_levels(expected['level'], expected['binary'],
expected['server'], expected['prefix'])
cs.assert_called('PUT', '/os-services/set-log', body=expected)
def test_volume_manage_cluster(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.16'))
vol = cs.volumes.manage(None, {'k': 'v'}, cluster='cluster1')
expected = {'host': None, 'name': None, 'availability_zone': None,
'description': None, 'metadata': None, 'ref': {'k': 'v'},
'volume_type': None, 'bootable': False,
'cluster': 'cluster1'}
cs.assert_called('POST', '/os-volume-manage', {'volume': expected})
self._assert_request_id(vol)
def test_list_services_with_cluster_info(self):
cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.7'))
services_list = cs.services.list()
cs.assert_called('GET', '/os-services')
self.assertEqual(3, len(services_list))
for service in services_list:
self.assertIsInstance(service, services.Service)
# Make sure cluster fields from v3.7 is present and not None
self.assertIsNotNone(getattr(service, 'cluster'))
self._assert_request_id(services_list)
def test_list_services_with_backend_state(self):
cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.49'))
services_list = cs.services.list()
cs.assert_called('GET', '/os-services')
self.assertEqual(3, len(services_list))
for service in services_list:
self.assertIsInstance(service, services.Service)
# Make sure backend_state fields from v3.49 is present and not
# None
if service.binary == 'cinder-volume':
self.assertIsNotNone(getattr(service, 'backend_state', None))
self._assert_request_id(services_list)
def test_list_replication_targets(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.38'))
expected = {'list_replication_targets': {}}
g0 = cs.groups.list()[0]
grp = g0.list_replication_targets()
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
grp = cs.groups.list_replication_targets('1234')
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
grp = cs.groups.list_replication_targets(g0)
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
def test_create_group_from_src_group_(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.14'))
grp = cs.groups.create_from_src(None, '5678', name='group')
expected = {
'create-from-src': {
'description': None,
'name': 'group',
'source_group_id': '5678',
'group_snapshot_id': None
}
}
cs.assert_called('POST', '/groups/action', body=expected)
self._assert_request_id(grp)
def test_migrate_with_lock_volume(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.0'))
v = cs.volumes.get('1234')
self._assert_request_id(v)
vol = cs.volumes.migrate_volume(v, 'dest', False, True)
cs.assert_called(
'POST', '/volumes/1234/action', {
'os-migrate_volume': {
'host': 'dest',
'force_host_copy': False,
'lock_volume': True
}
})
self._assert_request_id(vol)
def test_failover_replication_group(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.38'))
expected = {'failover_replication':
{'allow_attached_volume': False,
'secondary_backend_id': None}}
g0 = cs.groups.list()[0]
grp = g0.failover_replication()
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
grp = cs.groups.failover_replication('1234')
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
grp = cs.groups.failover_replication(g0)
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
def test_migrate_cluster(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.16'))
v = cs.volumes.get('fake')
self._assert_request_id(v)
vol = cs.volumes.migrate_volume(v, 'host_dest', False, False,
'cluster_dest')
cs.assert_called(
'POST', '/volumes/fake/action', {
'os-migrate_volume': {
'cluster': 'cluster_dest',
'force_host_copy': False,
'lock_volume': False
}
})
self._assert_request_id(vol)
def test_volume_summary(self, all_tenants_input):
all_tenants, url = all_tenants_input
cs = fakes.FakeClient(api_versions.APIVersion('3.12'))
cs.volumes.summary(all_tenants=all_tenants)
cs.assert_called('GET', url)
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import ddt
from cinderclient.tests.unit import utils
from cinderclient.tests.unit.v3 import fakes
cs = fakes.FakeClient()
@ddt.ddt
class GroupsTest(utils.TestCase):
def test_delete_group(self):
expected = {'delete': {'delete-volumes': True}}
v = cs.groups.list()[0]
grp = v.delete(delete_volumes=True)
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
grp = cs.groups.delete('1234', delete_volumes=True)
self._assert_request_id(grp)
cs.assert_called('POST', '/groups/1234/action', body=expected)
grp = cs.groups.delete(v, delete_volumes=True)
def test_list_messages_with_invalid_sort(self, sort_string):
cs = fakes.FakeClient(api_versions.APIVersion('3.5'))
self.assertRaises(ValueError, cs.messages.list, sort=sort_string)
def test_list_with_image_metadata(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.0'))
cs.volumes.list(search_opts={'glance_metadata': {'key1': 'val1'}})
expected = ("/volumes/detail?glance_metadata=%s" %
parse.quote_plus("{'key1': 'val1'}"))
cs.assert_called('GET', expected)
def test_get_messages(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.3'))
fake_id = '1234'
cs.messages.get(fake_id)
cs.assert_called('GET', '/messages/%s' % fake_id)
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from cinderclient import api_versions
from cinderclient import exceptions as exc
from cinderclient.tests.unit import utils
from cinderclient.tests.unit.v3 import fakes
from cinderclient.v3 import group_types
cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.11'))
pre_cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.10'))
class GroupTypesTest(utils.TestCase):
def test_list_group_types(self):
tl = cs.group_types.list()
cs.assert_called('GET', '/group_types?is_public=None')
self._assert_request_id(tl)
for t in tl:
self.assertIsInstance(t, group_types.GroupType)
def test_list_group_types_pre_version(self):
self.assertRaises(exc.VersionNotFoundForAPIMethod,
pre_cs.group_types.list)
def test_delete_messages(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.3'))
fake_id = '1234'
cs.messages.delete(fake_id)
cs.assert_called('DELETE', '/messages/%s' % fake_id)
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import ddt
from cinderclient import api_versions
from cinderclient import exceptions as exc
from cinderclient.tests.unit import utils
from cinderclient.tests.unit.v3 import fakes
cs = fakes.FakeClient(api_version=api_versions.APIVersion('3.7'))
@ddt.ddt
class ClusterTest(utils.TestCase):
def _check_fields_present(self, clusters, detailed=False):
expected_keys = {'name', 'binary', 'state', 'status'}
if detailed:
expected_keys.update(('num_hosts', 'num_down_hosts',
'last_heartbeat', 'disabled_reason',
'created_at', 'updated_at'))
for cluster in clusters:
self.assertEqual(expected_keys, set(cluster.to_dict()))
def test_clusters_list_pre_version(self, detailed):
pre_cs = fakes.FakeClient(api_version=
api_versions.APIVersion('3.6'))
self.assertRaises(exc.VersionNotFoundForAPIMethod,
pre_cs.clusters.list, detailed=detailed)
def test_volume_list_manageable(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.8'))
cs.volumes.list_manageable('host1', detailed=False)
cs.assert_called('GET', '/manageable_volumes?host=host1')
def test_api_version(self):
client = fakes.FakeClient(version_header='3.0')
svs = client.services.server_api_version()
[self.assertIsInstance(s, services.Service) for s in svs]
def test_snapshot_list_manageable_detailed(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.8'))
cs.volume_snapshots.list_manageable('host1', detailed=True)
cs.assert_called('GET', '/manageable_snapshots/detail?host=host1')
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from cinderclient import api_versions
from cinderclient.tests.unit import utils
from cinderclient.tests.unit.v3 import fakes
# Create calls need the right version of faked client
v3cs = fakes.FakeClient(api_versions.APIVersion('3.55'))
# Other calls fall back to default behavior
cs = fakes.FakeClient()
class VolumeTransfersTest(utils.TestCase):
def test_create(self):
vol = v3cs.transfers.create('1234')
v3cs.assert_called('POST',
'/volume-transfers',
body={
'transfer': {
'volume_id': '1234',
'name': None,
'no_snapshots': False
}
def test_snapshot_list_with_metadata(self):
cs = fakes.FakeClient(api_versions.APIVersion('3.22'))
cs.volume_snapshots.list(search_opts={'metadata': {'key1': 'val1'}})
expected = ("/snapshots/detail?metadata=%s" %
parse.quote_plus("{'key1': 'val1'}"))
cs.assert_called('GET', expected)
