# Copyright (c) 2014 ProphetStor, 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.

import errno
import httplib
import re

import mock

from cinder import exception
from cinder.openstack.common import units
from cinder import test
from cinder.volume import configuration as conf
from cinder.volume.drivers.prophetstor import dpl_iscsi as DPLDRIVER
from cinder.volume.drivers.prophetstor import dplcommon as DPLCOMMON

POOLUUID = 'ac33fc6e417440d5a1ef27d7231e1cc4'
VOLUMEUUID = 'a000000000000000000000000000001'
INITIATOR = 'iqn.2013-08.org.debian:01:aaaaaaaa'
DATA_IN_VOLUME = {'id': VOLUMEUUID}
DATA_IN_CONNECTOR = {'initiator': INITIATOR}
## dpl.getpool
DATA_SERVER_INFO = 0, {
    'metadata': {'vendor': 'ProphetStor',
                 'version': '1.5'}}

DATA_POOLINFO = 0, {
    'capabilitiesURI': '',
    'children': [],
    'childrenrange': '',
    'completionStatus': 'Complete',
    'metadata': {'available_capacity': 4194074624,
                 'ctime': 1390551362349,
                 'vendor': 'prophetstor',
                 'version': '1.5',
                 'display_description': 'Default Pool',
                 'display_name': 'default_pool',
                 'event_uuid': '4f7c4d679a664857afa4d51f282a516a',
                 'physical_device': {'cache': [],
                                     'data': ['disk_uuid_0',
                                              'disk_uuid_1',
                                              'disk_uuid_2'],
                                     'log': [],
                                     'spare': []},
                 'pool_uuid': POOLUUID,
                 'properties': {'raid_level': 'raid0'},
                 'state': 'Online',
                 'total_capacity': 4194828288,
                 'zpool_guid': '8173612007304181810'},
    'objectType': 'application/cdmi-container',
    'percentComplete': 100}

## dpl.assignvdev
DATA_ASSIGNVDEV = 0, {
    'children': [],
    'childrenrange': '',
    'completionStatus': 'Complete',
    'domainURI': '',
    'exports': {'Network/iSCSI': [
                {'logical_unit_name': '',
                 'logical_unit_number': '101',
                 'permissions': [INITIATOR],
                 'portals': ['172.31.1.210:3260'],
                 'target_identifier':
                 'iqn.2013-09.com.prophetstor:hypervisor.886423051816'
                 }]},
    'metadata': {'ctime': 0,
                 'event_uuid': 'c11e90287e9348d0b4889695f1ec4be5',
                 'type': 'volume'},
    'objectID': '',
    'objectName': 'd827e23d403f4f12bb208a6fec208fd8',
    'objectType': 'application/cdmi-container',
    'parentID': '8daa374670af447e8efea27e16bf84cd',
    'parentURI': '/dpl_volume',
    'snapshots': []
}

DATA_OUTPUT = 0, None

MOD_OUTPUT = {'status': 'available'}

DATA_IN_GROUP = {'id': 'fe2dbc51-5810-451d-ab2f-8c8a48d15bee',
                 'name': 'group123',
                 'description': 'des123',
                 'status': ''}

DATA_IN_VOLUME = {'id': 'abc123',
                  'display_name': 'abc123',
                  'display_description': '',
                  'size': 1}

DATA_IN_VOLUME_VG = {'id': 'abc123',
                     'display_name': 'abc123',
                     'display_description': '',
                     'size': 1,
                     'consistencygroup_id':
                         'fe2dbc51-5810-451d-ab2f-8c8a48d15bee',
                     'status': 'available'}

DATA_IN_VOLUME1 = {'id': 'abc456',
                   'display_name': 'abc456',
                   'display_description': '',
                   'size': 1}

DATA_IN_CG_SNAPSHOT = {
    'consistencygroup_id': 'fe2dbc51-5810-451d-ab2f-8c8a48d15bee',
    'id': 'cgsnapshot1',
    'name': 'cgsnapshot1',
    'description': 'cgsnapshot1',
    'status': ''}

DATA_IN_SNAPSHOT = {'id': 'snapshot1',
                    'volume_id': 'abc123',
                    'display_name': 'snapshot1',
                    'display_description': ''}

