# Copyright 2016 Nexenta Systems, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # 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. """ Unit tests for OpenStack Cinder volume driver """ import mock from mock import patch from oslo_serialization import jsonutils from oslo_utils import units import requests from cinder import context from cinder import db from cinder import exception from cinder import test from cinder.volume import configuration as conf from cinder.volume.drivers.nexenta.ns5 import iscsi from cinder.volume.drivers.nexenta.ns5 import jsonrpc class TestNexentaISCSIDriver(test.TestCase): TEST_VOLUME_NAME = 'volume1' TEST_VOLUME_NAME2 = 'volume2' TEST_VOLUME_NAME3 = 'volume3' TEST_SNAPSHOT_NAME = 'snapshot1' TEST_VOLUME_REF = { 'name': TEST_VOLUME_NAME, 'size': 1, 'id': '1', 'status': 'available' } TEST_VOLUME_REF2 = { 'name': TEST_VOLUME_NAME2, 'size': 1, 'id': '2', 'status': 'in-use' } TEST_VOLUME_REF3 = { 'name': TEST_VOLUME_NAME3, 'size': 2, 'id': '2', 'status': 'in-use' } TEST_SNAPSHOT_REF = { 'name': TEST_SNAPSHOT_NAME, 'volume_name': TEST_VOLUME_NAME, 'volume_id': '1', 'volume_size': 1 } def __init__(self, method): super(TestNexentaISCSIDriver, self).__init__(method) def setUp(self): super(TestNexentaISCSIDriver, self).setUp() self.cfg = mock.Mock(spec=conf.Configuration) self.ctxt = context.get_admin_context() self.cfg.nexenta_dataset_description = '' self.cfg.nexenta_host = '1.1.1.1' self.cfg.nexenta_user = 'admin' self.cfg.nexenta_password = 'nexenta' self.cfg.nexenta_volume = 'cinder' self.cfg.nexenta_rest_port = 2000 self.cfg.nexenta_rest_protocol = 'http' self.cfg.nexenta_iscsi_target_portal_port = 8080 self.cfg.nexenta_target_prefix = 'iqn:' self.cfg.nexenta_target_group_prefix = 'cinder/' self.cfg.nexenta_ns5_blocksize = 32 self.cfg.nexenta_sparse = True self.cfg.nexenta_dataset_compression = 'on' self.cfg.nexenta_dataset_dedup = 'off' self.cfg.reserved_percentage = 20 self.cfg.nexenta_volume = 'pool' self.cfg.nexenta_volume_group = 'dsg' self.nef_mock = mock.Mock() self.stubs.Set(jsonrpc, 'NexentaJSONProxy', lambda *_, **__: self.nef_mock) self.drv = iscsi.NexentaISCSIDriver( configuration=self.cfg) self.drv.db = db self.drv.do_setup(self.ctxt) def _create_volume_db_entry(self): vol = { 'id': '1', 'size': 1, 'status': 'available', 'provider_location': self.TEST_VOLUME_NAME } return db.volume_create(self.ctxt, vol)['id'] def test_do_setup(self): self.nef_mock.post.side_effect = exception.NexentaException( 'Could not create volume group') self.assertRaises( exception.NexentaException, self.drv.do_setup, self.ctxt) self.nef_mock.post.side_effect = exception.NexentaException( '{"code": "EEXIST"}') self.assertIsNone(self.drv.do_setup(self.ctxt)) def test_check_for_setup_error(self): self.nef_mock.get.return_value = { 'data': [{'name': 'iscsit', 'state': 'offline'}]} self.assertRaises( exception.NexentaException, self.drv.check_for_setup_error) self.nef_mock.get.side_effect = exception.NexentaException() self.assertRaises(LookupError, self.drv.check_for_setup_error) def test_create_volume(self): self.drv.create_volume(self.TEST_VOLUME_REF) url = 'storage/pools/pool/volumeGroups/dsg/volumes' self.nef_mock.post.assert_called_with(url, { 'name': self.TEST_VOLUME_REF['name'], 'volumeSize': 1 * units.Gi, 'volumeBlockSize': 32768, 'sparseVolume': self.cfg.nexenta_sparse}) def test_delete_volume(self): self.nef_mock.delete.side_effect = exception.NexentaException() self.assertIsNone(self.drv.delete_volume(self.TEST_VOLUME_REF)) url = 'storage/pools/pool/volumeGroups' data = {'name': 'dsg', 'volumeBlockSize': 32768} self.nef_mock.post.assert_called_with(url, data) def test_extend_volume(self): self.drv.extend_volume(self.TEST_VOLUME_REF, 2) url = ('storage/pools/pool/volumeGroups/dsg/volumes/%(name)s') % { 'name': self.TEST_VOLUME_REF['name']} self.nef_mock.put.assert_called_with(url, { 'volumeSize': 2 * units.Gi}) def test_delete_snapshot(self): self._create_volume_db_entry() url = ('storage/pools/pool/volumeGroups/dsg/' 'volumes/volume-1/snapshots/snapshot1') self.nef_mock.delete.side_effect = exception.NexentaException('EBUSY') self.drv.delete_snapshot(self.TEST_SNAPSHOT_REF) self.nef_mock.delete.assert_called_with(url) self.nef_mock.delete.side_effect = exception.NexentaException('Error') self.drv.delete_snapshot(self.TEST_SNAPSHOT_REF) self.nef_mock.delete.assert_called_with(url) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver.create_snapshot') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver.delete_snapshot') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver.create_volume_from_snapshot') def test_create_cloned_volume(self, crt_vol, dlt_snap, crt_snap): self._create_volume_db_entry() vol = self.TEST_VOLUME_REF2 src_vref = self.TEST_VOLUME_REF crt_vol.side_effect = exception.NexentaException() dlt_snap.side_effect = exception.NexentaException() self.assertRaises( exception.NexentaException, self.drv.create_cloned_volume, vol, src_vref) def test_create_snapshot(self): self._create_volume_db_entry() self.drv.create_snapshot(self.TEST_SNAPSHOT_REF) url = 'storage/pools/pool/volumeGroups/dsg/volumes/volume-1/snapshots' self.nef_mock.post.assert_called_with( url, {'name': 'snapshot1'}) def test_create_larger_volume_from_snapshot(self): self._create_volume_db_entry() vol = self.TEST_VOLUME_REF3 src_vref = self.TEST_SNAPSHOT_REF self.drv.create_volume_from_snapshot(vol, src_vref) # make sure the volume get extended! url = ('storage/pools/pool/volumeGroups/dsg/volumes/%(name)s') % { 'name': self.TEST_VOLUME_REF3['name']} self.nef_mock.put.assert_called_with(url, { 'volumeSize': 2 * units.Gi}) def test_get_target_by_alias(self): self.nef_mock.get.return_value = {'data': []} self.assertIsNone(self.drv._get_target_by_alias('1.1.1.1-0')) self.nef_mock.get.return_value = {'data': [{'name': 'iqn-0'}]} self.assertEqual( {'name': 'iqn-0'}, self.drv._get_target_by_alias('1.1.1.1-0')) def test_target_group_exists(self): self.nef_mock.get.return_value = {'data': []} self.assertFalse( self.drv._target_group_exists({'data': [{'name': 'iqn-0'}]})) self.nef_mock.get.return_value = {'data': [{'name': '1.1.1.1-0'}]} self.assertTrue(self.drv._target_group_exists( {'data': [{'name': 'iqn-0'}]})) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_target_by_alias') def test_create_target(self, target): self.nef_mock.get.return_value = {} target.return_value = {'name': 'iqn-0'} self.assertEqual('iqn-0', self.drv._create_target(0)) target.return_value = None self.assertRaises(TypeError, self.drv._create_target, 0) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._create_target') def test_get_target_name(self, target_name): self._create_volume_db_entry() self.drv.targets = {} target_name.return_value = 'iqn-0' self.drv.targets['iqn-0'] = [] self.assertEqual( 'iqn-0', self.drv._get_target_name(self.TEST_VOLUME_REF)) volume = self.TEST_VOLUME_REF volume['provider_location'] = '1.1.1.1:8080,1 iqn-0 0' self.nef_mock.get.return_value = {'data': [{'alias': '1.1.1.1-0'}]} self.assertEqual( 'iqn-0', self.drv._get_target_name(self.TEST_VOLUME_REF)) self.assertEqual('1.1.1.1-0', self.drv.targetgroups['iqn-0']) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._create_target') def test_get_targetgroup_name(self, target_name): self.TEST_VOLUME_REF['provider_location'] = '1.1.1.1:8080,1 iqn-0 0' self._create_volume_db_entry() target_name = 'iqn-0' self.drv.targetgroups[target_name] = '1.1.1.1-0' self.assertEqual( '1.1.1.1-0', self.drv._get_targetgroup_name(self.TEST_VOLUME_REF)) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_targetgroup_name') def test_get_lun_id(self, targetgroup): targetgroup.return_value = '1.1.1.1-0' self.nef_mock.get.return_value = {'data': [{'guid': '0'}]} self.assertEqual('0', self.drv._get_lun_id(self.TEST_VOLUME_REF)) self.nef_mock.get.return_value = {} self.assertRaises( LookupError, self.drv._get_lun_id, self.TEST_VOLUME_REF) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_lun_id') def test_lu_exists(self, lun_id): lun_id.return_value = '0' self.assertTrue(self.drv._lu_exists(self.TEST_VOLUME_REF)) lun_id.side_effect = LookupError self.assertFalse(self.drv._lu_exists(self.TEST_VOLUME_REF)) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_lun_id') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_targetgroup_name') def test_get_lun(self, targetgroup, lun_id): lun_id.return_value = '0' targetgroup.return_value = '1.1.1.1-0' self.nef_mock.get.return_value = {'data': [{'lunNumber': 0}]} self.assertEqual(0, self.drv._get_lun(self.TEST_VOLUME_REF)) self.nef_mock.get.return_value = {} self.assertRaises( LookupError, self.drv._get_lun, self.TEST_VOLUME_REF) lun_id.side_effect = LookupError() self.assertIsNone(self.drv._get_lun(self.TEST_VOLUME_REF)) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_target_name') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_targetgroup_name') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._lu_exists') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_lun') def test_do_export(self, get_lun, lu_exists, targetgroup, target): target.return_value = 'iqn-0' targetgroup.return_value = '1.1.1.1-0' lu_exists.return_value = False get_lun.return_value = 0 self.assertEqual( {'provider_location': '1.1.1.1:8080,1 iqn-0 0'}, self.drv._do_export({}, self.TEST_VOLUME_REF)) @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_targetgroup_name') @patch('cinder.volume.drivers.nexenta.ns5.iscsi.' 'NexentaISCSIDriver._get_lun_id') def test_remove_export(self, lun_id, tg_name): lun_id.return_value = '0' tg_name.return_value = '1.1.1.1-0' self.nef_mock.delete.side_effect = exception.NexentaException( 'No such logical unit in target group') self.assertIsNone( self.drv.remove_export(self.ctxt, self.TEST_VOLUME_REF)) self.nef_mock.delete.side_effect = exception.NexentaException( 'Error') self.assertRaises( exception.NexentaException, self.drv.remove_export, self.ctxt, self.TEST_VOLUME_REF) lun_id.side_effect = LookupError() self.assertIsNone( self.drv.remove_export(self.ctxt, self.TEST_VOLUME_REF)) def test_update_volume_stats(self): self.nef_mock.get.return_value = { 'bytesAvailable': 10 * units.Gi, 'bytesUsed': 2 * units.Gi } location_info = '%(driver)s:%(host)s:%(pool)s/%(group)s' % { 'driver': self.drv.__class__.__name__, 'host': self.cfg.nexenta_host, 'pool': self.cfg.nexenta_volume, 'group': self.cfg.nexenta_volume_group, } stats = { 'vendor_name': 'Nexenta', 'dedup': self.cfg.nexenta_dataset_dedup, 'compression': self.cfg.nexenta_dataset_compression, 'description': self.cfg.nexenta_dataset_description, 'driver_version': self.drv.VERSION, 'storage_protocol': 'iSCSI', 'total_capacity_gb': 10, 'free_capacity_gb': 8, 'reserved_percentage': self.cfg.reserved_percentage, 'QoS_support': False, 'volume_backend_name': self.drv.backend_name, 'location_info': location_info, 'iscsi_target_portal_port': ( self.cfg.nexenta_iscsi_target_portal_port), 'nef_url': self.drv.nef.url } self.drv._update_volume_stats() self.assertEqual(stats, self.drv._stats) class TestNexentaJSONProxy(test.TestCase): def __init__(self, method): super(TestNexentaJSONProxy, self).__init__(method) @patch('requests.Response.close') @patch('requests.get') @patch('requests.post') def test_call(self, post, get, close): nef_get = jsonrpc.NexentaJSONProxy( 'http', '1.1.1.1', '8080', 'user', 'pass', method='get') nef_post = jsonrpc.NexentaJSONProxy( 'http', '1.1.1.1', '8080', 'user', 'pass', method='post') data = {'key': 'value'} get.return_value = requests.Response() post.return_value = requests.Response() get.return_value.__setstate__({ 'status_code': 200, '_content': jsonutils.dumps(data)}) self.assertEqual({'key': 'value'}, nef_get('url')) get.return_value.__setstate__({ 'status_code': 201, '_content': ''}) self.assertEqual('Success', nef_get('url')) data2 = {'links': [{'href': 'redirect_url'}]} post.return_value.__setstate__({ 'status_code': 202, '_content': jsonutils.dumps(data2)}) get.return_value.__setstate__({ 'status_code': 200, '_content': jsonutils.dumps(data)}) self.assertEqual({'key': 'value'}, nef_post('url')) get.return_value.__setstate__({ 'status_code': 200, '_content': ''}) self.assertEqual('Success', nef_post('url', data)) get.return_value.__setstate__({ 'status_code': 400, '_content': jsonutils.dumps({'code': 'ENOENT'})}) self.assertRaises(exception.NexentaException, lambda: nef_get('url'))