# 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)