DATA_OUT_SNAPSHOT_CG = {
    'id': 'snapshot1',
    'volume_id': 'abc123',
    'display_name': 'snapshot1',
    'display_description': '',
    'cgsnapshot_id': 'fe2dbc51-5810-451d-ab2f-8c8a48d15bee'}


class TestProphetStorDPLVolume(test.TestCase):

    def _gen_snapshot_url(self, vdevid, snapshotid):
        snapshot_url = '/%s/%s/%s' % (vdevid, DPLCOMMON.DPL_OBJ_SNAPSHOT,
                                      snapshotid)
        return snapshot_url

    def setUp(self):
        super(TestProphetStorDPLVolume, self).setUp()
        self.dplcmd = DPLCOMMON.DPLVolume('1.1.1.1', 8356, 'admin', 'password')
        self.DPL_MOCK = mock.MagicMock()
        self.dplcmd.objCmd = self.DPL_MOCK
        self.DPL_MOCK.send_cmd.return_value = DATA_OUTPUT

    def test_getserverinfo(self):
        self.dplcmd.get_server_info()
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'GET',
            '/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_SYSTEM),
            None,
            [httplib.OK, httplib.ACCEPTED])

    def test_createvdev(self):
        self.dplcmd.create_vdev(DATA_IN_VOLUME['id'],
                                DATA_IN_VOLUME['display_name'],
                                DATA_IN_VOLUME['display_description'],
                                POOLUUID,
                                int(DATA_IN_VOLUME['size']) * units.Gi)

        metadata = {}
        metadata['display_name'] = DATA_IN_VOLUME['display_name']
        metadata['display_description'] = DATA_IN_VOLUME['display_description']
        metadata['pool_uuid'] = POOLUUID
        metadata['total_capacity'] = int(DATA_IN_VOLUME['size']) * units.Gi
        metadata['maximum_snapshot'] = 1024
        metadata['properties'] = dict(thin_provision=True)
        params = {}
        params['metadata'] = metadata
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.ACCEPTED, httplib.CREATED])

    def test_extendvdev(self):
        self.dplcmd.extend_vdev(DATA_IN_VOLUME['id'],
                                DATA_IN_VOLUME['display_name'],
                                DATA_IN_VOLUME['display_description'],
                                int(DATA_IN_VOLUME['size']) * units.Gi)
        metadata = {}
        metadata['display_name'] = DATA_IN_VOLUME['display_name']
        metadata['display_description'] = DATA_IN_VOLUME['display_description']
        metadata['total_capacity'] = int(DATA_IN_VOLUME['size']) * units.Gi
        metadata['maximum_snapshot'] = 1024
        params = {}
        params['metadata'] = metadata
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.ACCEPTED, httplib.CREATED])

    def test_deletevdev(self):
        self.dplcmd.delete_vdev(DATA_IN_VOLUME['id'], True)
        metadata = {}
        params = {}
        metadata['force'] = True
        params['metadata'] = metadata
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'DELETE',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.ACCEPTED, httplib.NOT_FOUND,
             httplib.NO_CONTENT])

    def test_createvdevfromsnapshot(self):
        self.dplcmd.create_vdev_from_snapshot(
            DATA_IN_VOLUME['id'],
            DATA_IN_VOLUME['display_name'],
            DATA_IN_VOLUME['display_description'],
            DATA_IN_SNAPSHOT['id'],
            POOLUUID)
        metadata = {}
        params = {}
        metadata['snapshot_operation'] = 'copy'
        metadata['display_name'] = DATA_IN_VOLUME['display_name']
        metadata['display_description'] = DATA_IN_VOLUME['display_description']
        metadata['pool_uuid'] = POOLUUID
        metadata['maximum_snapshot'] = 1024
        metadata['properties'] = dict(thin_provision=True)
        params['metadata'] = metadata
        params['copy'] = self._gen_snapshot_url(DATA_IN_VOLUME['id'],
                                                DATA_IN_SNAPSHOT['id'])
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.ACCEPTED, httplib.CREATED])

    def test_getpool(self):
        self.dplcmd.get_pool(POOLUUID)
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'GET',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_POOL,
                            POOLUUID),
            None,
            [httplib.OK, httplib.ACCEPTED])

    def test_clonevdev(self):
        self.dplcmd.clone_vdev(
            DATA_IN_VOLUME['id'],
            DATA_IN_VOLUME1['id'],
            POOLUUID,
            DATA_IN_VOLUME['display_name'],
            DATA_IN_VOLUME['display_description'],
            int(DATA_IN_VOLUME['size']) * units.Gi
        )
        metadata = {}
        params = {}
        metadata["snapshot_operation"] = "clone"
        metadata["display_name"] = DATA_IN_VOLUME['display_name']
        metadata["display_description"] = DATA_IN_VOLUME['display_description']
        metadata["pool_uuid"] = POOLUUID
        metadata["total_capacity"] = int(DATA_IN_VOLUME['size']) * units.Gi
        metadata['maximum_snapshot'] = 1024
        metadata['properties'] = dict(thin_provision=True)
        params["metadata"] = metadata
        params["copy"] = DATA_IN_VOLUME['id']

        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME1['id']),
            params,
            [httplib.OK, httplib.CREATED, httplib.ACCEPTED])

    def test_createvdevsnapshot(self):
        self.dplcmd.create_vdev_snapshot(
            DATA_IN_VOLUME['id'],
            DATA_IN_SNAPSHOT['id'],
            DATA_IN_SNAPSHOT['display_name'],
            DATA_IN_SNAPSHOT['display_description']
        )
        metadata = {}
        params = {}
        metadata['display_name'] = DATA_IN_SNAPSHOT['display_name']
        metadata['display_description'] = \
            DATA_IN_SNAPSHOT['display_description']
        params['metadata'] = metadata
        params['snapshot'] = DATA_IN_SNAPSHOT['id']

        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.CREATED, httplib.ACCEPTED])

    def test_getvdev(self):
        self.dplcmd.get_vdev(DATA_IN_VOLUME['id'])
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'GET',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1, DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            None,
            [httplib.OK, httplib.ACCEPTED, httplib.NOT_FOUND])

    def test_getvdevstatus(self):
        self.dplcmd.get_vdev_status(DATA_IN_VOLUME['id'], '123456')
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'GET',
            '/%s/%s/%s/?event_uuid=%s' % (DPLCOMMON.DPL_VER_V1,
                                          DPLCOMMON.DPL_OBJ_VOLUME,
                                          DATA_IN_VOLUME['id'],
                                          '123456'),
            None,
            [httplib.OK, httplib.NOT_FOUND])

    def test_getpoolstatus(self):
        self.dplcmd.get_pool_status(POOLUUID, '123456')
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'GET',
            '/%s/%s/%s/?event_uuid=%s' % (DPLCOMMON.DPL_VER_V1,
                                          DPLCOMMON.DPL_OBJ_POOL,
                                          POOLUUID,
                                          '123456'),
            None,
            [httplib.OK, httplib.NOT_FOUND])

    def test_assignvdev(self):
        self.dplcmd.assign_vdev(
            DATA_IN_VOLUME['id'],
            'iqn.1993-08.org.debian:01:test1',
            '',
            '1.1.1.1:3260',
            0
        )
        params = {}
        metadata = {}
        exports = {}
        metadata['export_operation'] = 'assign'
        exports['Network/iSCSI'] = {}
        target_info = {}
        target_info['logical_unit_number'] = 0
        target_info['logical_unit_name'] = ''
        permissions = []
        portals = []
        portals.append('1.1.1.1:3260')
        permissions.append('iqn.1993-08.org.debian:01:test1')
        target_info['permissions'] = permissions
        target_info['portals'] = portals
        exports['Network/iSCSI'] = target_info

        params['metadata'] = metadata
        params['exports'] = exports
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1,
                            DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.ACCEPTED, httplib.CREATED])

    def test_unassignvdev(self):
        self.dplcmd.unassign_vdev(DATA_IN_VOLUME['id'],
                                  'iqn.1993-08.org.debian:01:test1',
                                  '')
        params = {}
        metadata = {}
        exports = {}
        metadata['export_operation'] = 'unassign'
        params['metadata'] = metadata

        exports['Network/iSCSI'] = {}
        exports['Network/iSCSI']['target_identifier'] = ''
        permissions = []
        permissions.append('iqn.1993-08.org.debian:01:test1')
        exports['Network/iSCSI']['permissions'] = permissions

        params['exports'] = exports
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'PUT',
            '/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1,
                            DPLCOMMON.DPL_OBJ_VOLUME,
                            DATA_IN_VOLUME['id']),
            params,
            [httplib.OK, httplib.ACCEPTED,
             httplib.NO_CONTENT, httplib.NOT_FOUND])

    def test_deletevdevsnapshot(self):
        self.dplcmd.delete_vdev_snapshot(DATA_IN_VOLUME['id'],
                                         DATA_IN_SNAPSHOT['id'])
        params = {}
        params['copy'] = self._gen_snapshot_url(DATA_IN_VOLUME['id'],
                                                DATA_IN_SNAPSHOT['id'])
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'DELETE',
            '/%s/%s/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1,
                                  DPLCOMMON.DPL_OBJ_VOLUME,
                                  DATA_IN_VOLUME['id'],
                                  DPLCOMMON.DPL_OBJ_SNAPSHOT,
                                  DATA_IN_SNAPSHOT['id']),
            None,
            [httplib.OK, httplib.ACCEPTED, httplib.NO_CONTENT,
             httplib.NOT_FOUND])

    def test_listvdevsnapshots(self):
        self.dplcmd.list_vdev_snapshots(DATA_IN_VOLUME['id'])
        self.DPL_MOCK.send_cmd.assert_called_once_with(
            'GET',
            '/%s/%s/%s/%s/' % (DPLCOMMON.DPL_VER_V1,
                               DPLCOMMON.DPL_OBJ_VOLUME,
                               DATA_IN_VOLUME['id'],
                               DPLCOMMON.DPL_OBJ_SNAPSHOT),
            None,
            [httplib.OK])


