openstack/deb-cinder
Code Issues Proposed changes
599fff650f
deb-cinder/cinder/tests/unit/test_hitachi_hbsd_horcm_fc.py
Danny Al-Gaaf dbf7495f51 Hitachi drivers: resize volume if cloned image is larger 
Extend volume if during create_volume_from_snapshot() the new volume
is larger than the image it was cloned from. Extended test cases to
cover the change.

Closes-Bug: #1554779

Change-Id: I001d40e9aaa15dfa98230a1b6902b1d24931c9af
Signed-off-by: Danny Al-Gaaf <danny.al-gaaf@bisect.de>
2016-03-17 20:17:37 +01:00

1035 lines
44 KiB
Python
Raw Blame History

# Copyright (C) 2014, 2015, Hitachi, Ltd.
#
# 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.
#
"""
Self test for Hitachi Block Storage Driver
"""
import mock
from cinder import exception
from cinder import test
from cinder import utils
from cinder.volume import configuration as conf
from cinder.volume.drivers.hitachi import hbsd_basiclib
from cinder.volume.drivers.hitachi import hbsd_common
from cinder.volume.drivers.hitachi import hbsd_fc
from cinder.volume.drivers.hitachi import hbsd_horcm
def _exec_raidcom(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_vals.get(args)
def _exec_raidcom_get_ldev_no_stdout(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_no_stdout.get(args)
def _exec_raidcom_get_ldev_no_nml(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_no_nml.get(args)
def _exec_raidcom_get_ldev_no_open_v(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_no_open_v.get(args)
def _exec_raidcom_get_ldev_no_hdp(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_no_hdp.get(args)
def _exec_raidcom_get_ldev_pair(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_pair.get(args)
def _exec_raidcom_get_ldev_permit(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_permit.get(args)
def _exec_raidcom_get_ldev_invalid_size(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_invalid_size.get(args)
def _exec_raidcom_get_ldev_num_port(*args, **kargs):
return HBSDHORCMFCDriverTest.horcm_get_ldev_num_port.get(args)
class HBSDHORCMFCDriverTest(test.TestCase):
"""Test HBSDHORCMFCDriver."""
raidqry_result = "DUMMY\n\
Ver&Rev: 01-31-03/06"
raidcom_get_host_grp_result = "DUMMY\n\
CL1-A 0 HBSD-127.0.0.1 None -\n\
CL1-A 1 - None -"
raidcom_get_result = "LDEV : 0\n\
VOL_TYPE : OPEN-V-CVS\n\
LDEV : 1\n\
VOL_TYPE : NOT DEFINED"
raidcom_get_result2 = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : CVS : HDP\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 0\n\
STS : NML"
raidcom_get_result3 = "Serial# : 210944\n\
LDEV : 0\n\
SL : 0\n\
CL : 0\n\
VOL_TYPE : NOT DEFINED\n\
VOL_Capacity(BLK) : 2098560\n\
NUM_LDEV : 1\n\
LDEVs : 0\n\
NUM_PORT : 3\n\
PORTs : CL3-A-41 42 R7000001 : CL8-B-20 8 R7000000 : CL6-A-10 25 R7000000\n\
F_POOLID : NONE\n\
VOL_ATTR : CVS\n\
RAID_LEVEL : RAID5\n\
RAID_TYPE : 3D+1P\n\
NUM_GROUP : 1\n\
RAID_GROUPs : 01-01\n\
DRIVE_TYPE : DKR5C-J600SS\n\
DRIVE_Capa : 1143358736\n\
LDEV_NAMING : test\n\
STS : NML\n\
OPE_TYPE : NONE\n\
OPE_RATE : 100\n\
MP# : 0\n\
SSID : 0004"
raidcom_get_command_status_result = "HANDLE SSB1 SSB2 ERR_CNT\
Serial# Description\n\
00d4 - - 0 210944 -"
raidcom_get_result4 = "Serial# : 210944\n\
LDEV : 0\n\
SL : 0\n\
CL : 0\n\
VOL_TYPE : DEFINED\n\
VOL_Capacity(BLK) : 2098560\n\
NUM_LDEV : 1\n\
LDEVs : 0\n\
NUM_PORT : 3\n\
PORTs : CL3-A-41 42 R7000001 : CL8-B-20 8 R7000000 : CL6-A-10 25 R7000000\n\
F_POOLID : NONE\n\
VOL_ATTR : CVS\n\
RAID_LEVEL : RAID5\n\
RAID_TYPE : 3D+1P\n\
NUM_GROUP : 1\n\
RAID_GROUPs : 01-01\n\
DRIVE_TYPE : DKR5C-J600SS\n\
DRIVE_Capa : 1143358736\n\
LDEV_NAMING : test\n\
STS : NML\n\
OPE_TYPE : NONE\n\
OPE_RATE : 100\n\
MP# : 0\n\
SSID : 0004"
raidcom_get_copy_grp_result = "DUMMY\n\
HBSD-127.0.0.1None1A31 HBSD-127.0.0.1None1A31P - - None\n\
HBSD-127.0.0.1None1A31 HBSD-127.0.0.1None1A31S - - None"
raidcom_get_device_grp_result1 = "DUMMY\n\
HBSD-127.0.0.1None1A31P HBSD-ldev-0-2 0 None"
raidcom_get_device_grp_result2 = "DUMMY\n\
HBSD-127.0.0.1None1A31S HBSD-ldev-0-2 2 None"
raidcom_get_snapshot_result = "DUMMY\n\
HBSD-sanp P-VOL PSUS None 0 3 3 18 100 G--- 53ee291f\n\
HBSD-sanp P-VOL PSUS None 0 4 4 18 100 G--- 53ee291f"
raidcom_dp_pool_result = "DUMMY \n\
030 POLN 0 6006 6006 75 80 1 14860 32 167477"
raidcom_port_result = "DUMMY\n\
CL1-A FIBRE TAR AUT 01 Y PtoP Y 0 None 50060E801053C2E0 -"
raidcom_port_result2 = "DUMMY\n\
CL1-A 12345678912345aa None -\n\
CL1-A 12345678912345bb None -"
raidcom_host_grp_result = "DUMMY\n\
CL1-A 0 HBSD-127.0.0.1 None LINUX/IRIX"
raidcom_hba_wwn_result = "DUMMY\n\
CL1-A 0 HBSD-127.0.0.1 12345678912345aa None -"
raidcom_get_lun_result = "DUMMY\n\
CL1-A 0 LINUX/IRIX 254 1 5 - None"
pairdisplay_result = "DUMMY\n\
HBSD-127.0.0.1None1A31 HBSD-ldev-0-2 L CL1-A-0 0 0 0 None 0 P-VOL PSUS None 2\
-\n\
HBSD-127.0.0.1None1A31 HBSD-ldev-0-2 R CL1-A-0 0 0 0 None 2 S-VOL SSUS - 0 -"
pairdisplay_result2 = "DUMMY\n\
HBSD-127.0.0.1None1A30 HBSD-ldev-1-1 L CL1-A-1 0 0 0 None 1 P-VOL PAIR None 1\
-\n\
HBSD-127.0.0.1None1A30 HBSD-ldev-1-1 R CL1-A-1 0 0 0 None 1 S-VOL PAIR - 1 -"
horcm_vals = {
('raidqry', u'-h'):
[0, "%s" % raidqry_result, ""],
('raidcom', '-login user pasword'):
[0, "", ""],
('raidcom', u'get host_grp -port CL1-A -key host_grp'):
[0, "%s" % raidcom_get_host_grp_result, ""],
('raidcom', u'add host_grp -port CL1-A-1 -host_grp_name HBSD-pair00'):
[0, "", ""],
('raidcom',
u'add host_grp -port CL1-A-1 -host_grp_name HBSD-127.0.0.2'):
[0, "", ""],
('raidcom', u'delete host_grp -port CL1-A-1 HBSD-127.0.0.2'):
[1, "", ""],
('raidcom', 'get ldev -ldev_id 0 -cnt 2'):
[0, "%s" % raidcom_get_result, ""],
('raidcom',
'add ldev -pool 30 -ldev_id 1 -capacity 128G -emulation OPEN-V'):
[0, "", ""],
('raidcom',
'add ldev -pool 30 -ldev_id 1 -capacity 256G -emulation OPEN-V'):
[1, "", "SSB=0x2E22,0x0001"],
('raidcom', 'get command_status'):
[0, "%s" % raidcom_get_command_status_result, ""],
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_result2, ""],
('raidcom', 'get ldev -ldev_id 1 -check_status NML -time 120'):
[0, "", ""],
('raidcom', 'get snapshot -ldev_id 0'):
[0, "", ""],
('raidcom', 'get snapshot -ldev_id 1'):
[0, "%s" % raidcom_get_snapshot_result, ""],
('raidcom', 'get snapshot -ldev_id 2'):
[0, "", ""],
('raidcom', 'get snapshot -ldev_id 3'):
[0, "", ""],
('raidcom', 'get copy_grp'):
[0, "%s" % raidcom_get_copy_grp_result, ""],
('raidcom', 'delete ldev -ldev_id 0'):
[0, "", ""],
('raidcom', 'delete ldev -ldev_id 1'):
[0, "", ""],
('raidcom', 'delete ldev -ldev_id 2'):
[1, "", "error"],
('raidcom', 'delete ldev -ldev_id 3'):
[1, "", "SSB=0x2E20,0x0000"],
('raidcom', 'get device_grp -device_grp_name HBSD-127.0.0.1None1A30P'):
[0, "", ""],
('raidcom', 'get device_grp -device_grp_name HBSD-127.0.0.1None1A30S'):
[0, "", ""],
('raidcom', 'get device_grp -device_grp_name HBSD-127.0.0.1None1A31P'):
[0, "%s" % raidcom_get_device_grp_result1, ""],
('raidcom', 'get device_grp -device_grp_name HBSD-127.0.0.1None1A31S'):
[0, "%s" % raidcom_get_device_grp_result2, ""],
('pairdisplay', '-g HBSD-127.0.0.1None1A30 -CLI'):
[0, "", ""],
('pairdisplay', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-0-1 -CLI'):
[0, "", ""],
('pairdisplay', '-g HBSD-127.0.0.1None1A31 -CLI'):
[0, "%s" % pairdisplay_result, ""],
('pairdisplay', '-g HBSD-127.0.0.1None1A31 -d HBSD-ldev-0-2 -CLI'):
[0, "%s" % pairdisplay_result, ""],
('pairdisplay', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-1-1 -CLI'):
[0, "%s" % pairdisplay_result2, ""],
('raidcom',
'add device_grp -device_grp_name HBSD-127.0.0.1None1A30P \
HBSD-ldev-0-1 -ldev_id 0'):
[0, "", ""],
('raidcom',
'add device_grp -device_grp_name HBSD-127.0.0.1None1A30S \
HBSD-ldev-0-1 -ldev_id 1'):
[0, "", ""],
('raidcom',
'add device_grp -device_grp_name HBSD-127.0.0.1None1A30P \
HBSD-ldev-1-1 -ldev_id 1'):
[0, "", ""],
('raidcom',
'add device_grp -device_grp_name HBSD-127.0.0.1None1A30S \
HBSD-ldev-1-1 -ldev_id 1'):
[0, "", ""],
('raidcom',
'add copy_grp -copy_grp_name HBSD-127.0.0.1None1A30 \
HBSD-127.0.0.1None1A30P HBSD-127.0.0.1None1A30S -mirror_id 0'):
[0, "", ""],
('paircreate', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-0-1 \
-split -fq quick -c 3 -vl'):
[0, "", ""],
('paircreate', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-1-1 \
-split -fq quick -c 3 -vl'):
[0, "", ""],
('pairevtwait', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-0-1 -nowait'):
[4, "", ""],
('pairevtwait', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-0-1 -nowaits'):
[4, "", ""],
('pairevtwait', '-g HBSD-127.0.0.1None1A31 -d HBSD-ldev-0-2 -nowait'):
[1, "", ""],
('pairevtwait', '-g HBSD-127.0.0.1None1A31 -d HBSD-ldev-0-2 -nowaits'):
[1, "", ""],
('pairevtwait', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-1-1 -nowait'):
[4, "", ""],
('pairevtwait', '-g HBSD-127.0.0.1None1A30 -d HBSD-ldev-1-1 -nowaits'):
[200, "", ""],
('pairsplit', '-g HBSD-127.0.0.1None1A31 -d HBSD-ldev-0-2 -S'):
[0, "", ""],
('raidcom', 'extend ldev -ldev_id 0 -capacity 128G'):
[0, "", ""],
('raidcom', 'get dp_pool'):
[0, "%s" % raidcom_dp_pool_result, ""],
('raidcom', 'get port'):
[0, "%s" % raidcom_port_result, ""],
('raidcom', 'get port -port CL1-A'):
[0, "%s" % raidcom_port_result2, ""],
('raidcom', 'get host_grp -port CL1-A'):
[0, "%s" % raidcom_host_grp_result, ""],
('raidcom', 'get hba_wwn -port CL1-A-0'):
[0, "%s" % raidcom_hba_wwn_result, ""],
('raidcom', 'get hba_wwn -port CL1-A-1'):
[0, "", ""],
('raidcom', 'add hba_wwn -port CL1-A-0 -hba_wwn 12345678912345bb'):
[0, "", ""],
('raidcom', 'add hba_wwn -port CL1-A-1 -hba_wwn 12345678912345bb'):
[1, "", ""],
('raidcom', u'get lun -port CL1-A-0'):
[0, "%s" % raidcom_get_lun_result, ""],
('raidcom', u'get lun -port CL1-A-1'):
[0, "", ""],
('raidcom', u'add lun -port CL1-A-0 -ldev_id 0 -lun_id 0'):
[0, "", ""],
('raidcom', u'add lun -port CL1-A-0 -ldev_id 1 -lun_id 0'):
[0, "", ""],
('raidcom', u'add lun -port CL1-A-1 -ldev_id 0 -lun_id 0'):
[0, "", ""],
('raidcom', u'add lun -port CL1-A-1 -ldev_id 1 -lun_id 0'):
[0, "", ""],
('raidcom', u'delete lun -port CL1-A-0 -ldev_id 0'):
[0, "", ""],
('raidcom', u'delete lun -port CL1-A-0 -ldev_id 1'):
[0, "", ""],
('raidcom', u'delete lun -port CL1-A-1 -ldev_id 0'):
[0, "", ""],
('raidcom', u'delete lun -port CL1-A-1 -ldev_id 2'):
[0, "", ""],
('raidcom', u'delete lun -port CL1-A-1 -ldev_id 1'):
[1, "", ""]}
horcm_get_ldev_no_stdout = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "", ""]}
raidcom_get_ldev_no_nml = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : CVS : HDP\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 0\n\
STS :"
horcm_get_ldev_no_nml = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_no_nml, ""]}
raidcom_get_ldev_no_open_v = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : CVS\n\
VOL_ATTR : CVS : HDP\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 0\n\
STS : NML"
horcm_get_ldev_no_open_v = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_no_open_v, ""]}
raidcom_get_ldev_no_hdp = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : CVS :\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 0\n\
STS : NML"
horcm_get_ldev_no_hdp = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_no_hdp, ""]}
raidcom_get_ldev_pair = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : HORC : HDP\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 0\n\
STS : NML"
horcm_get_ldev_pair = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_pair, ""]}
raidcom_get_ldev_permit = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : XXX : HDP\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 0\n\
STS : NML"
horcm_get_ldev_permit = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_permit, ""]}
raidcom_get_ldev_invalid_size = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : CVS : HDP\n\
VOL_Capacity(BLK) : 2097151\n\
NUM_PORT : 0\n\
STS : NML"
horcm_get_ldev_invalid_size = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_invalid_size, ""]}
raidcom_get_ldev_num_port = "DUMMY\n\
LDEV : 1\n\
DUMMY\n\
DUMMY\n\
VOL_TYPE : OPEN-V-CVS\n\
VOL_ATTR : CVS : HDP\n\
VOL_Capacity(BLK) : 2097152\n\
NUM_PORT : 1\n\
STS : NML"
horcm_get_ldev_num_port = {
('raidcom', 'get ldev -ldev_id 1'):
[0, "%s" % raidcom_get_ldev_num_port, ""]}
# The following information is passed on to tests, when creating a volume
_VOLUME = {'size': 128, 'volume_type': None, 'source_volid': '0',
'provider_location': '0', 'name': 'test',
'id': 'abcdefg', 'snapshot_id': '0', 'status': 'available'}
test_volume = {'name': 'test_volume', 'size': 128,
'id': 'test-volume',
'provider_location': '1', 'status': 'available'}
test_volume_larger = {'name': 'test_volume', 'size': 256,
'id': 'test-volume',
'provider_location': '1', 'status': 'available'}
test_volume_error = {'name': 'test_volume', 'size': 256,
'id': 'test-volume',
'status': 'creating'}
test_volume_error2 = {'name': 'test_volume2', 'size': 128,
'id': 'test-volume2',
'provider_location': '1', 'status': 'available'}
test_volume_error3 = {'name': 'test_volume3', 'size': 128,
'id': 'test-volume3',
'volume_metadata': [{'key': 'type',
'value': 'V-VOL'}],
'provider_location': '1', 'status': 'available'}
test_volume_error4 = {'name': 'test_volume4', 'size': 128,
'id': 'test-volume2',
'provider_location': '3', 'status': 'available'}
test_volume_error5 = {'name': 'test_volume', 'size': 256,
'id': 'test-volume',
'provider_location': '1', 'status': 'available'}
test_snapshot = {'volume_name': 'test', 'size': 128,
'volume_size': 128, 'name': 'test-snap',
'volume_id': 0, 'id': 'test-snap-0', 'volume': _VOLUME,
'provider_location': '0', 'status': 'available'}
test_snapshot_error = {'volume_name': 'test', 'size': 128,
'volume_size': 128, 'name': 'test-snap',
'volume_id': 0, 'id': 'test-snap-0',
'volume': _VOLUME,
'provider_location': '2', 'status': 'available'}
test_snapshot_error2 = {'volume_name': 'test', 'size': 128,
'volume_size': 128, 'name': 'test-snap',
'volume_id': 0, 'id': 'test-snap-0',
'volume': _VOLUME,
'provider_location': '1', 'status': 'available'}
SERIAL_NUM = '210944'
test_existing_ref = {'ldev': '1', 'serial_number': SERIAL_NUM}
test_existing_none_ldev_ref = {'ldev': None,
'serial_number': SERIAL_NUM}
test_existing_invalid_ldev_ref = {'ldev': 'AAA',
'serial_number': SERIAL_NUM}
test_existing_no_ldev_ref = {'serial_number': SERIAL_NUM}
test_existing_none_serial_ref = {'ldev': '1', 'serial_number': None}
test_existing_invalid_serial_ref = {'ldev': '1', 'serial_number': '999999'}
test_existing_no_serial_ref = {'ldev': '1'}
def __init__(self, *args, **kwargs):
super(HBSDHORCMFCDriverTest, self).__init__(*args, **kwargs)
@mock.patch.object(utils, 'brick_get_connector_properties',
return_value={'ip': '127.0.0.1',
'wwpns': ['12345678912345aa']})
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(utils, 'execute',
return_value=['%s' % raidqry_result, ''])
def setUp(self, arg1, arg2, arg3, arg4):
super(HBSDHORCMFCDriverTest, self).setUp()
self._setup_config()
self._setup_driver()
self.driver.check_param()
self.driver.common.pair_flock = hbsd_basiclib.NopLock()
self.driver.common.command = hbsd_horcm.HBSDHORCM(self.configuration)
self.driver.common.command.horcmgr_flock = hbsd_basiclib.NopLock()
self.driver.common.create_lock_file()
self.driver.common.command.connect_storage()
self.driver.max_hostgroups = \
self.driver.common.command.get_max_hostgroups()
self.driver.add_hostgroup()
self.driver.output_param_to_log()
self.driver.do_setup_status.set()
def _setup_config(self):
self.configuration = mock.Mock(conf.Configuration)
self.configuration.hitachi_pool_id = 30
self.configuration.hitachi_thin_pool_id = 31
self.configuration.hitachi_target_ports = "CL1-A"
self.configuration.hitachi_debug_level = 0
self.configuration.hitachi_serial_number = "None"
self.configuration.hitachi_unit_name = None
self.configuration.hitachi_group_request = True
self.configuration.hitachi_group_range = None
self.configuration.hitachi_zoning_request = False
self.configuration.config_group = "None"
self.configuration.hitachi_ldev_range = "0-1"
self.configuration.hitachi_default_copy_method = 'FULL'
self.configuration.hitachi_copy_check_interval = 1
self.configuration.hitachi_async_copy_check_interval = 1
self.configuration.hitachi_copy_speed = 3
self.configuration.hitachi_horcm_add_conf = True
self.configuration.hitachi_horcm_numbers = "409,419"
self.configuration.hitachi_horcm_user = "user"
self.configuration.hitachi_horcm_password = "pasword"
self.configuration.hitachi_horcm_resource_lock_timeout = 600
def _setup_driver(self):
self.driver = hbsd_fc.HBSDFCDriver(
configuration=self.configuration)
context = None
db = None
self.driver.common = hbsd_common.HBSDCommon(
self.configuration, self.driver, context, db)
# API test cases
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_create_volume(self, arg1, arg2, arg3):
"""test create_volume."""
ret = self.driver.create_volume(self._VOLUME)
vol = self._VOLUME.copy()
vol['provider_location'] = ret['provider_location']
self.assertEqual('1', vol['provider_location'])
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_create_volume_error(self, arg1, arg2, arg3):
"""test create_volume."""
self.assertRaises(exception.HBSDError, self.driver.create_volume,
self.test_volume_error)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_get_volume_stats(self, arg1, arg2):
"""test get_volume_stats."""
stats = self.driver.get_volume_stats(True)
self.assertEqual('Hitachi', stats['vendor_name'])
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_get_volume_stats_error(self, arg1, arg2):
"""test get_volume_stats."""
self.configuration.hitachi_pool_id = 29
stats = self.driver.get_volume_stats(True)
self.assertEqual({}, stats)
self.configuration.hitachi_pool_id = 30
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_extend_volume(self, arg1, arg2, arg3, arg4):
"""test extend_volume."""
self.driver.extend_volume(self._VOLUME, 256)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_extend_volume_error(self, arg1, arg2, arg3, arg4):
"""test extend_volume."""
self.assertRaises(exception.HBSDError, self.driver.extend_volume,
self.test_volume_error3, 256)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_delete_volume(self, arg1, arg2, arg3, arg4):
"""test delete_volume."""
self.driver.delete_volume(self._VOLUME)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_delete_volume_error(self, arg1, arg2, arg3, arg4):
"""test delete_volume."""
self.driver.delete_volume(self.test_volume_error4)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_common.HBSDCommon, 'get_snapshot_metadata',
return_value={'dummy_snapshot_meta': 'snapshot_meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume',
return_value=_VOLUME)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_snapshot(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7):
"""test create_snapshot."""
ret = self.driver.create_volume(self._VOLUME)
ret = self.driver.create_snapshot(self.test_snapshot)
self.assertEqual('1', ret['provider_location'])
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_common.HBSDCommon, 'get_snapshot_metadata',
return_value={'dummy_snapshot_meta': 'snapshot_meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume',
return_value=_VOLUME)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_snapshot_error(self, arg1, arg2, arg3, arg4, arg5, arg6,
arg7):
"""test create_snapshot."""
ret = self.driver.create_volume(self.test_volume)
ret = self.driver.create_snapshot(self.test_snapshot_error)
self.assertEqual('1', ret['provider_location'])
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_delete_snapshot(self, arg1, arg2, arg3, arg4):
"""test delete_snapshot."""
self.driver.delete_snapshot(self.test_snapshot)
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_delete_snapshot_error(self, arg1, arg2, arg3, arg4):
"""test delete_snapshot."""
self.assertRaises(exception.HBSDCmdError,
self.driver.delete_snapshot,
self.test_snapshot_error)
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_volume_from_snapshot(self, arg1, arg2, arg3, arg4, arg5):
"""test create_volume_from_snapshot."""
vol = self.driver.create_volume_from_snapshot(self.test_volume,
self.test_snapshot)
self.assertIsNotNone(vol)
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_volume_from_snapshot_error(self, arg1, arg2, arg3, arg4,
arg5):
"""test create_volume_from_snapshot."""
self.assertRaises(exception.HBSDError,
self.driver.create_volume_from_snapshot,
self.test_volume_error5, self.test_snapshot_error2)
return
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume',
return_value=_VOLUME)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_cloned_volume(self, arg1, arg2, arg3, arg4, arg5, arg6):
"""test create_cloned_volume."""
vol = self.driver.create_cloned_volume(self.test_volume,
self._VOLUME)
self.assertEqual('1', vol['provider_location'])
return
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume',
return_value=_VOLUME)
@mock.patch.object(hbsd_common.HBSDCommon, 'extend_volume')
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_cloned_volume_larger_size(self, arg1, arg2, arg3, arg4,
arg5, arg6, arg7):
"""test create_cloned_volume."""
vol = self.driver.create_cloned_volume(self.test_volume_larger,
self._VOLUME)
self.assertEqual('1', vol['provider_location'])
arg5.assert_called_once_with(self.test_volume_larger,
self.test_volume_larger['size'])
return
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume_metadata',
return_value={'dummy_volume_meta': 'meta'})
@mock.patch.object(hbsd_common.HBSDCommon, 'get_volume',
return_value=_VOLUME)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
def test_create_cloned_volume_error(self, arg1, arg2, arg3, arg4, arg5,
arg6):
"""test create_cloned_volume."""
self.assertRaises(exception.HBSDCmdError,
self.driver.create_cloned_volume,
self.test_volume, self.test_volume_error2)
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_initialize_connection(self, arg1, arg2):
"""test initialize connection."""
connector = {'wwpns': ['12345678912345aa', '12345678912345bb'],
'ip': '127.0.0.1'}
rc = self.driver.initialize_connection(self._VOLUME, connector)
self.assertEqual('fibre_channel', rc['driver_volume_type'])
self.assertEqual(['50060E801053C2E0'], rc['data']['target_wwn'])
self.assertEqual(0, rc['data']['target_lun'])
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_initialize_connection_error(self, arg1, arg2):
"""test initialize connection."""
connector = {'wwpns': ['12345678912345bb'], 'ip': '127.0.0.2'}
self.assertRaises(exception.HBSDError,
self.driver.initialize_connection,
self._VOLUME, connector)
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_terminate_connection(self, arg1, arg2):
"""test terminate connection."""
connector = {'wwpns': ['12345678912345aa', '12345678912345bb'],
'ip': '127.0.0.1'}
rc = self.driver.terminate_connection(self._VOLUME, connector)
self.assertEqual('fibre_channel', rc['driver_volume_type'])
self.assertEqual(['50060E801053C2E0'], rc['data']['target_wwn'])
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_terminate_connection_error(self, arg1, arg2):
"""test terminate connection."""
connector = {'ip': '127.0.0.1'}
self.assertRaises(exception.HBSDError,
self.driver.terminate_connection,
self._VOLUME, connector)
return
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_manage_existing(self, arg1, arg2):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
rc = self.driver.manage_existing(self._VOLUME, self.test_existing_ref)
self.assertEqual(1, rc['provider_location'])
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
size = self.driver.manage_existing_get_size(self._VOLUME,
self.test_existing_ref)
self.assertEqual(1, size)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_none_ldev_ref(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_none_ldev_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_invalid_ldev_ref(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_invalid_ldev_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_no_ldev_ref(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_no_ldev_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_none_serial_ref(self, arg1, arg2,
arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_none_serial_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_invalid_serial_ref(self, arg1, arg2,
arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_invalid_serial_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_no_serial_ref(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_no_serial_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'start_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'check_horcm',
return_value=[0, "", ""])
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_unmanage(self, arg1, arg2, arg3, arg4):
self.driver.unmanage(self._VOLUME)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom)
def test_unmanage_busy(self, arg1, arg2):
self.assertRaises(exception.HBSDVolumeIsBusy,
self.driver.unmanage, self.test_volume_error3)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_no_stdout)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_no_stdout(self, arg1, arg2,
arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_no_nml)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_no_nml(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_no_open_v)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_no_open_v(self, arg1, arg2,
arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_no_hdp)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_no_hdp(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_pair)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_pair(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_permit)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_permit(self, arg1, arg2, arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_invalid_size)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_invalid_size(self, arg1, arg2,
arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
@mock.patch.object(hbsd_basiclib, 'get_process_lock')
@mock.patch.object(hbsd_horcm.HBSDHORCM, 'exec_raidcom',
side_effect=_exec_raidcom_get_ldev_num_port)
@mock.patch.object(hbsd_common.HBSDCommon, '_update_volume_metadata')
def test_manage_existing_get_size_get_ldev_num_port(self, arg1, arg2,
arg3):
self.configuration.hitachi_serial_number = self.SERIAL_NUM
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size, self._VOLUME,
self.test_existing_ref)
def test_invalid_resource_lock_timeout_below_limit(self):
self.configuration.hitachi_horcm_resource_lock_timeout = -1
self.assertRaises(exception.HBSDError, self.driver.check_param)
def test_invalid_resource_lock_timeout_over_limit(self):
self.configuration.hitachi_horcm_resource_lock_timeout = 7201
self.assertRaises(exception.HBSDError, self.driver.check_param)
View Git Blame Copy Permalink