class TestProphetStorDPLDriver(test.TestCase):

    def __init__(self, method):
        super(TestProphetStorDPLDriver, self).__init__(method)

    def _conver_uuid2hex(self, strID):
        return strID.replace('-', '')

    def setUp(self):
        super(TestProphetStorDPLDriver, self).setUp()
        self.configuration = mock.Mock(conf.Configuration)
        self.configuration.san_ip = '1.1.1.1'
        self.configuration.dpl_port = 8356
        self.configuration.san_login = 'admin'
        self.configuration.san_password = 'password'
        self.configuration.dpl_pool = POOLUUID
        self.configuration.iscsi_port = 3260
        self.configuration.san_is_local = False
        self.configuration.san_thin_provision = True
        self.context = ''
        self.DPL_MOCK = mock.MagicMock()
        self.DB_MOCK = mock.MagicMock()
        self.dpldriver = DPLDRIVER.DPLISCSIDriver(
            configuration=self.configuration)
        self.dpldriver.dpl = self.DPL_MOCK
        self.dpldriver.db = self.DB_MOCK
        self.dpldriver.do_setup(self.context)

    def test_get_volume_stats(self):
        self.DPL_MOCK.get_pool.return_value = DATA_POOLINFO
        self.DPL_MOCK.get_server_info.return_value = DATA_SERVER_INFO
        res = self.dpldriver.get_volume_stats(True)
        self.assertEqual(res['vendor_name'], 'ProphetStor')
        self.assertEqual(res['driver_version'], '1.5')
        self.assertEqual(res['total_capacity_gb'], 3.91)
        self.assertEqual(res['free_capacity_gb'], 3.91)
        self.assertEqual(res['reserved_percentage'], 0)
        self.assertEqual(res['QoS_support'], False)

    def test_create_volume(self):
        self.DPL_MOCK.create_vdev.return_value = DATA_OUTPUT
        self.dpldriver.create_volume(DATA_IN_VOLUME)
        self.DPL_MOCK.create_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']),
            DATA_IN_VOLUME['display_name'],
            DATA_IN_VOLUME['display_description'],
            self.configuration.dpl_pool,
            int(DATA_IN_VOLUME['size']) * units.Gi,
            True)

    def test_create_volume_of_group(self):
        self.DPL_MOCK.create_vdev.return_value = DATA_OUTPUT
        self.DPL_MOCK.join_vg.return_value = DATA_OUTPUT
        self.dpldriver.create_volume(DATA_IN_VOLUME_VG)
        self.DPL_MOCK.create_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']),
            DATA_IN_VOLUME['display_name'],
            DATA_IN_VOLUME['display_description'],
            self.configuration.dpl_pool,
            int(DATA_IN_VOLUME['size']) * units.Gi,
            True)
        self.DPL_MOCK.join_vg.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME_VG['id']),
            self._conver_uuid2hex(
                DATA_IN_VOLUME_VG['consistencygroup_id']))

    def test_delete_volume(self):
        self.DPL_MOCK.delete_vdev.return_value = DATA_OUTPUT
        self.dpldriver.delete_volume(DATA_IN_VOLUME)
        self.DPL_MOCK.delete_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']))

    def test_delete_volume_of_group(self):
        self.DPL_MOCK.delete_vdev.return_value = DATA_OUTPUT
        self.DPL_MOCK.leave_vg.return_volume = DATA_OUTPUT
        self.dpldriver.delete_volume(DATA_IN_VOLUME_VG)
        self.DPL_MOCK.leave_vg.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME_VG['id']),
            self._conver_uuid2hex(DATA_IN_GROUP['id'])
        )
        self.DPL_MOCK.delete_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']))

    def test_create_volume_from_snapshot(self):
        self.DPL_MOCK.create_vdev_from_snapshot.return_value = DATA_OUTPUT
        self.dpldriver.create_volume_from_snapshot(DATA_IN_VOLUME,
                                                   DATA_IN_SNAPSHOT)
        self.DPL_MOCK.create_vdev_from_snapshot.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']),
            DATA_IN_VOLUME['display_name'],
            DATA_IN_VOLUME['display_description'],
            self._conver_uuid2hex(DATA_IN_SNAPSHOT['id']),
            self.configuration.dpl_pool,
            True)

    def test_create_cloned_volume(self):
        self.DPL_MOCK.clone_vdev.return_value = DATA_OUTPUT
        self.dpldriver.create_cloned_volume(DATA_IN_VOLUME1, DATA_IN_VOLUME)
        self.DPL_MOCK.clone_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']),
            self._conver_uuid2hex(DATA_IN_VOLUME1['id']),
            self.configuration.dpl_pool,
            DATA_IN_VOLUME1['display_name'],
            DATA_IN_VOLUME1['display_description'],
            int(DATA_IN_VOLUME1['size']) *
            units.Gi,
            True)

    def test_create_snapshot(self):
        self.DPL_MOCK.create_vdev_snapshot.return_value = DATA_OUTPUT
        self.dpldriver.create_snapshot(DATA_IN_SNAPSHOT)
        self.DPL_MOCK.create_vdev_snapshot.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_SNAPSHOT['volume_id']),
            self._conver_uuid2hex(DATA_IN_SNAPSHOT['id']),
            DATA_IN_SNAPSHOT['display_name'],
            DATA_IN_SNAPSHOT['display_description'])

    def test_delete_snapshot(self):
        self.DPL_MOCK.delete_vdev_snapshot.return_value = DATA_OUTPUT
        self.dpldriver.delete_snapshot(DATA_IN_SNAPSHOT)
        self.DPL_MOCK.delete_vdev_snapshot.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_SNAPSHOT['volume_id']),
            self._conver_uuid2hex(DATA_IN_SNAPSHOT['id']))

    def test_initialize_connection(self):
        self.DPL_MOCK.assign_vdev.return_value = DATA_ASSIGNVDEV
        self.DPL_MOCK.get_vdev.return_value = DATA_ASSIGNVDEV
        res = self.dpldriver.initialize_connection(DATA_IN_VOLUME,
                                                   DATA_IN_CONNECTOR)
        self.assertEqual(res['driver_volume_type'], 'iscsi')
        self.assertEqual(res['data']['target_lun'], '101')
        self.assertEqual(res['data']['target_discovered'], True)
        self.assertEqual(res['data']['target_portal'], '172.31.1.210:3260')
        self.assertEqual(res['data']['target_iqn'], 'iqn.2013-09.com.'
                                                    'prophetstor:hypervisor.'
                                                    '886423051816')

    def test_terminate_connection(self):
        self.DPL_MOCK.unassign_vdev.return_value = DATA_OUTPUT
        self.dpldriver.terminate_connection(DATA_IN_VOLUME, DATA_IN_CONNECTOR)
        self.DPL_MOCK.unassign_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']),
            DATA_IN_CONNECTOR['initiator'])

    def test_terminate_connection_volume_detached(self):
        self.DPL_MOCK.unassign_vdev.return_value = errno.ENODATA, None
        self.dpldriver.terminate_connection(DATA_IN_VOLUME, DATA_IN_CONNECTOR)
        self.DPL_MOCK.unassign_vdev.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_VOLUME['id']),
            DATA_IN_CONNECTOR['initiator'])

    def test_terminate_connection_failed(self):
        self.DPL_MOCK.unassign_vdev.return_value = errno.EFAULT, None
        ex = self.assertRaises(
            exception.VolumeBackendAPIException,
            self.dpldriver.terminate_connection,
            volume=DATA_IN_VOLUME, connector=DATA_IN_CONNECTOR)
        self.assertTrue(
            re.match(r".*Flexvisor failed", ex.msg))

    def test_get_pool_info(self):
        self.DPL_MOCK.get_pool.return_value = DATA_POOLINFO
        _, res = self.dpldriver._get_pool_info(POOLUUID)
        self.assertEqual(res['metadata']['available_capacity'], 4194074624)
        self.assertEqual(res['metadata']['ctime'], 1390551362349)
        self.assertEqual(res['metadata']['display_description'],
                         'Default Pool')
        self.assertEqual(res['metadata']['display_name'],
                         'default_pool')
        self.assertEqual(res['metadata']['event_uuid'],
                         '4f7c4d679a664857afa4d51f282a516a')
        self.assertEqual(res['metadata']['physical_device'], {
                         'cache': [],
                         'data': ['disk_uuid_0', 'disk_uuid_1', 'disk_uuid_2'],
                         'log': [],
                         'spare': []})
        self.assertEqual(res['metadata']['pool_uuid'], POOLUUID)
        self.assertEqual(res['metadata']['properties'], {
                         'raid_level': 'raid0'})
        self.assertEqual(res['metadata']['state'], 'Online')
        self.assertEqual(res['metadata']['total_capacity'], 4194828288)
        self.assertEqual(res['metadata']['zpool_guid'], '8173612007304181810')

    def test_create_consistency_group(self):
        self.DPL_MOCK.create_vg.return_value = DATA_OUTPUT
        model_update = self.dpldriver.create_consistencygroup(self.context,
                                                              DATA_IN_GROUP)
        self.DPL_MOCK.create_vg.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_GROUP['id']), DATA_IN_GROUP['name'],
            DATA_IN_GROUP['description'])
        self.assertDictMatch({'status': 'available'}, model_update)

    def test_delete_consistency_group(self):
        self.DB_MOCK.volume_get_all_by_group.return_value = \
            [DATA_IN_VOLUME_VG]
        self.DPL_MOCK.delete_vdev.return_value = DATA_OUTPUT
        self.DPL_MOCK.delete_cg.return_value = DATA_OUTPUT
        model_update, volumes = self.dpldriver.delete_consistencygroup(
            self.context, DATA_IN_GROUP)
        self.DPL_MOCK.delete_vg.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_GROUP['id']))
        self.DPL_MOCK.delete_vdev.assert_called_once_with(
            self._conver_uuid2hex((DATA_IN_VOLUME_VG['id'])))
        self.assertDictMatch({'status': 'deleted'}, model_update, )

    def test_create_consistency_group_snapshot(self):
        self.DB_MOCK.snapshot_get_all_for_cgsnapshot.return_value = \
            [DATA_OUT_SNAPSHOT_CG]
        self.DPL_MOCK.create_vdev_snapshot.return_value = DATA_OUTPUT
        model_update, snapshots = self.dpldriver.create_cgsnapshot(
            self.context, DATA_IN_CG_SNAPSHOT)
        self.assertDictMatch({'status': 'available'}, model_update)

    def test_delete_consistency_group_snapshot(self):
        self.DB_MOCK.snapshot_get_all_for_cgsnapshot.return_value = \
            [DATA_OUT_SNAPSHOT_CG]
        self.DPL_MOCK.delete_cgsnapshot.return_value = DATA_OUTPUT
        model_update, snapshots = self.dpldriver.delete_cgsnapshot(
            self.context, DATA_IN_CG_SNAPSHOT)
        self.DPL_MOCK.delete_vdev_snapshot.assert_called_once_with(
            self._conver_uuid2hex(DATA_IN_CG_SNAPSHOT['consistencygroup_id']),
            self._conver_uuid2hex(DATA_IN_CG_SNAPSHOT['id']),
            True)
        self.assertDictMatch({'status': 'deleted'}, model_update)
