9191 lines
419 KiB
Python
9191 lines
419 KiB
Python
# Copyright (c) 2015 Dell Inc.
|
|
#
|
|
# 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 ddt
|
|
import eventlet
|
|
import json
|
|
import mock
|
|
import requests
|
|
from requests import models
|
|
import uuid
|
|
|
|
from cinder import context
|
|
from cinder import exception
|
|
from cinder import test
|
|
from cinder.tests.unit import fake_constants as fake
|
|
from cinder.volume.drivers.dell_emc.sc import storagecenter_api
|
|
|
|
|
|
# We patch these here as they are used by every test to keep
|
|
# from trying to contact a Dell Storage Center.
|
|
@ddt.ddt
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'__init__',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'open_connection')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'close_connection')
|
|
class DellSCSanAPITestCase(test.TestCase):
|
|
|
|
"""DellSCSanAPITestCase
|
|
|
|
Class to test the Storage Center API using Mock.
|
|
"""
|
|
|
|
SC = {u'IPv6ManagementIPPrefix': 128,
|
|
u'connectionError': u'',
|
|
u'instanceId': u'64702',
|
|
u'scSerialNumber': 64702,
|
|
u'dataProgressionRunning': False,
|
|
u'hostOrIpAddress': u'192.168.0.80',
|
|
u'userConnected': True,
|
|
u'portsBalanced': True,
|
|
u'managementIp': u'192.168.0.80',
|
|
u'version': u'6.5.1.269',
|
|
u'location': u'',
|
|
u'objectType': u'StorageCenter',
|
|
u'instanceName': u'Storage Center 64702',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'flashOptimizedConfigured': False,
|
|
u'connected': True,
|
|
u'operationMode': u'Normal',
|
|
u'userName': u'Admin',
|
|
u'nonFlashOptimizedConfigured': True,
|
|
u'name': u'Storage Center 64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'serialNumber': 64702,
|
|
u'raidRebalanceRunning': False,
|
|
u'userPasswordExpired': False,
|
|
u'contact': u'',
|
|
u'IPv6ManagementIP': u'::'}
|
|
|
|
VOLUME = {u'instanceId': u'64702.3494',
|
|
u'scSerialNumber': 64702,
|
|
u'replicationSource': False,
|
|
u'liveVolume': False,
|
|
u'vpdId': 3496,
|
|
u'objectType': u'ScVolume',
|
|
u'index': 3494,
|
|
u'volumeFolderPath': u'devstackvol/fcvm/',
|
|
u'hostCacheEnabled': False,
|
|
u'usedByLegacyFluidFsNasVolume': False,
|
|
u'inRecycleBin': False,
|
|
u'volumeFolderIndex': 17,
|
|
u'instanceName': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'storageType': {u'instanceId': u'64702.1',
|
|
u'instanceName': u'Assigned - Redundant - 2 MB',
|
|
u'objectType': u'ScStorageType'},
|
|
u'cmmDestination': False,
|
|
u'replicationDestination': False,
|
|
u'volumeFolder': {u'instanceId': u'64702.17',
|
|
u'instanceName': u'fcvm',
|
|
u'objectType': u'ScVolumeFolder'},
|
|
u'deviceId': u'6000d31000fcbe000000000000000da8',
|
|
u'active': True,
|
|
u'portableVolumeDestination': False,
|
|
u'deleteAllowed': True,
|
|
u'name': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'scName': u'Storage Center 64702',
|
|
u'secureDataUsed': False,
|
|
u'serialNumber': u'0000fcbe-00000da8',
|
|
u'replayAllowed': True,
|
|
u'flashOptimized': False,
|
|
u'configuredSize': u'1.073741824E9 Bytes',
|
|
u'mapped': False,
|
|
u'cmmSource': False}
|
|
|
|
VOLUME_LIST = [{u'instanceId': u'64702.3494',
|
|
u'scSerialNumber': 64702,
|
|
u'replicationSource': False,
|
|
u'liveVolume': False,
|
|
u'vpdId': 3496,
|
|
u'objectType': u'ScVolume',
|
|
u'index': 3494,
|
|
u'volumeFolderPath': u'devstackvol/fcvm/',
|
|
u'hostCacheEnabled': False,
|
|
u'usedByLegacyFluidFsNasVolume': False,
|
|
u'inRecycleBin': False,
|
|
u'volumeFolderIndex': 17,
|
|
u'instanceName':
|
|
u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'storageType': {u'instanceId': u'64702.1',
|
|
u'instanceName':
|
|
u'Assigned - Redundant - 2 MB',
|
|
u'objectType': u'ScStorageType'},
|
|
u'cmmDestination': False,
|
|
u'replicationDestination': False,
|
|
u'volumeFolder': {u'instanceId': u'64702.17',
|
|
u'instanceName': u'fcvm',
|
|
u'objectType': u'ScVolumeFolder'},
|
|
u'deviceId': u'6000d31000fcbe000000000000000da8',
|
|
u'active': True,
|
|
u'portableVolumeDestination': False,
|
|
u'deleteAllowed': True,
|
|
u'name': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'scName': u'Storage Center 64702',
|
|
u'secureDataUsed': False,
|
|
u'serialNumber': u'0000fcbe-00000da8',
|
|
u'replayAllowed': True,
|
|
u'flashOptimized': False,
|
|
u'configuredSize': u'1.073741824E9 Bytes',
|
|
u'mapped': False,
|
|
u'cmmSource': False}]
|
|
|
|
# Volume list that contains multiple volumes
|
|
VOLUME_LIST_MULTI_VOLS = [
|
|
{u'instanceId': u'64702.3494',
|
|
u'scSerialNumber': 64702,
|
|
u'replicationSource': False,
|
|
u'liveVolume': False,
|
|
u'vpdId': 3496,
|
|
u'objectType': u'ScVolume',
|
|
u'index': 3494,
|
|
u'volumeFolderPath': u'devstackvol/fcvm/',
|
|
u'hostCacheEnabled': False,
|
|
u'usedByLegacyFluidFsNasVolume': False,
|
|
u'inRecycleBin': False,
|
|
u'volumeFolderIndex': 17,
|
|
u'instanceName':
|
|
u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'storageType': {u'instanceId': u'64702.1',
|
|
u'instanceName':
|
|
u'Assigned - Redundant - 2 MB',
|
|
u'objectType': u'ScStorageType'},
|
|
u'cmmDestination': False,
|
|
u'replicationDestination': False,
|
|
u'volumeFolder': {u'instanceId': u'64702.17',
|
|
u'instanceName': u'fcvm',
|
|
u'objectType': u'ScVolumeFolder'},
|
|
u'deviceId': u'6000d31000fcbe000000000000000da8',
|
|
u'active': True,
|
|
u'portableVolumeDestination': False,
|
|
u'deleteAllowed': True,
|
|
u'name': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'scName': u'Storage Center 64702',
|
|
u'secureDataUsed': False,
|
|
u'serialNumber': u'0000fcbe-00000da8',
|
|
u'replayAllowed': True,
|
|
u'flashOptimized': False,
|
|
u'configuredSize': u'1.073741824E9 Bytes',
|
|
u'mapped': False,
|
|
u'cmmSource': False},
|
|
{u'instanceId': u'64702.3495',
|
|
u'scSerialNumber': 64702,
|
|
u'replicationSource': False,
|
|
u'liveVolume': False,
|
|
u'vpdId': 3496,
|
|
u'objectType': u'ScVolume',
|
|
u'index': 3495,
|
|
u'volumeFolderPath': u'devstackvol/fcvm/',
|
|
u'hostCacheEnabled': False,
|
|
u'usedByLegacyFluidFsNasVolume': False,
|
|
u'inRecycleBin': False,
|
|
u'volumeFolderIndex': 17,
|
|
u'instanceName':
|
|
u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'storageType': {u'instanceId': u'64702.1',
|
|
u'instanceName':
|
|
u'Assigned - Redundant - 2 MB',
|
|
u'objectType': u'ScStorageType'},
|
|
u'cmmDestination': False,
|
|
u'replicationDestination': False,
|
|
u'volumeFolder': {u'instanceId': u'64702.17',
|
|
u'instanceName': u'fcvm',
|
|
u'objectType': u'ScVolumeFolder'},
|
|
u'deviceId': u'6000d31000fcbe000000000000000da9',
|
|
u'active': True,
|
|
u'portableVolumeDestination': False,
|
|
u'deleteAllowed': True,
|
|
u'name': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'scName': u'Storage Center 64702',
|
|
u'secureDataUsed': False,
|
|
u'serialNumber': u'0000fcbe-00000da8',
|
|
u'replayAllowed': True,
|
|
u'flashOptimized': False,
|
|
u'configuredSize': u'1.073741824E9 Bytes',
|
|
u'mapped': False,
|
|
u'cmmSource': False}]
|
|
|
|
VOLUME_CONFIG = \
|
|
{u'instanceId': u'64702.3494',
|
|
u'scSerialNumber': 64702,
|
|
u'maximumSiblingCount': 100,
|
|
u'writeCacheStatus': u'Up',
|
|
u'objectType': u'ScVolumeConfiguration',
|
|
u'currentSiblingConfiguredSize': u'2.147483648E9 Bytes',
|
|
u'compressionPaused': False,
|
|
u'enforceConsumptionLimit': False,
|
|
u'volumeSpaceConsumptionLimit': u'2.147483648E9 Bytes',
|
|
u'readCacheEnabled': True,
|
|
u'writeCacheEnabled': True,
|
|
u'instanceName': u'volume-ff9589d3-2d41-48d5-9ef5-2713a875e85b',
|
|
u'dateModified': u'04/03/2015 12:01:08 AM',
|
|
u'modifyUser': u'Admin',
|
|
u'replayExpirationPaused': False,
|
|
u'currentSiblingCount': 1,
|
|
u'replayCreationPaused': False,
|
|
u'replayProfileList': [{u'instanceId': u'64702.2',
|
|
u'instanceName': u'Daily',
|
|
u'objectType': u'ScReplayProfile'}],
|
|
u'dateCreated': u'04/04/2014 03:54:26 AM',
|
|
u'volume': {u'instanceId': u'64702.3494',
|
|
u'instanceName':
|
|
u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'objectType': u'ScVolume'},
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'coalesceIntoActive': False,
|
|
u'createUser': u'Admin',
|
|
u'importToLowestTier': False,
|
|
u'readCacheStatus': u'Up',
|
|
u'maximumSiblingConfiguredSpace': u'5.49755813888E14 Bytes',
|
|
u'storageProfile': {u'instanceId': u'64702.1',
|
|
u'instanceName': u'Recommended',
|
|
u'objectType': u'ScStorageProfile'},
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'diskFolder': {u'instanceId': u'64702.3',
|
|
u'instanceName': u'Assigned',
|
|
u'objectType': u'ScDiskFolder'},
|
|
u'openVmsUniqueDiskId': 48,
|
|
u'compressionEnabled': False}
|
|
|
|
INACTIVE_VOLUME = \
|
|
{u'instanceId': u'64702.3494',
|
|
u'scSerialNumber': 64702,
|
|
u'replicationSource': False,
|
|
u'liveVolume': False,
|
|
u'vpdId': 3496,
|
|
u'objectType': u'ScVolume',
|
|
u'index': 3494,
|
|
u'volumeFolderPath': u'devstackvol/fcvm/',
|
|
u'hostCacheEnabled': False,
|
|
u'usedByLegacyFluidFsNasVolume': False,
|
|
u'inRecycleBin': False,
|
|
u'volumeFolderIndex': 17,
|
|
u'instanceName': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'storageType': {u'instanceId': u'64702.1',
|
|
u'instanceName': u'Assigned - Redundant - 2 MB',
|
|
u'objectType': u'ScStorageType'},
|
|
u'cmmDestination': False,
|
|
u'replicationDestination': False,
|
|
u'volumeFolder': {u'instanceId': u'64702.17',
|
|
u'instanceName': u'fcvm',
|
|
u'objectType': u'ScVolumeFolder'},
|
|
u'deviceId': u'6000d31000fcbe000000000000000da8',
|
|
u'active': False,
|
|
u'portableVolumeDestination': False,
|
|
u'deleteAllowed': True,
|
|
u'name': u'volume-37883deb-85cd-426a-9a98-62eaad8671ea',
|
|
u'scName': u'Storage Center 64702',
|
|
u'secureDataUsed': False,
|
|
u'serialNumber': u'0000fcbe-00000da8',
|
|
u'replayAllowed': True,
|
|
u'flashOptimized': False,
|
|
u'configuredSize': u'1.073741824E9 Bytes',
|
|
u'mapped': False,
|
|
u'cmmSource': False}
|
|
|
|
SCSERVER = {u'scName': u'Storage Center 64702',
|
|
u'volumeCount': 0,
|
|
u'removeHbasAllowed': True,
|
|
u'legacyFluidFs': False,
|
|
u'serverFolderIndex': 4,
|
|
u'alertOnConnectivity': True,
|
|
u'objectType': u'ScPhysicalServer',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'instanceId': u'64702.47',
|
|
u'serverFolderPath': u'devstacksrv/',
|
|
u'portType': [u'FibreChannel'],
|
|
u'type': u'Physical',
|
|
u'statusMessage': u'Only 5 of 6 expected paths are up',
|
|
u'status': u'Degraded',
|
|
u'scSerialNumber': 64702,
|
|
u'serverFolder': {u'instanceId': u'64702.4',
|
|
u'instanceName': u'devstacksrv',
|
|
u'objectType': u'ScServerFolder'},
|
|
u'parentIndex': 0,
|
|
u'connectivity': u'Partial',
|
|
u'hostCacheIndex': 0,
|
|
u'deleteAllowed': True,
|
|
u'pathCount': 5,
|
|
u'name': u'Server_21000024ff30441d',
|
|
u'hbaPresent': True,
|
|
u'hbaCount': 2,
|
|
u'notes': u'Created by Dell EMC Cinder Driver',
|
|
u'mapped': False,
|
|
u'operatingSystem': {u'instanceId': u'64702.38',
|
|
u'instanceName': u'Red Hat Linux 6.x',
|
|
u'objectType': u'ScServerOperatingSystem'}
|
|
}
|
|
|
|
# ScServer where deletedAllowed=False (not allowed to be deleted)
|
|
SCSERVER_NO_DEL = {u'scName': u'Storage Center 64702',
|
|
u'volumeCount': 0,
|
|
u'removeHbasAllowed': True,
|
|
u'legacyFluidFs': False,
|
|
u'serverFolderIndex': 4,
|
|
u'alertOnConnectivity': True,
|
|
u'objectType': u'ScPhysicalServer',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'instanceId': u'64702.47',
|
|
u'serverFolderPath': u'devstacksrv/',
|
|
u'portType': [u'FibreChannel'],
|
|
u'type': u'Physical',
|
|
u'statusMessage': u'Only 5 of 6 expected paths are up',
|
|
u'status': u'Degraded',
|
|
u'scSerialNumber': 64702,
|
|
u'serverFolder': {u'instanceId': u'64702.4',
|
|
u'instanceName': u'devstacksrv',
|
|
u'objectType': u'ScServerFolder'},
|
|
u'parentIndex': 0,
|
|
u'connectivity': u'Partial',
|
|
u'hostCacheIndex': 0,
|
|
u'deleteAllowed': False,
|
|
u'pathCount': 5,
|
|
u'name': u'Server_21000024ff30441d',
|
|
u'hbaPresent': True,
|
|
u'hbaCount': 2,
|
|
u'notes': u'Created by Dell EMC Cinder Driver',
|
|
u'mapped': False,
|
|
u'operatingSystem':
|
|
{u'instanceId': u'64702.38',
|
|
u'instanceName': u'Red Hat Linux 6.x',
|
|
u'objectType': u'ScServerOperatingSystem'}
|
|
}
|
|
|
|
SCSERVERS = [{u'scName': u'Storage Center 64702',
|
|
u'volumeCount': 5,
|
|
u'removeHbasAllowed': True,
|
|
u'legacyFluidFs': False,
|
|
u'serverFolderIndex': 0,
|
|
u'alertOnConnectivity': True,
|
|
u'objectType': u'ScPhysicalServer',
|
|
u'instanceName': u'openstack4',
|
|
u'instanceId': u'64702.1',
|
|
u'serverFolderPath': u'',
|
|
u'portType': [u'Iscsi'],
|
|
u'type': u'Physical',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'scSerialNumber': 64702,
|
|
u'serverFolder': {u'instanceId': u'64702.0',
|
|
u'instanceName': u'Servers',
|
|
u'objectType': u'ScServerFolder'},
|
|
u'parentIndex': 0,
|
|
u'connectivity': u'Up',
|
|
u'hostCacheIndex': 0,
|
|
u'deleteAllowed': True,
|
|
u'pathCount': 0,
|
|
u'name': u'openstack4',
|
|
u'hbaPresent': True,
|
|
u'hbaCount': 1,
|
|
u'notes': u'',
|
|
u'mapped': True,
|
|
u'operatingSystem':
|
|
{u'instanceId': u'64702.3',
|
|
u'instanceName': u'Other Multipath',
|
|
u'objectType': u'ScServerOperatingSystem'}},
|
|
{u'scName': u'Storage Center 64702',
|
|
u'volumeCount': 1,
|
|
u'removeHbasAllowed': True,
|
|
u'legacyFluidFs': False,
|
|
u'serverFolderIndex': 0,
|
|
u'alertOnConnectivity': True,
|
|
u'objectType': u'ScPhysicalServer',
|
|
u'instanceName': u'openstack5',
|
|
u'instanceId': u'64702.2',
|
|
u'serverFolderPath': u'',
|
|
u'portType': [u'Iscsi'],
|
|
u'type': u'Physical',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'scSerialNumber': 64702,
|
|
u'serverFolder': {u'instanceId': u'64702.0',
|
|
u'instanceName': u'Servers',
|
|
u'objectType': u'ScServerFolder'},
|
|
u'parentIndex': 0,
|
|
u'connectivity': u'Up',
|
|
u'hostCacheIndex': 0,
|
|
u'deleteAllowed': True,
|
|
u'pathCount': 0, u'name': u'openstack5',
|
|
u'hbaPresent': True,
|
|
u'hbaCount': 1,
|
|
u'notes': u'',
|
|
u'mapped': True,
|
|
u'operatingSystem':
|
|
{u'instanceId': u'64702.2',
|
|
u'instanceName': u'Other Singlepath',
|
|
u'objectType': u'ScServerOperatingSystem'}}]
|
|
|
|
# ScServers list where status = Down
|
|
SCSERVERS_DOWN = \
|
|
[{u'scName': u'Storage Center 64702',
|
|
u'volumeCount': 5,
|
|
u'removeHbasAllowed': True,
|
|
u'legacyFluidFs': False,
|
|
u'serverFolderIndex': 0,
|
|
u'alertOnConnectivity': True,
|
|
u'objectType': u'ScPhysicalServer',
|
|
u'instanceName': u'openstack4',
|
|
u'instanceId': u'64702.1',
|
|
u'serverFolderPath': u'',
|
|
u'portType': [u'Iscsi'],
|
|
u'type': u'Physical',
|
|
u'statusMessage': u'',
|
|
u'status': u'Down',
|
|
u'scSerialNumber': 64702,
|
|
u'serverFolder': {u'instanceId': u'64702.0',
|
|
u'instanceName': u'Servers',
|
|
u'objectType': u'ScServerFolder'},
|
|
u'parentIndex': 0,
|
|
u'connectivity': u'Up',
|
|
u'hostCacheIndex': 0,
|
|
u'deleteAllowed': True,
|
|
u'pathCount': 0,
|
|
u'name': u'openstack4',
|
|
u'hbaPresent': True,
|
|
u'hbaCount': 1,
|
|
u'notes': u'',
|
|
u'mapped': True,
|
|
u'operatingSystem':
|
|
{u'instanceId': u'64702.3',
|
|
u'instanceName': u'Other Multipath',
|
|
u'objectType': u'ScServerOperatingSystem'}}]
|
|
|
|
MAP_PROFILE = {u'instanceId': u'64702.2941',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'lunUsed': [1],
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume':
|
|
{u'instanceId': u'64702.6025',
|
|
u'instanceName': u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'connectivity': u'Up',
|
|
u'readOnly': False,
|
|
u'objectType': u'ScMappingProfile',
|
|
u'hostCache': False,
|
|
u'mappedVia': u'Server',
|
|
u'mapCount': 3,
|
|
u'instanceName': u'6025-47',
|
|
u'lunRequested': u'N/A'}
|
|
|
|
MAP_PROFILES = [MAP_PROFILE]
|
|
|
|
MAPPINGS = [{u'profile': {u'instanceId': u'64702.104',
|
|
u'instanceName': u'92-30',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Down',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.969.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64702',
|
|
u'instanceName': u'SN 64702',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.30',
|
|
u'instanceName':
|
|
u'Server_iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.92',
|
|
u'instanceName':
|
|
u'volume-74a21934-60ad-4cf2-b89b-1f0dda309ddf',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'lunUsed': [1],
|
|
u'serverHba': {u'instanceId': u'64702.3454975614',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path': {u'instanceId': u'64702.64702.64702.31.8',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:'
|
|
'01:3776df826e4f-5000D31000FCBE43',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort': {u'instanceId':
|
|
u'64702.5764839588723736131.91',
|
|
u'instanceName': u'5000D31000FCBE43',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-969',
|
|
u'transport': u'Iscsi',
|
|
u'objectType': u'ScMapping'}]
|
|
|
|
# Multiple mappings to test find_iscsi_properties with multiple portals
|
|
MAPPINGS_MULTI_PORTAL = \
|
|
[{u'profile': {u'instanceId': u'64702.104',
|
|
u'instanceName': u'92-30',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Down',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.969.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64702',
|
|
u'instanceName': u'SN 64702',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.30',
|
|
u'instanceName':
|
|
u'Server_iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.92',
|
|
u'instanceName':
|
|
u'volume-74a21934-60ad-4cf2-b89b-1f0dda309ddf',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'lunUsed': [1],
|
|
u'serverHba': {u'instanceId': u'64702.3454975614',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path': {u'instanceId': u'64702.64702.64702.31.8',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:'
|
|
'01:3776df826e4f-5000D31000FCBE43',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort': {u'instanceId':
|
|
u'64702.5764839588723736131.91',
|
|
u'instanceName': u'5000D31000FCBE43',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-969',
|
|
u'transport': u'Iscsi',
|
|
u'objectType': u'ScMapping'},
|
|
{u'profile': {u'instanceId': u'64702.104',
|
|
u'instanceName': u'92-30',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Down',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.969.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64702',
|
|
u'instanceName': u'SN 64702',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.30',
|
|
u'instanceName':
|
|
u'Server_iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.92',
|
|
u'instanceName':
|
|
u'volume-74a21934-60ad-4cf2-b89b-1f0dda309ddf',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'lunUsed': [1],
|
|
u'serverHba': {u'instanceId': u'64702.3454975614',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path': {u'instanceId': u'64702.64702.64702.31.8',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:'
|
|
'01:3776df826e4f-5000D31000FCBE43',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort': {u'instanceId':
|
|
u'64702.5764839588723736131.91',
|
|
u'instanceName': u'5000D31000FCBE43',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-969',
|
|
u'transport': u'Iscsi',
|
|
u'objectType': u'ScMapping'}]
|
|
|
|
MAPPINGS_READ_ONLY = \
|
|
[{u'profile': {u'instanceId': u'64702.104',
|
|
u'instanceName': u'92-30',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Down',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.969.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64702',
|
|
u'instanceName': u'SN 64702',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.30',
|
|
u'instanceName':
|
|
u'Server_iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.92',
|
|
u'instanceName':
|
|
u'volume-74a21934-60ad-4cf2-b89b-1f0dda309ddf',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': True,
|
|
u'lun': 1,
|
|
u'lunUsed': [1],
|
|
u'serverHba': {u'instanceId': u'64702.3454975614',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:01:3776df826e4f',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path': {u'instanceId': u'64702.64702.64702.31.8',
|
|
u'instanceName':
|
|
u'iqn.1993-08.org.debian:'
|
|
'01:3776df826e4f-5000D31000FCBE43',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort': {u'instanceId':
|
|
u'64702.5764839588723736131.91',
|
|
u'instanceName':
|
|
u'5000D31000FCBE43',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-969',
|
|
u'transport': u'Iscsi',
|
|
u'objectType': u'ScMapping'}]
|
|
|
|
FC_MAPPINGS = [{u'profile': {u'instanceId': u'64702.2941',
|
|
u'instanceName': u'6025-47',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Up',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.7639.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'serverHba': {u'instanceId': u'64702.3282218607',
|
|
u'instanceName': u'21000024FF30441C',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path': {u'instanceId': u'64702.64702.64703.27.73',
|
|
u'instanceName':
|
|
u'21000024FF30441C-5000D31000FCBE36',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort':
|
|
{u'instanceId': u'64702.5764839588723736118.50',
|
|
u'instanceName': u'5000D31000FCBE36',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-7639',
|
|
u'transport': u'FibreChannel',
|
|
u'objectType': u'ScMapping'},
|
|
{u'profile': {u'instanceId': u'64702.2941',
|
|
u'instanceName': u'6025-47',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Up',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.7640.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume':
|
|
{u'instanceId': u'64702.6025',
|
|
u'instanceName': u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'serverHba': {u'instanceId': u'64702.3282218606',
|
|
u'instanceName': u'21000024FF30441D',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path':
|
|
{u'instanceId': u'64702.64702.64703.27.78',
|
|
u'instanceName': u'21000024FF30441D-5000D31000FCBE36',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort':
|
|
{u'instanceId': u'64702.5764839588723736118.50',
|
|
u'instanceName': u'5000D31000FCBE36',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-7640',
|
|
u'transport': u'FibreChannel',
|
|
u'objectType': u'ScMapping'},
|
|
{u'profile': {u'instanceId': u'64702.2941',
|
|
u'instanceName': u'6025-47',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Up',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.7638.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'serverHba': {u'instanceId': u'64702.3282218606',
|
|
u'instanceName': u'21000024FF30441D',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path':
|
|
{u'instanceId': u'64702.64702.64703.28.76',
|
|
u'instanceName': u'21000024FF30441D-5000D31000FCBE3E',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort': {u'instanceId':
|
|
u'64702.5764839588723736126.60',
|
|
u'instanceName': u'5000D31000FCBE3E',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-7638',
|
|
u'transport': u'FibreChannel',
|
|
u'objectType': u'ScMapping'}]
|
|
|
|
FC_MAPPINGS_LUN_MISMATCH = \
|
|
[{u'profile': {u'instanceId': u'64702.2941',
|
|
u'instanceName': u'6025-47',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Up',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.7639.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'serverHba': {u'instanceId': u'64702.3282218607',
|
|
u'instanceName': u'21000024FF30441C',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path': {u'instanceId': u'64702.64702.64703.27.73',
|
|
u'instanceName':
|
|
u'21000024FF30441C-5000D31000FCBE36',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort':
|
|
{u'instanceId': u'64702.5764839588723736118.50',
|
|
u'instanceName': u'5000D31000FCBE36',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-7639',
|
|
u'transport': u'FibreChannel',
|
|
u'objectType': u'ScMapping'},
|
|
{u'profile': {u'instanceId': u'64702.2941',
|
|
u'instanceName': u'6025-47',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Up',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.7640.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume':
|
|
{u'instanceId': u'64702.6025',
|
|
u'instanceName': u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 1,
|
|
u'serverHba': {u'instanceId': u'64702.3282218606',
|
|
u'instanceName': u'21000024FF30441D',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path':
|
|
{u'instanceId': u'64702.64702.64703.27.78',
|
|
u'instanceName': u'21000024FF30441D-5000D31000FCBE36',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort':
|
|
{u'instanceId': u'64702.5764839588723736118.50',
|
|
u'instanceName': u'5000D31000FCBE36',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-7640',
|
|
u'transport': u'FibreChannel',
|
|
u'objectType': u'ScMapping'},
|
|
{u'profile': {u'instanceId': u'64702.2941',
|
|
u'instanceName': u'6025-47',
|
|
u'objectType': u'ScMappingProfile'},
|
|
u'status': u'Up',
|
|
u'statusMessage': u'',
|
|
u'instanceId': u'64702.7638.64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'volume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'readOnly': False,
|
|
u'lun': 2,
|
|
u'serverHba': {u'instanceId': u'64702.3282218606',
|
|
u'instanceName': u'21000024FF30441D',
|
|
u'objectType': u'ScServerHba'},
|
|
u'path':
|
|
{u'instanceId': u'64702.64702.64703.28.76',
|
|
u'instanceName': u'21000024FF30441D-5000D31000FCBE3E',
|
|
u'objectType': u'ScServerHbaPath'},
|
|
u'controllerPort': {u'instanceId':
|
|
u'64702.5764839588723736126.60',
|
|
u'instanceName': u'5000D31000FCBE3E',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'instanceName': u'64702-7638',
|
|
u'transport': u'FibreChannel',
|
|
u'objectType': u'ScMapping'}]
|
|
|
|
RPLAY = {u'scSerialNumber': 64702,
|
|
u'globalIndex': u'64702-46-250',
|
|
u'description': u'Cinder Clone Replay',
|
|
u'parent': {u'instanceId': u'64702.46.249',
|
|
u'instanceName': u'64702-46-249',
|
|
u'objectType': u'ScReplay'},
|
|
u'instanceId': u'64702.46.250',
|
|
u'scName': u'Storage Center 64702',
|
|
u'consistent': False,
|
|
u'expires': True,
|
|
u'freezeTime': u'12/09/2014 03:52:08 PM',
|
|
u'createVolume': {u'instanceId': u'64702.46',
|
|
u'instanceName':
|
|
u'volume-ff9589d3-2d41-48d5-9ef5-2713a875e85b',
|
|
u'objectType': u'ScVolume'},
|
|
u'expireTime': u'12/09/2014 04:52:08 PM',
|
|
u'source': u'Manual',
|
|
u'spaceRecovery': False,
|
|
u'writesHeldDuration': 7910,
|
|
u'active': False,
|
|
u'markedForExpiration': False,
|
|
u'objectType': u'ScReplay',
|
|
u'instanceName': u'12/09/2014 03:52:08 PM',
|
|
u'size': u'0.0 Bytes'
|
|
}
|
|
|
|
RPLAYS = [{u'scSerialNumber': 64702,
|
|
u'globalIndex': u'64702-6025-5',
|
|
u'description': u'Manually Created',
|
|
u'parent': {u'instanceId': u'64702.6025.4',
|
|
u'instanceName': u'64702-6025-4',
|
|
u'objectType': u'ScReplay'},
|
|
u'instanceId': u'64702.6025.5',
|
|
u'scName': u'Storage Center 64702',
|
|
u'consistent': False,
|
|
u'expires': True,
|
|
u'freezeTime': u'02/02/2015 08:23:55 PM',
|
|
u'createVolume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'expireTime': u'02/02/2015 09:23:55 PM',
|
|
u'source': u'Manual',
|
|
u'spaceRecovery': False,
|
|
u'writesHeldDuration': 7889,
|
|
u'active': False,
|
|
u'markedForExpiration': False,
|
|
u'objectType': u'ScReplay',
|
|
u'instanceName': u'02/02/2015 08:23:55 PM',
|
|
u'size': u'0.0 Bytes'},
|
|
{u'scSerialNumber': 64702,
|
|
u'globalIndex': u'64702-6025-4',
|
|
u'description': u'Cinder Test Replay012345678910',
|
|
u'parent': {u'instanceId': u'64702.6025.3',
|
|
u'instanceName': u'64702-6025-3',
|
|
u'objectType': u'ScReplay'},
|
|
u'instanceId': u'64702.6025.4',
|
|
u'scName': u'Storage Center 64702',
|
|
u'consistent': False,
|
|
u'expires': True,
|
|
u'freezeTime': u'02/02/2015 08:23:47 PM',
|
|
u'createVolume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'expireTime': u'02/02/2015 09:23:47 PM',
|
|
u'source': u'Manual',
|
|
u'spaceRecovery': False,
|
|
u'writesHeldDuration': 7869,
|
|
u'active': False,
|
|
u'markedForExpiration': False,
|
|
u'objectType': u'ScReplay',
|
|
u'instanceName': u'02/02/2015 08:23:47 PM',
|
|
u'size': u'0.0 Bytes'}]
|
|
|
|
TST_RPLAY = {u'scSerialNumber': 64702,
|
|
u'globalIndex': u'64702-6025-4',
|
|
u'description': u'Cinder Test Replay012345678910',
|
|
u'parent': {u'instanceId': u'64702.6025.3',
|
|
u'instanceName': u'64702-6025-3',
|
|
u'objectType': u'ScReplay'},
|
|
u'instanceId': u'64702.6025.4',
|
|
u'scName': u'Storage Center 64702',
|
|
u'consistent': False,
|
|
u'expires': True,
|
|
u'freezeTime': u'02/02/2015 08:23:47 PM',
|
|
u'createVolume': {u'instanceId': u'64702.6025',
|
|
u'instanceName':
|
|
u'Server_21000024ff30441d Test Vol',
|
|
u'objectType': u'ScVolume'},
|
|
u'expireTime': u'02/02/2015 09:23:47 PM',
|
|
u'source': u'Manual',
|
|
u'spaceRecovery': False,
|
|
u'writesHeldDuration': 7869,
|
|
u'active': False,
|
|
u'markedForExpiration': False,
|
|
u'objectType': u'ScReplay',
|
|
u'instanceName': u'02/02/2015 08:23:47 PM',
|
|
u'size': u'0.0 Bytes'}
|
|
|
|
FLDR = {u'status': u'Up',
|
|
u'instanceName': u'opnstktst',
|
|
u'name': u'opnstktst',
|
|
u'parent':
|
|
{u'instanceId': u'64702.0',
|
|
u'instanceName': u'Volumes',
|
|
u'objectType': u'ScVolumeFolder'},
|
|
u'instanceId': u'64702.43',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'Folder for OpenStack Cinder Driver',
|
|
u'scSerialNumber': 64702,
|
|
u'parentIndex': 0,
|
|
u'okToDelete': True,
|
|
u'folderPath': u'',
|
|
u'root': False,
|
|
u'statusMessage': u'',
|
|
u'objectType': u'ScVolumeFolder'}
|
|
|
|
SVR_FLDR = {u'status': u'Up',
|
|
u'instanceName': u'devstacksrv',
|
|
u'name': u'devstacksrv',
|
|
u'parent': {u'instanceId': u'64702.0',
|
|
u'instanceName': u'Servers',
|
|
u'objectType': u'ScServerFolder'},
|
|
u'instanceId': u'64702.4',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'Folder for OpenStack Cinder Driver',
|
|
u'scSerialNumber': 64702,
|
|
u'parentIndex': 0,
|
|
u'okToDelete': False,
|
|
u'folderPath': u'',
|
|
u'root': False,
|
|
u'statusMessage': u'',
|
|
u'objectType': u'ScServerFolder'}
|
|
|
|
ISCSI_HBA = {u'portWwnList': [],
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'pathCount': 1,
|
|
u'name': u'iqn.1993-08.org.debian:01:52332b70525',
|
|
u'connectivity': u'Down',
|
|
u'instanceId': u'64702.3786433166',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'scSerialNumber': 64702,
|
|
u'server':
|
|
{u'instanceId': u'64702.38',
|
|
u'instanceName':
|
|
u'Server_iqn.1993-08.org.debian:01:52332b70525',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'remoteStorageCenter': False,
|
|
u'iscsiName': u'',
|
|
u'portType': u'Iscsi',
|
|
u'instanceName': u'iqn.1993-08.org.debian:01:52332b70525',
|
|
u'objectType': u'ScServerHba'}
|
|
|
|
FC_HBAS = [{u'portWwnList': [],
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'pathCount': 2,
|
|
u'name': u'21000024FF30441C',
|
|
u'connectivity': u'Up',
|
|
u'instanceId': u'64702.3282218607',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'scSerialNumber': 64702,
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'remoteStorageCenter': False,
|
|
u'iscsiName': u'',
|
|
u'portType': u'FibreChannel',
|
|
u'instanceName': u'21000024FF30441C',
|
|
u'objectType': u'ScServerHba'},
|
|
{u'portWwnList': [],
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'pathCount': 3,
|
|
u'name': u'21000024FF30441D',
|
|
u'connectivity': u'Partial',
|
|
u'instanceId': u'64702.3282218606',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'scSerialNumber': 64702,
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'remoteStorageCenter': False,
|
|
u'iscsiName': u'',
|
|
u'portType': u'FibreChannel',
|
|
u'instanceName': u'21000024FF30441D',
|
|
u'objectType': u'ScServerHba'}]
|
|
|
|
FC_HBA = {u'portWwnList': [],
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'pathCount': 3,
|
|
u'name': u'21000024FF30441D',
|
|
u'connectivity': u'Partial',
|
|
u'instanceId': u'64702.3282218606',
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'scSerialNumber': 64702,
|
|
u'server': {u'instanceId': u'64702.47',
|
|
u'instanceName': u'Server_21000024ff30441d',
|
|
u'objectType': u'ScPhysicalServer'},
|
|
u'remoteStorageCenter': False,
|
|
u'iscsiName': u'',
|
|
u'portType': u'FibreChannel',
|
|
u'instanceName': u'21000024FF30441D',
|
|
u'objectType': u'ScServerHba'}
|
|
|
|
SVR_OS_S = [{u'allowsLunGaps': True,
|
|
u'product': u'Red Hat Linux',
|
|
u'supportsActiveMappingDeletion': True,
|
|
u'version': u'6.x',
|
|
u'requiresLunZero': False,
|
|
u'scName': u'Storage Center 64702',
|
|
u'virtualMachineGuest': True,
|
|
u'virtualMachineHost': False,
|
|
u'allowsCrossTransportMapping': False,
|
|
u'objectType': u'ScServerOperatingSystem',
|
|
u'instanceId': u'64702.38',
|
|
u'lunCanVaryAcrossPaths': False,
|
|
u'scSerialNumber': 64702,
|
|
u'maximumVolumeSize': u'0.0 Bytes',
|
|
u'multipath': True,
|
|
u'instanceName': u'Red Hat Linux 6.x',
|
|
u'supportsActiveMappingCreation': True,
|
|
u'name': u'Red Hat Linux 6.x'}]
|
|
|
|
ISCSI_FLT_DOMAINS = [{u'headerDigestEnabled': False,
|
|
u'classOfServicePriority': 0,
|
|
u'wellKnownIpAddress': u'192.168.0.21',
|
|
u'scSerialNumber': 64702,
|
|
u'iscsiName':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe42',
|
|
u'portNumber': 3260,
|
|
u'subnetMask': u'255.255.255.0',
|
|
u'gateway': u'192.168.0.1',
|
|
u'objectType': u'ScIscsiFaultDomain',
|
|
u'chapEnabled': False,
|
|
u'instanceId': u'64702.6.5.3',
|
|
u'childStatus': u'Up',
|
|
u'defaultTimeToRetain': u'SECONDS_20',
|
|
u'dataDigestEnabled': False,
|
|
u'instanceName': u'iSCSI 10G 2',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'transportType': u'Iscsi',
|
|
u'vlanId': 0,
|
|
u'windowSize': u'131072.0 Bytes',
|
|
u'defaultTimeToWait': u'SECONDS_2',
|
|
u'scsiCommandTimeout': u'MINUTES_1',
|
|
u'deleteAllowed': False,
|
|
u'name': u'iSCSI 10G 2',
|
|
u'immediateDataWriteEnabled': False,
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'mtu': u'MTU_1500',
|
|
u'bidirectionalChapSecret': u'',
|
|
u'keepAliveTimeout': u'SECONDS_30'}]
|
|
|
|
# For testing find_iscsi_properties where multiple portals are found
|
|
ISCSI_FLT_DOMAINS_MULTI_PORTALS = \
|
|
[{u'headerDigestEnabled': False,
|
|
u'classOfServicePriority': 0,
|
|
u'wellKnownIpAddress': u'192.168.0.21',
|
|
u'scSerialNumber': 64702,
|
|
u'iscsiName':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe42',
|
|
u'portNumber': 3260,
|
|
u'subnetMask': u'255.255.255.0',
|
|
u'gateway': u'192.168.0.1',
|
|
u'objectType': u'ScIscsiFaultDomain',
|
|
u'chapEnabled': False,
|
|
u'instanceId': u'64702.6.5.3',
|
|
u'childStatus': u'Up',
|
|
u'defaultTimeToRetain': u'SECONDS_20',
|
|
u'dataDigestEnabled': False,
|
|
u'instanceName': u'iSCSI 10G 2',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'transportType': u'Iscsi',
|
|
u'vlanId': 0,
|
|
u'windowSize': u'131072.0 Bytes',
|
|
u'defaultTimeToWait': u'SECONDS_2',
|
|
u'scsiCommandTimeout': u'MINUTES_1',
|
|
u'deleteAllowed': False,
|
|
u'name': u'iSCSI 10G 2',
|
|
u'immediateDataWriteEnabled': False,
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'mtu': u'MTU_1500',
|
|
u'bidirectionalChapSecret': u'',
|
|
u'keepAliveTimeout': u'SECONDS_30'},
|
|
{u'headerDigestEnabled': False,
|
|
u'classOfServicePriority': 0,
|
|
u'wellKnownIpAddress': u'192.168.0.25',
|
|
u'scSerialNumber': 64702,
|
|
u'iscsiName':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe42',
|
|
u'portNumber': 3260,
|
|
u'subnetMask': u'255.255.255.0',
|
|
u'gateway': u'192.168.0.1',
|
|
u'objectType': u'ScIscsiFaultDomain',
|
|
u'chapEnabled': False,
|
|
u'instanceId': u'64702.6.5.3',
|
|
u'childStatus': u'Up',
|
|
u'defaultTimeToRetain': u'SECONDS_20',
|
|
u'dataDigestEnabled': False,
|
|
u'instanceName': u'iSCSI 10G 2',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'transportType': u'Iscsi',
|
|
u'vlanId': 0,
|
|
u'windowSize': u'131072.0 Bytes',
|
|
u'defaultTimeToWait': u'SECONDS_2',
|
|
u'scsiCommandTimeout': u'MINUTES_1',
|
|
u'deleteAllowed': False,
|
|
u'name': u'iSCSI 10G 2',
|
|
u'immediateDataWriteEnabled': False,
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'mtu': u'MTU_1500',
|
|
u'bidirectionalChapSecret': u'',
|
|
u'keepAliveTimeout': u'SECONDS_30'}]
|
|
|
|
ISCSI_FLT_DOMAIN = {u'headerDigestEnabled': False,
|
|
u'classOfServicePriority': 0,
|
|
u'wellKnownIpAddress': u'192.168.0.21',
|
|
u'scSerialNumber': 64702,
|
|
u'iscsiName':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe42',
|
|
u'portNumber': 3260,
|
|
u'subnetMask': u'255.255.255.0',
|
|
u'gateway': u'192.168.0.1',
|
|
u'objectType': u'ScIscsiFaultDomain',
|
|
u'chapEnabled': False,
|
|
u'instanceId': u'64702.6.5.3',
|
|
u'childStatus': u'Up',
|
|
u'defaultTimeToRetain': u'SECONDS_20',
|
|
u'dataDigestEnabled': False,
|
|
u'instanceName': u'iSCSI 10G 2',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'transportType': u'Iscsi',
|
|
u'vlanId': 0,
|
|
u'windowSize': u'131072.0 Bytes',
|
|
u'defaultTimeToWait': u'SECONDS_2',
|
|
u'scsiCommandTimeout': u'MINUTES_1',
|
|
u'deleteAllowed': False,
|
|
u'name': u'iSCSI 10G 2',
|
|
u'immediateDataWriteEnabled': False,
|
|
u'scName': u'Storage Center 64702',
|
|
u'notes': u'',
|
|
u'mtu': u'MTU_1500',
|
|
u'bidirectionalChapSecret': u'',
|
|
u'keepAliveTimeout': u'SECONDS_30'}
|
|
|
|
CTRLR_PORT = {u'status': u'Up',
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'WWN': u'5000D31000FCBE06',
|
|
u'name': u'5000D31000FCBE06',
|
|
u'iscsiGateway': u'0.0.0.0',
|
|
u'instanceId': u'64702.5764839588723736070.51',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'transportType': u'FibreChannel',
|
|
u'virtual': False,
|
|
u'controller': {u'instanceId': u'64702.64702',
|
|
u'instanceName': u'SN 64702',
|
|
u'objectType': u'ScController'},
|
|
u'iscsiName': u'',
|
|
u'purpose': u'FrontEnd',
|
|
u'iscsiSubnetMask': u'0.0.0.0',
|
|
u'faultDomain':
|
|
{u'instanceId': u'64702.4.3',
|
|
u'instanceName': u'Domain 1',
|
|
u'objectType': u'ScControllerPortFaultDomain'},
|
|
u'instanceName': u'5000D31000FCBE06',
|
|
u'statusMessage': u'',
|
|
u'objectType': u'ScControllerPort'}
|
|
|
|
ISCSI_CTRLR_PORT = {u'preferredParent':
|
|
{u'instanceId': u'64702.5764839588723736074.69',
|
|
u'instanceName': u'5000D31000FCBE0A',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'status': u'Up',
|
|
u'iscsiIpAddress': u'10.23.8.235',
|
|
u'WWN': u'5000D31000FCBE43',
|
|
u'name': u'5000D31000FCBE43',
|
|
u'parent':
|
|
{u'instanceId': u'64702.5764839588723736074.69',
|
|
u'instanceName': u'5000D31000FCBE0A',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'iscsiGateway': u'0.0.0.0',
|
|
u'instanceId': u'64702.5764839588723736131.91',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'transportType': u'Iscsi',
|
|
u'virtual': True,
|
|
u'controller': {u'instanceId': u'64702.64702',
|
|
u'instanceName': u'SN 64702',
|
|
u'objectType': u'ScController'},
|
|
u'iscsiName':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
u'purpose': u'FrontEnd',
|
|
u'iscsiSubnetMask': u'0.0.0.0',
|
|
u'faultDomain':
|
|
{u'instanceId': u'64702.6.5',
|
|
u'instanceName': u'iSCSI 10G 2',
|
|
u'objectType': u'ScControllerPortFaultDomain'},
|
|
u'instanceName': u'5000D31000FCBE43',
|
|
u'childStatus': u'Up',
|
|
u'statusMessage': u'',
|
|
u'objectType': u'ScControllerPort'}
|
|
|
|
FC_CTRLR_PORT = {u'preferredParent':
|
|
{u'instanceId': u'64702.5764839588723736093.57',
|
|
u'instanceName': u'5000D31000FCBE1D',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'status': u'Up',
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'WWN': u'5000D31000FCBE36',
|
|
u'name': u'5000D31000FCBE36',
|
|
u'parent':
|
|
{u'instanceId': u'64702.5764839588723736093.57',
|
|
u'instanceName': u'5000D31000FCBE1D',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'iscsiGateway': u'0.0.0.0',
|
|
u'instanceId': u'64702.5764839588723736118.50',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'transportType': u'FibreChannel',
|
|
u'virtual': True,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'iscsiName': u'',
|
|
u'purpose': u'FrontEnd',
|
|
u'iscsiSubnetMask': u'0.0.0.0',
|
|
u'faultDomain':
|
|
{u'instanceId': u'64702.1.0',
|
|
u'instanceName': u'Domain 0',
|
|
u'objectType': u'ScControllerPortFaultDomain'},
|
|
u'instanceName': u'5000D31000FCBE36',
|
|
u'childStatus': u'Up',
|
|
u'statusMessage': u'',
|
|
u'objectType': u'ScControllerPort'}
|
|
|
|
FC_CTRLR_PORT_WWN_ERROR = \
|
|
{u'preferredParent':
|
|
{u'instanceId': u'64702.5764839588723736093.57',
|
|
u'instanceName': u'5000D31000FCBE1D',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'status': u'Up',
|
|
u'iscsiIpAddress': u'0.0.0.0',
|
|
u'wWN': u'5000D31000FCBE36',
|
|
u'name': u'5000D31000FCBE36',
|
|
u'parent':
|
|
{u'instanceId': u'64702.5764839588723736093.57',
|
|
u'instanceName': u'5000D31000FCBE1D',
|
|
u'objectType': u'ScControllerPort'},
|
|
u'iscsiGateway': u'0.0.0.0',
|
|
u'instanceId': u'64702.5764839588723736118.50',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'transportType': u'FibreChannel',
|
|
u'virtual': True,
|
|
u'controller': {u'instanceId': u'64702.64703',
|
|
u'instanceName': u'SN 64703',
|
|
u'objectType': u'ScController'},
|
|
u'iscsiName': u'',
|
|
u'purpose': u'FrontEnd',
|
|
u'iscsiSubnetMask': u'0.0.0.0',
|
|
u'faultDomain':
|
|
{u'instanceId': u'64702.1.0',
|
|
u'instanceName': u'Domain 0',
|
|
u'objectType': u'ScControllerPortFaultDomain'},
|
|
u'instanceName': u'5000D31000FCBE36',
|
|
u'childStatus': u'Up',
|
|
u'statusMessage': u'',
|
|
u'objectType': u'ScControllerPort'}
|
|
|
|
STRG_USAGE = {u'systemSpace': u'7.38197504E8 Bytes',
|
|
u'freeSpace': u'1.297659461632E13 Bytes',
|
|
u'oversubscribedSpace': u'0.0 Bytes',
|
|
u'instanceId': u'64702',
|
|
u'scName': u'Storage Center 64702',
|
|
u'savingVsRaidTen': u'1.13737990144E11 Bytes',
|
|
u'allocatedSpace': u'1.66791217152E12 Bytes',
|
|
u'usedSpace': u'3.25716017152E11 Bytes',
|
|
u'configuredSpace': u'9.155796533248E12 Bytes',
|
|
u'alertThresholdSpace': u'1.197207956992E13 Bytes',
|
|
u'availableSpace': u'1.3302310633472E13 Bytes',
|
|
u'badSpace': u'0.0 Bytes',
|
|
u'time': u'02/02/2015 02:23:39 PM',
|
|
u'scSerialNumber': 64702,
|
|
u'instanceName': u'Storage Center 64702',
|
|
u'storageAlertThreshold': 10,
|
|
u'objectType': u'StorageCenterStorageUsage'}
|
|
|
|
RPLAY_PROFILE = {u'name': u'fc8f2fec-fab2-4e34-9148-c094c913b9a3',
|
|
u'type': u'Consistent',
|
|
u'notes': u'Created by Dell EMC Cinder Driver',
|
|
u'volumeCount': 0,
|
|
u'expireIncompleteReplaySets': True,
|
|
u'replayCreationTimeout': 20,
|
|
u'enforceReplayCreationTimeout': False,
|
|
u'ruleCount': 0,
|
|
u'userCreated': True,
|
|
u'scSerialNumber': 64702,
|
|
u'scName': u'Storage Center 64702',
|
|
u'objectType': u'ScReplayProfile',
|
|
u'instanceId': u'64702.11',
|
|
u'instanceName': u'fc8f2fec-fab2-4e34-9148-c094c913b9a3'}
|
|
STORAGE_PROFILE_LIST = [
|
|
{u'allowedForFlashOptimized': False,
|
|
u'allowedForNonFlashOptimized': True,
|
|
u'index': 1,
|
|
u'instanceId': u'64158.1',
|
|
u'instanceName': u'Recommended',
|
|
u'name': u'Recommended',
|
|
u'notes': u'',
|
|
u'objectType': u'ScStorageProfile',
|
|
u'raidTypeDescription': u'RAID 10 Active, RAID 5 or RAID 6 Replay',
|
|
u'raidTypeUsed': u'Mixed',
|
|
u'scName': u'Storage Center 64158',
|
|
u'scSerialNumber': 64158,
|
|
u'tiersUsedDescription': u'Tier 1, Tier 2, Tier 3',
|
|
u'useTier1Storage': True,
|
|
u'useTier2Storage': True,
|
|
u'useTier3Storage': True,
|
|
u'userCreated': False,
|
|
u'volumeCount': 125},
|
|
{u'allowedForFlashOptimized': False,
|
|
u'allowedForNonFlashOptimized': True,
|
|
u'index': 2,
|
|
u'instanceId': u'64158.2',
|
|
u'instanceName': u'High Priority',
|
|
u'name': u'High Priority',
|
|
u'notes': u'',
|
|
u'objectType': u'ScStorageProfile',
|
|
u'raidTypeDescription': u'RAID 10 Active, RAID 5 or RAID 6 Replay',
|
|
u'raidTypeUsed': u'Mixed',
|
|
u'scName': u'Storage Center 64158',
|
|
u'scSerialNumber': 64158,
|
|
u'tiersUsedDescription': u'Tier 1',
|
|
u'useTier1Storage': True,
|
|
u'useTier2Storage': False,
|
|
u'useTier3Storage': False,
|
|
u'userCreated': False,
|
|
u'volumeCount': 0},
|
|
{u'allowedForFlashOptimized': False,
|
|
u'allowedForNonFlashOptimized': True,
|
|
u'index': 3,
|
|
u'instanceId': u'64158.3',
|
|
u'instanceName': u'Medium Priority',
|
|
u'name': u'Medium Priority',
|
|
u'notes': u'',
|
|
u'objectType': u'ScStorageProfile',
|
|
u'raidTypeDescription': u'RAID 10 Active, RAID 5 or RAID 6 Replay',
|
|
u'raidTypeUsed': u'Mixed',
|
|
u'scName': u'Storage Center 64158',
|
|
u'scSerialNumber': 64158,
|
|
u'tiersUsedDescription': u'Tier 2',
|
|
u'useTier1Storage': False,
|
|
u'useTier2Storage': True,
|
|
u'useTier3Storage': False,
|
|
u'userCreated': False,
|
|
u'volumeCount': 0},
|
|
{u'allowedForFlashOptimized': True,
|
|
u'allowedForNonFlashOptimized': True,
|
|
u'index': 4,
|
|
u'instanceId': u'64158.4',
|
|
u'instanceName': u'Low Priority',
|
|
u'name': u'Low Priority',
|
|
u'notes': u'',
|
|
u'objectType': u'ScStorageProfile',
|
|
u'raidTypeDescription': u'RAID 10 Active, RAID 5 or RAID 6 Replay',
|
|
u'raidTypeUsed': u'Mixed',
|
|
u'scName': u'Storage Center 64158',
|
|
u'scSerialNumber': 64158,
|
|
u'tiersUsedDescription': u'Tier 3',
|
|
u'useTier1Storage': False,
|
|
u'useTier2Storage': False,
|
|
u'useTier3Storage': True,
|
|
u'userCreated': False,
|
|
u'volumeCount': 0}]
|
|
|
|
CGS = [{u'profile':
|
|
{u'instanceId': u'65690.4',
|
|
u'instanceName': u'0869559e-6881-454e-ba18-15c6726d33c1',
|
|
u'objectType': u'ScReplayProfile'},
|
|
u'scSerialNumber': 65690,
|
|
u'globalIndex': u'65690-4-2',
|
|
u'description': u'GUID1-0869559e-6881-454e-ba18-15c6726d33c1',
|
|
u'instanceId': u'65690.65690.4.2',
|
|
u'scName': u'Storage Center 65690',
|
|
u'expires': False,
|
|
u'freezeTime': u'2015-09-28T14:00:59-05:00',
|
|
u'expireTime': u'1969-12-31T18:00:00-06:00',
|
|
u'expectedReplayCount': 2,
|
|
u'writesHeldDuration': 19809,
|
|
u'replayCount': 2,
|
|
u'instanceName': u'Name1',
|
|
u'objectType': u'ScReplayConsistencyGroup'},
|
|
{u'profile':
|
|
{u'instanceId': u'65690.4',
|
|
u'instanceName': u'0869559e-6881-454e-ba18-15c6726d33c1',
|
|
u'objectType': u'ScReplayProfile'},
|
|
u'scSerialNumber': 65690,
|
|
u'globalIndex': u'65690-4-3',
|
|
u'description': u'GUID2-0869559e-6881-454e-ba18-15c6726d33c1',
|
|
u'instanceId': u'65690.65690.4.3',
|
|
u'scName': u'Storage Center 65690',
|
|
u'expires': False,
|
|
u'freezeTime': u'2015-09-28T14:00:59-05:00',
|
|
u'expireTime': u'1969-12-31T18:00:00-06:00',
|
|
u'expectedReplayCount': 2,
|
|
u'writesHeldDuration': 19809,
|
|
u'replayCount': 2,
|
|
u'instanceName': u'Name2',
|
|
u'objectType': u'ScReplayConsistencyGroup'}
|
|
]
|
|
|
|
ISCSI_CONFIG = {
|
|
u'initialReadyToTransfer': True,
|
|
u'scSerialNumber': 64065,
|
|
u'macAddress': u'00c0dd-1da173',
|
|
u'instanceId': u'64065.5764839588723573038.6',
|
|
u'vlanTagging': False,
|
|
u'mapCount': 8,
|
|
u'cardModel': u'Qle4062',
|
|
u'portNumber': 3260,
|
|
u'firstBurstSize': 256,
|
|
u'deviceName': u'PCIDEV09',
|
|
u'subnetMask': u'255.255.255.0',
|
|
u'speed': u'1 Gbps',
|
|
u'maximumVlanCount': 0,
|
|
u'gatewayIpAddress': u'192.168.0.1',
|
|
u'slot': 4,
|
|
u'sfpData': u'',
|
|
u'dataDigest': False,
|
|
u'chapEnabled': False,
|
|
u'firmwareVersion': u'03.00.01.77',
|
|
u'preferredControllerIndex': 64066,
|
|
u'defaultTimeToRetain': 20,
|
|
u'objectType': u'ScControllerPortIscsiConfiguration',
|
|
u'instanceName': u'5000d31000FCBE43',
|
|
u'scName': u'sc64065',
|
|
u'revision': u'0',
|
|
u'controllerPortIndex': 5764839588723573038,
|
|
u'maxBurstSize': 512,
|
|
u'targetCount': 20,
|
|
u'description': u'QLogic QLE4062 iSCSI Adapter Rev 0 Copper',
|
|
u'vlanSupported': True,
|
|
u'chapName': u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
u'windowSize': 128,
|
|
u'vlanId': 0,
|
|
u'defaultTimeToWait': 2,
|
|
u'headerDigest': False,
|
|
u'slotPort': 2,
|
|
u'immediateDataWrite': False,
|
|
u'storageCenterTargetCount': 20,
|
|
u'vlanCount': 0,
|
|
u'scsiCommandTimeout': 60,
|
|
u'slotType': u'PCI4',
|
|
u'ipAddress': u'192.168.0.21',
|
|
u'vlanUserPriority': 0,
|
|
u'bothCount': 0,
|
|
u'initiatorCount': 33,
|
|
u'keepAliveTimeout': 30,
|
|
u'homeControllerIndex': 64066,
|
|
u'chapSecret': u'',
|
|
u'maximumTransmissionUnit': 1500}
|
|
|
|
SCQOS = {u'linkSpeed': u'1 Gbps',
|
|
u'numberDevices': 1,
|
|
u'bandwidthLimited': False,
|
|
u'name': u'Cinder QoS',
|
|
u'instanceId': u'64702.2',
|
|
u'scName': u'Storage Center 64702',
|
|
u'scSerialNumber': 64702,
|
|
u'instanceName': u'Cinder QoS',
|
|
u'advancedSettings': {u'globalMaxSectorPerIo': 512,
|
|
u'destinationMaxSectorCount': 65536,
|
|
u'queuePassMaxSectorCount': 65536,
|
|
u'destinationMaxIoCount': 18,
|
|
u'globalMaxIoCount': 32,
|
|
u'queuePassMaxIoCount': 8},
|
|
u'objectType': u'ScReplicationQosNode'}
|
|
|
|
SCREPL = [{u'destinationVolume': {u'instanceId': u'65495.167',
|
|
u'instanceName': u'Cinder repl of abcd9'
|
|
u'5b2-1284-4cf0-a397-9'
|
|
u'70fa6c68092',
|
|
u'objectType': u'ScVolume'},
|
|
u'instanceId': u'64702.9',
|
|
u'scSerialNumber': 64702,
|
|
u'syncStatus': u'NotApplicable',
|
|
u'objectType': u'ScReplication',
|
|
u'sourceStorageCenter': {u'instanceId': u'64702',
|
|
u'instanceName': u'Storage Center '
|
|
'64702',
|
|
u'objectType': u'StorageCenter'},
|
|
u'secondaryTransportTypes': [],
|
|
u'dedup': False,
|
|
u'state': u'Up',
|
|
u'replicateActiveReplay': False,
|
|
u'qosNode': {u'instanceId': u'64702.2',
|
|
u'instanceName': u'Cinder QoS',
|
|
u'objectType': u'ScReplicationQosNode'},
|
|
u'sourceVolume': {u'instanceId': u'64702.13108',
|
|
u'instanceName': u'abcd95b2-1284-4cf0-a397-'
|
|
u'970fa6c68092',
|
|
u'objectType': u'ScVolume'},
|
|
u'type': u'Asynchronous',
|
|
u'statusMessage': u'',
|
|
u'status': u'Up',
|
|
u'syncMode': u'None',
|
|
u'stateMessage': u'',
|
|
u'managedByLiveVolume': False,
|
|
u'destinationScSerialNumber': 65495,
|
|
u'pauseAllowed': True,
|
|
u'instanceName': u"Replication of 'abcd95b2-1284-4cf0-"
|
|
u"a397-970fa6c68092'",
|
|
u'simulation': False,
|
|
u'transportTypes': [u'FibreChannel'],
|
|
u'replicateStorageToLowestTier': True,
|
|
u'scName': u'Storage Center 64702',
|
|
u'destinationStorageCenter': {u'instanceId': u'65495',
|
|
u'instanceName': u'Storage Center'
|
|
u' 65495',
|
|
u'objectType': u'StorageCenter'}}]
|
|
|
|
IQN = 'iqn.2002-03.com.compellent:5000D31000000001'
|
|
WWN = u'21000024FF30441C'
|
|
|
|
WWNS = [u'21000024FF30441C',
|
|
u'21000024FF30441D']
|
|
|
|
# Used to test finding no match in find_wwns
|
|
WWNS_NO_MATCH = [u'21000024FF30451C',
|
|
u'21000024FF30451D']
|
|
|
|
FLDR_PATH = 'StorageCenter/ScVolumeFolder/'
|
|
|
|
# Create a Response object that indicates OK
|
|
|
|
response_ok = models.Response()
|
|
response_ok.status_code = 200
|
|
response_ok.reason = u'ok'
|
|
response_ok._content = ''
|
|
response_ok._content_consumed = True
|
|
RESPONSE_200 = response_ok
|
|
|
|
# Create a Response object that indicates created
|
|
response_created = models.Response()
|
|
response_created.status_code = 201
|
|
response_created.reason = u'created'
|
|
response_created._content = ''
|
|
response_created._content_consumed = True
|
|
RESPONSE_201 = response_created
|
|
|
|
# Create a Response object that can indicate a failure. Although
|
|
# 204 can be a success with no return. (Know your calls!)
|
|
response_nc = models.Response()
|
|
response_nc.status_code = 204
|
|
response_nc.reason = u'duplicate'
|
|
response_nc._content = ''
|
|
response_nc._content_consumed = True
|
|
RESPONSE_204 = response_nc
|
|
|
|
# Create a Response object is a pure error.
|
|
response_bad = models.Response()
|
|
response_bad.status_code = 400
|
|
response_bad.reason = u'bad request'
|
|
response_bad._content = ''
|
|
response_bad._content_consumed = True
|
|
RESPONSE_400 = response_bad
|
|
|
|
# Create a Response object is a pure error.
|
|
response_bad = models.Response()
|
|
response_bad.status_code = 404
|
|
response_bad.reason = u'not found'
|
|
response_bad._content = ''
|
|
response_bad._content_consumed = True
|
|
RESPONSE_404 = response_bad
|
|
|
|
def setUp(self):
|
|
super(DellSCSanAPITestCase, self).setUp()
|
|
|
|
# Configuration is a mock. A mock is pretty much a blank
|
|
# slate. I believe mock's done in setup are not happy time
|
|
# mocks. So we just do a few things like driver config here.
|
|
self.configuration = mock.Mock()
|
|
|
|
self.configuration.san_is_local = False
|
|
self.configuration.san_ip = "192.168.0.1"
|
|
self.configuration.san_login = "admin"
|
|
self.configuration.san_password = "mmm"
|
|
self.configuration.dell_sc_ssn = 12345
|
|
self.configuration.dell_sc_server_folder = 'opnstktst'
|
|
self.configuration.dell_sc_volume_folder = 'opnstktst'
|
|
# Note that we set this to True even though we do not
|
|
# test this functionality. This is sent directly to
|
|
# the requests calls as the verify parameter and as
|
|
# that is a third party library deeply stubbed out is
|
|
# not directly testable by this code. Note that in the
|
|
# case that this fails the driver fails to even come
|
|
# up.
|
|
self.configuration.dell_sc_verify_cert = True
|
|
self.configuration.dell_sc_api_port = 3033
|
|
self.configuration.target_ip_address = '192.168.1.1'
|
|
self.configuration.target_port = 3260
|
|
self._context = context.get_admin_context()
|
|
self.apiversion = '2.0'
|
|
self.asynctimeout = 15
|
|
self.synctimeout = 30
|
|
|
|
# Set up the SCApi
|
|
self.scapi = storagecenter_api.SCApi(
|
|
self.configuration.san_ip,
|
|
self.configuration.dell_sc_api_port,
|
|
self.configuration.san_login,
|
|
self.configuration.san_password,
|
|
self.configuration.dell_sc_verify_cert,
|
|
self.asynctimeout,
|
|
self.synctimeout,
|
|
self.apiversion)
|
|
|
|
# Set up the scapi configuration vars
|
|
self.scapi.ssn = self.configuration.dell_sc_ssn
|
|
self.scapi.sfname = self.configuration.dell_sc_server_folder
|
|
self.scapi.vfname = self.configuration.dell_sc_volume_folder
|
|
# Note that we set this to True (or not) on the replication tests.
|
|
self.scapi.failed_over = False
|
|
# Legacy folder names are still current so we default this to true.
|
|
self.scapi.legacyfoldernames = True
|
|
|
|
self.volid = str(uuid.uuid4())
|
|
self.volume_name = "volume" + self.volid
|
|
self.repl_name = "Cinder repl of volume" + self.volid
|
|
|
|
def test_path_to_array(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._path_to_array(u'folder1/folder2/folder3')
|
|
expected = [u'folder1', u'folder2', u'folder3']
|
|
self.assertEqual(expected, res, 'Unexpected folder path')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result',
|
|
return_value=SC)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_sc(self,
|
|
mock_get,
|
|
mock_get_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_sc()
|
|
mock_get.assert_called_once_with('StorageCenter/StorageCenter')
|
|
self.assertTrue(mock_get_result.called)
|
|
self.assertEqual(u'64702', res, 'Unexpected SSN')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result',
|
|
return_value=None)
|
|
def test_find_sc_failure(self,
|
|
mock_get_result,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_sc)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_folder(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._create_folder(
|
|
'StorageCenter/ScVolumeFolder',
|
|
'',
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.FLDR, res, 'Unexpected Folder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_folder_with_parent(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where parent folder name is specified
|
|
res = self.scapi._create_folder(
|
|
'StorageCenter/ScVolumeFolder', 'parentFolder',
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.FLDR, res, 'Unexpected Folder')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_create_folder_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._create_folder(
|
|
'StorageCenter/ScVolumeFolder', '',
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertIsNone(res, 'Test Create folder - None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_path_to_array',
|
|
return_value=['Cinder_Test_Folder'])
|
|
def test_create_folder_path(self,
|
|
mock_path_to_array,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._create_folder_path(
|
|
'StorageCenter/ScVolumeFolder',
|
|
self.configuration.dell_sc_volume_folder)
|
|
mock_path_to_array.assert_called_once_with(
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertTrue(mock_find_folder.called)
|
|
self.assertEqual(self.FLDR, res, 'Unexpected ScFolder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_create_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_path_to_array',
|
|
return_value=['Cinder_Test_Folder'])
|
|
def test_create_folder_path_create_fldr(self,
|
|
mock_path_to_array,
|
|
mock_find_folder,
|
|
mock_create_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where folder is not found and must be created
|
|
res = self.scapi._create_folder_path(
|
|
'StorageCenter/ScVolumeFolder',
|
|
self.configuration.dell_sc_volume_folder)
|
|
mock_path_to_array.assert_called_once_with(
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertTrue(mock_find_folder.called)
|
|
self.assertTrue(mock_create_folder.called)
|
|
self.assertEqual(self.FLDR, res, 'Unexpected ScFolder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_create_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_path_to_array',
|
|
return_value=['Cinder_Test_Folder'])
|
|
def test_create_folder_path_failure(self,
|
|
mock_path_to_array,
|
|
mock_find_folder,
|
|
mock_create_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where folder is not found, must be created
|
|
# and creation fails
|
|
res = self.scapi._create_folder_path(
|
|
'StorageCenter/ScVolumeFolder',
|
|
self.configuration.dell_sc_volume_folder)
|
|
mock_path_to_array.assert_called_once_with(
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertTrue(mock_find_folder.called)
|
|
self.assertTrue(mock_create_folder.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_folder(self,
|
|
mock_post,
|
|
mock_get_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.scapi._find_folder('StorageCenter/ScVolumeFolder/GetList',
|
|
'devstackvol/fcvm', 12345)
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'Name',
|
|
'attributeValue': 'fcvm'},
|
|
{'filterType': 'Equals', 'attributeName': 'folderPath',
|
|
'attributeValue': 'devstackvol/'}]}}
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
expected_payload)
|
|
self.assertTrue(mock_get_result.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_folder_not_legacy(self,
|
|
mock_post,
|
|
mock_get_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.scapi.legacyfoldernames = False
|
|
self.scapi._find_folder('StorageCenter/ScVolumeFolder/GetList',
|
|
'devstackvol/fcvm', 12345)
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'Name',
|
|
'attributeValue': 'fcvm'},
|
|
{'filterType': 'Equals', 'attributeName': 'folderPath',
|
|
'attributeValue': '/devstackvol/'}]}}
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
expected_payload)
|
|
self.assertTrue(mock_get_result.called)
|
|
self.scapi.legacyfoldernames = True
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_folder_legacy_root(self,
|
|
mock_post,
|
|
mock_get_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.scapi._find_folder('StorageCenter/ScVolumeFolder/GetList',
|
|
'devstackvol', 12345)
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'Name',
|
|
'attributeValue': 'devstackvol'},
|
|
{'filterType': 'Equals', 'attributeName': 'folderPath',
|
|
'attributeValue': ''}]}}
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
expected_payload)
|
|
self.assertTrue(mock_get_result.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_folder_non_legacy_root(self,
|
|
mock_post,
|
|
mock_get_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.scapi.legacyfoldernames = False
|
|
self.scapi._find_folder('StorageCenter/ScVolumeFolder/GetList',
|
|
'devstackvol', 12345)
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'Name',
|
|
'attributeValue': 'devstackvol'},
|
|
{'filterType': 'Equals', 'attributeName': 'folderPath',
|
|
'attributeValue': '/'}]}}
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
expected_payload)
|
|
self.assertTrue(mock_get_result.called)
|
|
self.scapi.legacyfoldernames = True
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_result',
|
|
return_value=u'devstackvol/fcvm/')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_folder_multi_fldr(self,
|
|
mock_post,
|
|
mock_get_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case for folder path with multiple folders
|
|
res = self.scapi._find_folder(
|
|
'StorageCenter/ScVolumeFolder',
|
|
u'testParentFolder/opnstktst')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_result.called)
|
|
self.assertEqual(u'devstackvol/fcvm/', res, 'Unexpected folder')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_find_folder_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_folder(
|
|
'StorageCenter/ScVolumeFolder',
|
|
self.configuration.dell_sc_volume_folder)
|
|
self.assertIsNone(res, 'Test find folder - None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=None)
|
|
def test_find_volume_folder_fail(self,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where _find_volume_folder returns none
|
|
res = self.scapi._find_volume_folder(
|
|
False)
|
|
mock_find_folder.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
self.configuration.dell_sc_volume_folder, -1)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=FLDR)
|
|
def test_find_volume_folder(self,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_volume_folder(
|
|
False)
|
|
mock_find_folder.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
self.configuration.dell_sc_volume_folder, -1)
|
|
self.assertEqual(self.FLDR, res, 'Unexpected Folder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=STORAGE_PROFILE_LIST)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_storage_profile_fail(self,
|
|
mock_json,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where _find_volume_folder returns none
|
|
res = self.scapi._find_storage_profile("Blah")
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=STORAGE_PROFILE_LIST)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_storage_profile_none(self,
|
|
mock_json,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where _find_storage_profile returns none
|
|
res = self.scapi._find_storage_profile(None)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=STORAGE_PROFILE_LIST)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@ddt.data('HighPriority', 'highpriority', 'High Priority')
|
|
def test_find_storage_profile(self,
|
|
value,
|
|
mock_json,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_storage_profile(value)
|
|
self.assertIsNotNone(res, 'Expected matching storage profile!')
|
|
self.assertEqual(self.STORAGE_PROFILE_LIST[1]['instanceId'],
|
|
res.get('instanceId'))
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_create_folder_path',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=None)
|
|
def test_find_volume_folder_create_folder(self,
|
|
mock_find_folder,
|
|
mock_create_folder_path,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where _find_volume_folder returns none and folder must be
|
|
# created
|
|
res = self.scapi._find_volume_folder(
|
|
True)
|
|
mock_find_folder.assert_called_once_with(
|
|
'StorageCenter/ScVolumeFolder/GetList',
|
|
self.configuration.dell_sc_volume_folder, -1)
|
|
self.assertTrue(mock_create_folder_path.called)
|
|
self.assertEqual(self.FLDR, res, 'Unexpected Folder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'unmap_volume',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'map_volume',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCSERVERS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_init_volume(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_map_volume,
|
|
mock_unmap_volume,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.scapi._init_volume(self.VOLUME)
|
|
self.assertTrue(mock_map_volume.called)
|
|
self.assertTrue(mock_unmap_volume.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'unmap_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'map_volume',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_init_volume_retry(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_map_volume,
|
|
mock_unmap_volume,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_get_json.return_value = [{'name': 'srv1', 'status': 'up',
|
|
'type': 'physical'},
|
|
{'name': 'srv2', 'status': 'up',
|
|
'type': 'physical'}]
|
|
mock_get_volume.side_effect = [{'name': 'guid', 'active': False,
|
|
'instanceId': '12345.1'},
|
|
{'name': 'guid', 'active': True,
|
|
'instanceId': '12345.1'}]
|
|
self.scapi._init_volume(self.VOLUME)
|
|
# First return wasn't active. So try second.
|
|
self.assertEqual(2, mock_map_volume.call_count)
|
|
self.assertEqual(2, mock_unmap_volume.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_init_volume_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScServer list fails
|
|
self.scapi._init_volume(self.VOLUME)
|
|
self.assertTrue(mock_post.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'unmap_volume',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'map_volume',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCSERVERS_DOWN)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_init_volume_servers_down(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_map_volume,
|
|
mock_unmap_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScServer Status = Down
|
|
self.scapi._init_volume(self.VOLUME)
|
|
self.assertFalse(mock_map_volume.called)
|
|
self.assertFalse(mock_unmap_volume.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_volume(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_volume(
|
|
self.volume_name,
|
|
1)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_storage_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_replay_profiles')
|
|
def test_create_volume_with_profiles(self,
|
|
mock_find_replay_profiles,
|
|
mock_find_storage_profile,
|
|
mock_find_data_reduction_profile,
|
|
mock_find_qos_profile,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_find_replay_profiles.return_value = (['12345.4'], [])
|
|
mock_get_json.return_value = self.VOLUME
|
|
mock_find_volume_folder.return_value = {'instanceId': '12345.200'}
|
|
mock_post.return_value = self.RESPONSE_201
|
|
mock_find_storage_profile.return_value = {'instanceId': '12345.0'}
|
|
mock_find_data_reduction_profile.return_value = {'instanceId':
|
|
'12345.1'}
|
|
mock_find_qos_profile.side_effect = [{'instanceId': '12345.2'},
|
|
{'instanceId': '12345.3'}]
|
|
res = self.scapi.create_volume(self.volume_name, 1, 'storage_profile',
|
|
'replay_profile_string', 'volume_qos',
|
|
'group_qos', 'datareductionprofile')
|
|
expected_payload = {'Name': self.volume_name,
|
|
'Notes': 'Created by Dell EMC Cinder Driver',
|
|
'Size': '1 GB',
|
|
'StorageCenter': 12345,
|
|
'VolumeFolder': '12345.200',
|
|
'StorageProfile': '12345.0',
|
|
'VolumeQosProfile': '12345.2',
|
|
'GroupQosProfile': '12345.3',
|
|
'DataReductionProfile': '12345.1',
|
|
'ReplayProfileList': ['12345.4']}
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
mock_post.assert_called_once_with('StorageCenter/ScVolume',
|
|
expected_payload, True)
|
|
self.assertEqual(self.VOLUME, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_storage_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_replay_profiles')
|
|
def test_create_volume_profile_not_found(self,
|
|
mock_find_replay_profiles,
|
|
mock_find_storage_profile,
|
|
mock_find_qos_profile,
|
|
mock_find_volume_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_find_replay_profiles.return_value = (['12345.4'], [])
|
|
mock_find_volume_folder.return_value = self.FLDR
|
|
mock_find_storage_profile.return_value = [{'instanceId': '12345.0'}]
|
|
# Failure is on the volumeqosprofile.
|
|
mock_find_qos_profile.return_value = None
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_volume, self.volume_name, 1,
|
|
'storage_profile', 'replay_profile_string',
|
|
'volume_qos', 'group_qos', 'datareductionprofile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_storage_profile',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
def test_create_volume_storage_profile_missing(self,
|
|
mock_find_volume_folder,
|
|
mock_find_storage_profile,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_volume,
|
|
self.volume_name,
|
|
1,
|
|
'Blah')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_storage_profile',
|
|
return_value=STORAGE_PROFILE_LIST[0])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_volume_storage_profile(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_find_storage_profile,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.scapi.create_volume(
|
|
self.volume_name,
|
|
1,
|
|
'Recommended')
|
|
actual = mock_post.call_args[0][1]['StorageProfile']
|
|
expected = self.STORAGE_PROFILE_LIST[0]['instanceId']
|
|
self.assertEqual(expected, actual)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_search_for_volume',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_volume_retry_find(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_get_json,
|
|
mock_search_for_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where find_volume is used to do a retry of finding the
|
|
# created volume
|
|
res = self.scapi.create_volume(
|
|
self.volume_name,
|
|
1)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
mock_search_for_volume.assert_called_once_with(self.volume_name)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_vol_folder_fail(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test calling create_volume where volume folder does not exist and
|
|
# fails to be created
|
|
res = self.scapi.create_volume(
|
|
self.volume_name,
|
|
1)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_create_volume_failure(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_volume(
|
|
self.volume_name,
|
|
1)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME_LIST)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test__get_volume_list_enforce_vol_fldr(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case to find volume in the configured volume folder
|
|
res = self.scapi._get_volume_list(self.volume_name, None, True)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.VOLUME_LIST, res, 'Unexpected volume list')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME_LIST)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test__get_volume_list_any_fldr(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case to find volume anywhere in the configured SC
|
|
res = self.scapi._get_volume_list(self.volume_name, None, False)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.VOLUME_LIST, res, 'Unexpected volume list')
|
|
|
|
def test_get_volume_list_no_name_no_id(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case specified volume name is None and device id is None.
|
|
res = self.scapi._get_volume_list(None, None, True)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test__get_volume_list_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case to find volume in the configured volume folder
|
|
res = self.scapi._get_volume_list(self.volume_name, None, True)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_search_for_volume',
|
|
return_value=VOLUME)
|
|
def test_find_volume(self,
|
|
mock_search_for_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case to find volume by name
|
|
res = self.scapi.find_volume(self.volume_name, None)
|
|
mock_search_for_volume.assert_called_once_with(self.volume_name)
|
|
self.assertEqual(self.VOLUME, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_search_for_volume',
|
|
return_value=None)
|
|
def test_find_volume_not_found(self,
|
|
mock_search_for_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case to find volume by name
|
|
res = self.scapi.find_volume(self.volume_name, None)
|
|
mock_search_for_volume.assert_called_once_with(self.volume_name)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume',
|
|
return_value=VOLUME)
|
|
def test_find_volume_with_provider_id(self,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
res = self.scapi.find_volume(self.volume_name, provider_id)
|
|
mock_get_volume.assert_called_once_with(provider_id)
|
|
self.assertEqual(self.VOLUME, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_search_for_volume',
|
|
return_value=VOLUME)
|
|
def test_find_volume_with_invalid_provider_id(self,
|
|
mock_search_for_volume,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = 'WrongSSN.1'
|
|
res = self.scapi.find_volume(self.volume_name, provider_id)
|
|
mock_search_for_volume.assert_called_once_with(self.volume_name)
|
|
self.assertFalse(mock_get_volume.called)
|
|
self.assertEqual(self.VOLUME, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume',
|
|
return_value=None)
|
|
def test_find_volume_with_provider_id_not_found(self,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
res = self.scapi.find_volume(self.volume_name, provider_id)
|
|
mock_get_volume.assert_called_once_with(provider_id)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_import_one',
|
|
return_value=VOLUME)
|
|
def test_find_volume_with_provider_id_complete_replication(
|
|
self,
|
|
mock_import_one,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
# Configure to middle of failover.
|
|
self.scapi.failed_over = True
|
|
mock_get_volume.return_value = {'name': self.repl_name}
|
|
res = self.scapi.find_volume(self.volume_name, provider_id)
|
|
self.scapi.failed_over = False
|
|
mock_import_one.assert_called_once_with(mock_get_volume.return_value,
|
|
self.volume_name)
|
|
mock_get_volume.assert_called_once_with(provider_id)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected volume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_import_one',
|
|
return_value=None)
|
|
def test_find_volume_with_provider_id_import_fail(self,
|
|
mock_import_one,
|
|
mock_get_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
# Configure to middle of failover.
|
|
self.scapi.failed_over = True
|
|
mock_get_volume.return_value = {'name': self.repl_name}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_volume, self.volume_name,
|
|
provider_id)
|
|
self.scapi.failed_over = False
|
|
mock_import_one.assert_called_once_with(mock_get_volume.return_value,
|
|
self.volume_name)
|
|
mock_get_volume.assert_called_once_with(provider_id)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=None)
|
|
def test_search_for_volume_no_name(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test calling find_volume with no name or instanceid
|
|
res = self.scapi._search_for_volume(None)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list')
|
|
def test_search_for_volume_not_found(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test calling find_volume with result of no volume found
|
|
mock_get_volume_list.side_effect = [[], []]
|
|
res = self.scapi._search_for_volume(self.volume_name)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=VOLUME_LIST_MULTI_VOLS)
|
|
def test_search_for_volume_multi_vols_found(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where multiple volumes are found
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi._search_for_volume, self.volume_name)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME)
|
|
def test_get_volume(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
res = self.scapi.get_volume(provider_id)
|
|
mock_get.assert_called_once_with(
|
|
'StorageCenter/ScVolume/' + provider_id)
|
|
self.assertEqual(self.VOLUME, res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_get_volume_error(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
res = self.scapi.get_volume(provider_id)
|
|
mock_get.assert_called_once_with(
|
|
'StorageCenter/ScVolume/' + provider_id)
|
|
self.assertIsNone(res)
|
|
|
|
def test_get_volume_no_id(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = None
|
|
res = self.scapi.get_volume(provider_id)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=VOLUME)
|
|
def test_delete_volume(self,
|
|
mock_find_volume,
|
|
mock_delete,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.delete_volume(self.volume_name)
|
|
self.assertTrue(mock_delete.called)
|
|
mock_find_volume.assert_called_once_with(self.volume_name, None)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=VOLUME)
|
|
def test_delete_volume_with_provider_id(self,
|
|
mock_find_volume,
|
|
mock_delete,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
res = self.scapi.delete_volume(self.volume_name, provider_id)
|
|
mock_find_volume.assert_called_once_with(self.volume_name, provider_id)
|
|
self.assertTrue(mock_delete.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=VOLUME)
|
|
def test_delete_volume_failure(self,
|
|
mock_find_volume,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
provider_id = str(self.scapi.ssn) + '.1'
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.delete_volume, self.volume_name,
|
|
provider_id)
|
|
mock_find_volume.assert_called_once_with(self.volume_name, provider_id)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=None)
|
|
def test_delete_volume_no_vol_found(self,
|
|
mock_find_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where volume to be deleted does not exist
|
|
res = self.scapi.delete_volume(self.volume_name, None)
|
|
mock_find_volume.assert_called_once_with(self.volume_name, None)
|
|
self.assertTrue(res, 'Expected True')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=SVR_FLDR)
|
|
def test_find_server_folder(self,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_server_folder(False)
|
|
mock_find_folder.assert_called_once_with(
|
|
'StorageCenter/ScServerFolder/GetList',
|
|
self.configuration.dell_sc_server_folder, 12345)
|
|
self.assertEqual(self.SVR_FLDR, res, 'Unexpected server folder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_create_folder_path',
|
|
return_value=SVR_FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=None)
|
|
def test_find_server_folder_create_folder(self,
|
|
mock_find_folder,
|
|
mock_create_folder_path,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where specified server folder is not found and must be
|
|
# created
|
|
res = self.scapi._find_server_folder(True)
|
|
mock_find_folder.assert_called_once_with(
|
|
'StorageCenter/ScServerFolder/GetList',
|
|
self.configuration.dell_sc_server_folder, 12345)
|
|
self.assertTrue(mock_create_folder_path.called)
|
|
self.assertEqual(self.SVR_FLDR, res, 'Unexpected server folder')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_folder',
|
|
return_value=None)
|
|
def test_find_server_folder_fail(self,
|
|
mock_find_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where _find_server_folder returns none
|
|
res = self.scapi._find_server_folder(
|
|
False)
|
|
mock_find_folder.assert_called_once_with(
|
|
'StorageCenter/ScServerFolder/GetList',
|
|
self.configuration.dell_sc_volume_folder, 12345)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_add_hba(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._add_hba(self.SCSERVER,
|
|
self.IQN)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_add_hba_fc(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
saveproto = self.scapi.protocol
|
|
self.scapi.protocol = 'FibreChannel'
|
|
res = self.scapi._add_hba(self.SCSERVER,
|
|
self.WWN)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(res)
|
|
self.scapi.protocol = saveproto
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_add_hba_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._add_hba(self.SCSERVER,
|
|
self.IQN)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SVR_OS_S)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_serveros(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_serveros('Red Hat Linux 6.x')
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertEqual('64702.38', res, 'Wrong InstanceId')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SVR_OS_S)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_serveros_not_found(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test requesting a Server OS that will not be found
|
|
res = self.scapi._find_serveros('Non existent OS')
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_find_serveros_failed(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_serveros('Red Hat Linux 6.x')
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=SVR_FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=FC_HBA)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_create_server',
|
|
return_value=SCSERVER)
|
|
def test_create_server_multiple_hbas(self,
|
|
mock_create_server,
|
|
mock_add_hba,
|
|
mock_find_server_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_server(self.WWNS, 'Red Hat Linux 6.x')
|
|
self.assertTrue(mock_create_server.called)
|
|
self.assertTrue(mock_add_hba.called)
|
|
self.assertEqual(self.SCSERVER, res, 'Unexpected ScServer')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=SCSERVER)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=SVR_FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serveros',
|
|
return_value='64702.38')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_server(self,
|
|
mock_post,
|
|
mock_find_serveros,
|
|
mock_find_server_folder,
|
|
mock_first_result,
|
|
mock_add_hba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_server(self.IQN, 'Red Hat Linux 6.x')
|
|
self.assertTrue(mock_find_serveros.called)
|
|
self.assertTrue(mock_find_server_folder.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertTrue(mock_add_hba.called)
|
|
self.assertEqual(self.SCSERVER, res, 'Unexpected ScServer')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=SCSERVER)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=SVR_FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serveros',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_server_os_not_found(self,
|
|
mock_post,
|
|
mock_find_serveros,
|
|
mock_find_server_folder,
|
|
mock_first_result,
|
|
mock_add_hba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_server(self.IQN, 'Red Hat Binux 6.x')
|
|
self.assertTrue(mock_find_serveros.called)
|
|
self.assertEqual(self.SCSERVER, res, 'Unexpected ScServer')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=SCSERVER)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serveros',
|
|
return_value='64702.38')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_server_fldr_not_found(self,
|
|
mock_post,
|
|
mock_find_serveros,
|
|
mock_find_server_folder,
|
|
mock_first_result,
|
|
mock_add_hba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_server(self.IQN, 'Red Hat Linux 6.x')
|
|
self.assertTrue(mock_find_server_folder.called)
|
|
self.assertEqual(self.SCSERVER, res, 'Unexpected ScServer')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=SCSERVER)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serveros',
|
|
return_value='64702.38')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_create_server_failure(self,
|
|
mock_post,
|
|
mock_find_serveros,
|
|
mock_find_server_folder,
|
|
mock_first_result,
|
|
mock_add_hba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_server(self.IQN, 'Red Hat Linux 6.x')
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serveros',
|
|
return_value='64702.38')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_server_not_found(self,
|
|
mock_post,
|
|
mock_find_serveros,
|
|
mock_find_server_folder,
|
|
mock_first_result,
|
|
mock_add_hba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test create server where _first_result is None
|
|
res = self.scapi.create_server(self.IQN, 'Red Hat Linux 6.x')
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_delete_server',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_hba',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=SCSERVER)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_server_folder',
|
|
return_value=SVR_FLDR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serveros',
|
|
return_value='64702.38')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_server_addhba_fail(self,
|
|
mock_post,
|
|
mock_find_serveros,
|
|
mock_find_server_folder,
|
|
mock_first_result,
|
|
mock_add_hba,
|
|
mock_delete_server,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Tests create server where add hba fails
|
|
res = self.scapi.create_server(self.IQN, 'Red Hat Linux 6.x')
|
|
self.assertTrue(mock_delete_server.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=SCSERVER)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serverhba',
|
|
return_value=ISCSI_HBA)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_server(self,
|
|
mock_post,
|
|
mock_find_serverhba,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_server(self.IQN)
|
|
self.assertTrue(mock_find_serverhba.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertIsNotNone(res, 'Expected ScServer')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serverhba',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_server_no_hba(self,
|
|
mock_post,
|
|
mock_find_serverhba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where a ScServer HBA does not exist with the specified IQN
|
|
# or WWN
|
|
res = self.scapi.find_server(self.IQN)
|
|
self.assertTrue(mock_find_serverhba.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_serverhba',
|
|
return_value=ISCSI_HBA)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_find_server_failure(self,
|
|
mock_post,
|
|
mock_find_serverhba,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where a ScServer does not exist with the specified
|
|
# ScServerHba
|
|
res = self.scapi.find_server(self.IQN)
|
|
self.assertTrue(mock_find_serverhba.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=ISCSI_HBA)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_serverhba(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_server(self.IQN)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertIsNotNone(res, 'Expected ScServerHba')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_find_serverhba_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where a ScServer does not exist with the specified
|
|
# ScServerHba
|
|
res = self.scapi.find_server(self.IQN)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=ISCSI_FLT_DOMAINS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_domains(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_domains(u'64702.5764839588723736074.69')
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(
|
|
self.ISCSI_FLT_DOMAINS, res, 'Unexpected ScIscsiFaultDomain')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_204)
|
|
def test_find_domains_error(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where get of ScControllerPort FaultDomainList fails
|
|
res = self.scapi._find_domains(u'64702.5764839588723736074.69')
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=FC_HBAS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_initiators(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_initiators(self.SCSERVER)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertIsNotNone(res, 'Expected WWN list')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_find_initiators_error(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where get of ScServer HbaList fails
|
|
res = self.scapi._find_initiators(self.SCSERVER)
|
|
self.assertListEqual([], res, 'Expected empty list')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_get_volume_count(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.get_volume_count(self.SCSERVER)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(len(self.MAPPINGS), res, 'Mapping count mismatch')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_get_volume_count_failure(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case of where get of ScServer MappingList fails
|
|
res = self.scapi.get_volume_count(self.SCSERVER)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertEqual(-1, res, 'Mapping count not -1')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_get_volume_count_no_volumes(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.get_volume_count(self.SCSERVER)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(len([]), res, 'Mapping count mismatch')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_mappings(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_mappings(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.MAPPINGS, res, 'Mapping mismatch')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_mappings_inactive_vol(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test getting volume mappings on inactive volume
|
|
res = self.scapi._find_mappings(self.INACTIVE_VOLUME)
|
|
self.assertFalse(mock_get.called)
|
|
self.assertEqual([], res, 'No mappings expected')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_find_mappings_failure(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case of where get of ScVolume MappingList fails
|
|
res = self.scapi._find_mappings(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertEqual([], res, 'Mapping count not empty')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_mappings_no_mappings(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume has no mappings
|
|
res = self.scapi._find_mappings(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual([], res, 'Mapping count mismatch')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=MAP_PROFILES)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_mapping_profiles(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume has no mappings
|
|
res = self.scapi._find_mapping_profiles(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.MAP_PROFILES, res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_find_mapping_profiles_error(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume has no mappings
|
|
res = self.scapi._find_mapping_profiles(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertEqual([], res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_controller_port(self,
|
|
mock_get,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_controller_port(u'64702.5764839588723736070.51')
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.CTRLR_PORT, res, 'ScControllerPort mismatch')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_204)
|
|
def test_find_controller_port_failure(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where get of ScVolume MappingList fails
|
|
res = self.scapi._find_controller_port(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=FC_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=FC_MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_initiators',
|
|
return_value=WWNS)
|
|
def test_find_wwns(self,
|
|
mock_find_initiators,
|
|
mock_find_mappings,
|
|
mock_find_controller_port,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lun, wwns, itmap = self.scapi.find_wwns(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_initiators.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_controller_port.called)
|
|
|
|
# The _find_controller_port is Mocked, so all mapping pairs
|
|
# will have the same WWN for the ScControllerPort
|
|
itmapCompare = {u'21000024FF30441C': [u'5000D31000FCBE36'],
|
|
u'21000024FF30441D':
|
|
[u'5000D31000FCBE36', u'5000D31000FCBE36']}
|
|
self.assertEqual(1, lun, 'Incorrect LUN')
|
|
self.assertIsNotNone(wwns, 'WWNs is None')
|
|
self.assertEqual(itmapCompare, itmap, 'WWN mapping incorrect')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_initiators',
|
|
return_value=FC_HBAS)
|
|
def test_find_wwns_no_mappings(self,
|
|
mock_find_initiators,
|
|
mock_find_mappings,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where there are no ScMapping(s)
|
|
lun, wwns, itmap = self.scapi.find_wwns(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_initiators.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertIsNone(lun, 'Incorrect LUN')
|
|
self.assertEqual([], wwns, 'WWNs is not empty')
|
|
self.assertEqual({}, itmap, 'WWN mapping not empty')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=FC_MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_initiators',
|
|
return_value=WWNS)
|
|
def test_find_wwns_no_ctlr_port(self,
|
|
mock_find_initiators,
|
|
mock_find_mappings,
|
|
mock_find_controller_port,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScControllerPort is none
|
|
lun, wwns, itmap = self.scapi.find_wwns(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_initiators.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_controller_port.called)
|
|
self.assertIsNone(lun, 'Incorrect LUN')
|
|
self.assertEqual([], wwns, 'WWNs is not empty')
|
|
self.assertEqual({}, itmap, 'WWN mapping not empty')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=FC_CTRLR_PORT_WWN_ERROR)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=FC_MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_initiators',
|
|
return_value=WWNS)
|
|
def test_find_wwns_wwn_resilient(self,
|
|
mock_find_initiators,
|
|
mock_find_mappings,
|
|
mock_find_controller_port,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScControllerPort object has wWN instead of wwn (as
|
|
# seen in some cases) for a property but we are still able to find it.
|
|
lun, wwns, itmap = self.scapi.find_wwns(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_initiators.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_controller_port.called)
|
|
|
|
self.assertEqual(1, lun, 'Incorrect LUN')
|
|
expected_wwn = ['5000D31000FCBE36', '5000D31000FCBE36',
|
|
'5000D31000FCBE36']
|
|
self.assertEqual(expected_wwn, wwns, 'WWNs incorrect')
|
|
expected_itmap = {'21000024FF30441C': ['5000D31000FCBE36'],
|
|
'21000024FF30441D': ['5000D31000FCBE36',
|
|
'5000D31000FCBE36']}
|
|
self.assertEqual(expected_itmap, itmap, 'WWN mapping incorrect')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=FC_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=FC_MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_initiators',
|
|
return_value=WWNS_NO_MATCH)
|
|
# Test case where HBA name is not found in list of initiators
|
|
def test_find_wwns_hbaname_not_found(self,
|
|
mock_find_initiators,
|
|
mock_find_mappings,
|
|
mock_find_controller_port,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lun, wwns, itmap = self.scapi.find_wwns(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_initiators.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_controller_port.called)
|
|
|
|
self.assertIsNone(lun, 'Incorrect LUN')
|
|
self.assertEqual([], wwns, 'WWNs is not empty')
|
|
self.assertEqual({}, itmap, 'WWN mapping not empty')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=FC_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=FC_MAPPINGS_LUN_MISMATCH)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_initiators',
|
|
return_value=WWNS)
|
|
# Test case where FC mappings contain a LUN mismatch
|
|
def test_find_wwns_lun_mismatch(self,
|
|
mock_find_initiators,
|
|
mock_find_mappings,
|
|
mock_find_controller_port,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lun, wwns, itmap = self.scapi.find_wwns(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_initiators.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_controller_port.called)
|
|
# The _find_controller_port is Mocked, so all mapping pairs
|
|
# will have the same WWN for the ScControllerPort
|
|
itmapCompare = {u'21000024FF30441C': [u'5000D31000FCBE36'],
|
|
u'21000024FF30441D':
|
|
[u'5000D31000FCBE36', u'5000D31000FCBE36']}
|
|
self.assertEqual(1, lun, 'Incorrect LUN')
|
|
self.assertIsNotNone(wwns, 'WWNs is None')
|
|
self.assertEqual(itmapCompare, itmap, 'WWN mapping incorrect')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=VOLUME_CONFIG)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_active_controller(self,
|
|
mock_get,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_active_controller(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual('64702.64703', res, 'Unexpected Active Controller')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_find_active_controller_failure(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case of where get of ScVolume MappingList fails
|
|
res = self.scapi._find_active_controller(self.VOLUME)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.5764839588723736131.91')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_domains',
|
|
return_value=ISCSI_FLT_DOMAINS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_mappings(self,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_domains,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_domains.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1],
|
|
'target_portal': u'192.168.0.21:3260',
|
|
'target_portals': [u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.5764839588723736131.91')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_domains',
|
|
return_value=ISCSI_FLT_DOMAINS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_multiple_servers_mapped(
|
|
self, mock_is_virtualport_mode, mock_find_mappings,
|
|
mock_find_domains, mock_find_ctrl_port,
|
|
mock_find_active_controller, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
mappings = [{'instanceId': '64702.970.64702',
|
|
'server': {'instanceId': '64702.47'},
|
|
'volume': {'instanceId': '64702.92'}}]
|
|
mappings.append(self.MAPPINGS[0].copy())
|
|
scserver = {'instanceId': '64702.30'}
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_domains.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1],
|
|
'target_portal': u'192.168.0.21:3260',
|
|
'target_portals': [u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=[])
|
|
def test_find_iscsi_properties_no_mapping(self,
|
|
mock_find_mappings,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
# Test case where there are no ScMapping(s)
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_iscsi_properties,
|
|
self.VOLUME,
|
|
scserver)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_domains',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_no_domain(self,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_domains,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
# Test case where there are no ScFaultDomain(s)
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_iscsi_properties,
|
|
self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_domains.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_no_ctrl_port(self,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
# Test case where there are no ScFaultDomain(s)
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_iscsi_properties,
|
|
self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_domains',
|
|
return_value=ISCSI_FLT_DOMAINS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS_READ_ONLY)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_ro(self,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_domains,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
# Test case where Read Only mappings are found
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_domains.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1],
|
|
'target_portal': u'192.168.0.21:3260',
|
|
'target_portals': [u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_domains',
|
|
return_value=ISCSI_FLT_DOMAINS_MULTI_PORTALS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS_MULTI_PORTAL)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_multi_portals(self,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_domains,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where there are multiple portals
|
|
mock_find_ctrl_port.side_effect = [
|
|
{'iscsiName': 'iqn.2002-03.com.compellent:5000d31000fcbe43'},
|
|
{'iscsiName': 'iqn.2002-03.com.compellent:5000d31000fcbe44'}]
|
|
scserver = {'instanceId': '64702.30'}
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_domains.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe44',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe44',
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe44'],
|
|
'target_lun': 1,
|
|
'target_luns': [1, 1, 1, 1],
|
|
'target_portal': u'192.168.0.25:3260',
|
|
'target_portals': [u'192.168.0.25:3260',
|
|
u'192.168.0.21:3260',
|
|
u'192.168.0.25:3260',
|
|
u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_domains',
|
|
return_value=ISCSI_FLT_DOMAINS_MULTI_PORTALS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS_MULTI_PORTAL)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=True)
|
|
def test_find_iscsi_properties_multi_portals_duplicates(
|
|
self,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_domains,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where there are multiple portals and
|
|
mock_find_ctrl_port.return_value = {
|
|
'iscsiName': 'iqn.2002-03.com.compellent:5000d31000fcbe43'}
|
|
scserver = {'instanceId': '64702.30'}
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_domains.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1, 1],
|
|
'target_portal': u'192.168.0.25:3260',
|
|
'target_portals': [u'192.168.0.25:3260',
|
|
u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.5764839588723736131.91')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port_iscsi_config',
|
|
return_value=ISCSI_CONFIG)
|
|
def test_find_iscsi_properties_mappings_legacy(
|
|
self,
|
|
mock_find_controller_port_iscsi_config,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_controller_port_iscsi_config.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1],
|
|
'target_portal': u'192.168.0.21:3260',
|
|
'target_portals': [u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.5764839588723736131.91')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port_iscsi_config',
|
|
return_value=None)
|
|
def test_find_iscsi_properties_mappings_legacy_no_iscsi_config(
|
|
self,
|
|
mock_find_controller_port_iscsi_config,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_iscsi_properties,
|
|
self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_controller_port_iscsi_config.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port',
|
|
return_value=ISCSI_CTRLR_PORT)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS_READ_ONLY)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port_iscsi_config',
|
|
return_value=ISCSI_CONFIG)
|
|
def test_find_iscsi_properties_ro_legacy(self,
|
|
mock_find_iscsi_config,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scserver = {'instanceId': '64702.30'}
|
|
# Test case where Read Only mappings are found
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
self.assertTrue(mock_find_iscsi_config.called)
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1],
|
|
'target_portal': u'192.168.0.21:3260',
|
|
'target_portals': [u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_active_controller',
|
|
return_value='64702.64702')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=MAPPINGS_MULTI_PORTAL)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_is_virtualport_mode',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_controller_port_iscsi_config',
|
|
return_value=ISCSI_CONFIG)
|
|
def test_find_iscsi_properties_multi_portals_legacy(
|
|
self,
|
|
mock_find_controller_port_iscsi_config,
|
|
mock_is_virtualport_mode,
|
|
mock_find_mappings,
|
|
mock_find_ctrl_port,
|
|
mock_find_active_controller,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_find_ctrl_port.side_effect = [
|
|
{'iscsiName': 'iqn.2002-03.com.compellent:5000d31000fcbe43'},
|
|
{'iscsiName': 'iqn.2002-03.com.compellent:5000d31000fcbe44'}]
|
|
scserver = {'instanceId': '64702.30'}
|
|
# Test case where there are multiple portals
|
|
res = self.scapi.find_iscsi_properties(self.VOLUME, scserver)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_find_ctrl_port.called)
|
|
self.assertTrue(mock_find_active_controller.called)
|
|
self.assertTrue(mock_is_virtualport_mode.called)
|
|
self.assertTrue(mock_find_controller_port_iscsi_config.called)
|
|
# We're feeding the same info back multiple times the information
|
|
# will be scrubbed to a single item.
|
|
expected = {'target_discovered': False,
|
|
'target_iqn':
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe44',
|
|
'target_iqns':
|
|
[u'iqn.2002-03.com.compellent:5000d31000fcbe44',
|
|
u'iqn.2002-03.com.compellent:5000d31000fcbe43'],
|
|
'target_lun': 1,
|
|
'target_luns': [1, 1],
|
|
'target_portal': u'192.168.0.21:3260',
|
|
'target_portals': [u'192.168.0.21:3260',
|
|
u'192.168.0.21:3260']}
|
|
self.assertEqual(expected, res, 'Wrong Target Info')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=MAP_PROFILE)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=[])
|
|
def test_map_volume(self,
|
|
mock_find_mapping_profiles,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.map_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mapping_profiles.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.MAP_PROFILE, res, 'Incorrect ScMappingProfile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=MAP_PROFILE)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=MAP_PROFILES)
|
|
def test_map_volume_existing_mapping(self,
|
|
mock_find_mappings,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.map_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertFalse(mock_post.called)
|
|
self.assertFalse(mock_first_result.called)
|
|
self.assertEqual(self.MAP_PROFILE, res, 'Incorrect ScMappingProfile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=MAP_PROFILE)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=[])
|
|
def test_map_volume_existing_mapping_not_us(self,
|
|
mock_find_mappings,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
server = {'instanceId': 64702.48, 'name': 'Server X'}
|
|
res = self.scapi.map_volume(self.VOLUME,
|
|
server)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.MAP_PROFILE, res, 'Incorrect ScMappingProfile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_map_volume_no_vol_id(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_get_id,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume instanceId is None
|
|
mock_get_id.side_effect = [None, '64702.47']
|
|
res = self.scapi.map_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertFalse(mock_post.called)
|
|
self.assertFalse(mock_first_result.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_map_volume_no_server_id(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_get_id,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume instanceId is None
|
|
mock_get_id.side_effect = ['64702.3494', None]
|
|
res = self.scapi.map_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertFalse(mock_post.called)
|
|
self.assertFalse(mock_first_result.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=[])
|
|
def test_map_volume_failure(self,
|
|
mock_find_mapping_profiles,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where mapping volume to server fails
|
|
res = self.scapi.map_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mapping_profiles.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=MAP_PROFILES)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value={'result': True})
|
|
def test_unmap_volume(self,
|
|
mock_get_json,
|
|
mock_find_mapping_profiles,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.unmap_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mapping_profiles.called)
|
|
self.assertTrue(mock_delete.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=MAP_PROFILES)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_204)
|
|
def test_unmap_volume_failure(self,
|
|
mock_delete,
|
|
mock_find_mapping_profiles,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.unmap_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mapping_profiles.called)
|
|
self.assertTrue(mock_delete.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=[])
|
|
def test_unmap_volume_no_map_profile(self,
|
|
mock_find_mapping_profiles,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.unmap_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mapping_profiles.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_204)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=MAP_PROFILES)
|
|
def test_unmap_volume_del_fail(self,
|
|
mock_find_mapping_profiles,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.unmap_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertTrue(mock_find_mapping_profiles.called)
|
|
self.assertTrue(mock_delete.called)
|
|
self.assertFalse(res, False)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=MAP_PROFILES)
|
|
def test_unmap_volume_no_vol_id(self,
|
|
mock_find_mapping_profiles,
|
|
mock_delete,
|
|
mock_get_id,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume instanceId = None
|
|
mock_get_id.side_effect = [None, '64702.47']
|
|
res = self.scapi.unmap_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertFalse(mock_find_mapping_profiles.called)
|
|
self.assertFalse(mock_delete.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles',
|
|
return_value=MAP_PROFILES)
|
|
def test_unmap_volume_no_server_id(self,
|
|
mock_find_mapping_profiles,
|
|
mock_delete,
|
|
mock_get_id,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where ScVolume instanceId = None
|
|
mock_get_id.side_effect = ['64702.3494', None]
|
|
res = self.scapi.unmap_volume(self.VOLUME,
|
|
self.SCSERVER)
|
|
self.assertFalse(mock_find_mapping_profiles.called)
|
|
self.assertFalse(mock_delete.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test_unmap_all(self, mock_get_json, mock_find_mapping_profiles,
|
|
mock_get, mock_delete, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
mock_delete.return_value = self.RESPONSE_200
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_find_mapping_profiles.return_value = [
|
|
{'instanceId': '12345.0.1',
|
|
'server': {'instanceId': '12345.100', 'instanceName': 'Srv1'}},
|
|
{'instanceId': '12345.0.2',
|
|
'server': {'instanceId': '12345.101', 'instanceName': 'Srv2'}},
|
|
{'instanceId': '12345.0.3',
|
|
'server': {'instanceId': '12345.102', 'instanceName': 'Srv3'}},
|
|
]
|
|
# server, result pairs
|
|
mock_get_json.side_effect = [
|
|
{'instanceId': '12345.100', 'instanceName': 'Srv1',
|
|
'type': 'Physical'},
|
|
{'result': True},
|
|
{'instanceId': '12345.101', 'instanceName': 'Srv2',
|
|
'type': 'Physical'},
|
|
{'result': True},
|
|
{'instanceId': '12345.102', 'instanceName': 'Srv3',
|
|
'type': 'Physical'},
|
|
{'result': True}
|
|
]
|
|
vol = {'instanceId': '12345.0', 'name': 'vol1'}
|
|
res = self.scapi.unmap_all(vol)
|
|
# Success and 3 delete calls
|
|
self.assertTrue(res)
|
|
self.assertEqual(3, mock_delete.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test_unmap_all_with_remote(self, mock_get_json,
|
|
mock_find_mapping_profiles, mock_get,
|
|
mock_delete, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
mock_delete.return_value = self.RESPONSE_200
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_find_mapping_profiles.return_value = [
|
|
{'instanceId': '12345.0.1',
|
|
'server': {'instanceId': '12345.100', 'instanceName': 'Srv1'}},
|
|
{'instanceId': '12345.0.2',
|
|
'server': {'instanceId': '12345.101', 'instanceName': 'Srv2'}},
|
|
{'instanceId': '12345.0.3',
|
|
'server': {'instanceId': '12345.102', 'instanceName': 'Srv3'}},
|
|
]
|
|
# server, result pairs
|
|
mock_get_json.side_effect = [
|
|
{'instanceId': '12345.100', 'instanceName': 'Srv1',
|
|
'type': 'Physical'},
|
|
{'result': True},
|
|
{'instanceId': '12345.101', 'instanceName': 'Srv2',
|
|
'type': 'RemoteStorageCenter'},
|
|
{'instanceId': '12345.102', 'instanceName': 'Srv3',
|
|
'type': 'Physical'},
|
|
{'result': True}
|
|
]
|
|
vol = {'instanceId': '12345.0', 'name': 'vol1'}
|
|
res = self.scapi.unmap_all(vol)
|
|
# Should succeed but call delete only twice
|
|
self.assertTrue(res)
|
|
self.assertEqual(2, mock_delete.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test_unmap_all_fail(self, mock_get_json, mock_find_mapping_profiles,
|
|
mock_get, mock_delete, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
mock_delete.return_value = self.RESPONSE_400
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_find_mapping_profiles.return_value = [
|
|
{'instanceId': '12345.0.1',
|
|
'server': {'instanceId': '12345.100', 'instanceName': 'Srv1'}},
|
|
{'instanceId': '12345.0.2',
|
|
'server': {'instanceId': '12345.101', 'instanceName': 'Srv2'}},
|
|
{'instanceId': '12345.0.3',
|
|
'server': {'instanceId': '12345.102', 'instanceName': 'Srv3'}},
|
|
]
|
|
# server, result pairs
|
|
mock_get_json.side_effect = [
|
|
{'instanceId': '12345.100', 'instanceName': 'Srv1',
|
|
'type': 'Physical'}
|
|
]
|
|
vol = {'instanceId': '12345.0', 'name': 'vol1'}
|
|
res = self.scapi.unmap_all(vol)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mapping_profiles')
|
|
def test_unmap_all_no_profiles(self, mock_find_mapping_profiles,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_mapping_profiles.return_value = []
|
|
vol = {'instanceId': '12345.0', 'name': 'vol1'}
|
|
res = self.scapi.unmap_all(vol)
|
|
# Should exit with success.
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[{'a': 1}, {'a': 2}])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_controller_port_iscsi_config(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Not much to test here. Just make sure we call our stuff and
|
|
# that we return the first item returned to us.
|
|
res = self.scapi._find_controller_port_iscsi_config('guid')
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual({'a': 1}, res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_find_controller_port_iscsi_config_err(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_controller_port_iscsi_config('guid')
|
|
self.assertTrue(mock_get.called)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=STRG_USAGE)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_get_storage_usage(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.get_storage_usage()
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.STRG_USAGE, res, 'Unexpected ScStorageUsage')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_204)
|
|
def test_get_storage_usage_no_ssn(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where SSN is none
|
|
self.scapi.ssn = None
|
|
res = self.scapi.get_storage_usage()
|
|
self.scapi.ssn = 12345
|
|
self.assertFalse(mock_get.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_204)
|
|
# Test case where get of Storage Usage fails
|
|
def test_get_storage_usage_failure(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.get_storage_usage()
|
|
self.assertTrue(mock_get.called)
|
|
self.assertIsNone(res, 'None expected')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=RPLAY)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_replay(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_replay(self.VOLUME,
|
|
'Test Replay',
|
|
60)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.RPLAY, res, 'Unexpected ScReplay')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=RPLAY)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_init_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_replay_inact_vol(self,
|
|
mock_post,
|
|
mock_get_volume,
|
|
mock_init_volume,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where the specified volume is inactive
|
|
mock_get_volume.return_value = self.VOLUME
|
|
res = self.scapi.create_replay(self.INACTIVE_VOLUME,
|
|
'Test Replay',
|
|
60)
|
|
self.assertTrue(mock_post.called)
|
|
mock_init_volume.assert_called_once_with(self.INACTIVE_VOLUME)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.RPLAY, res, 'Unexpected ScReplay')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_init_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_volume')
|
|
def test_create_replay_inact_vol_init_fail(
|
|
self, mock_get_volume, mock_init_volume, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
# Test case where the specified volume is inactive
|
|
mock_get_volume.return_value = self.INACTIVE_VOLUME
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_replay,
|
|
self.INACTIVE_VOLUME, 'Test Replay', 60)
|
|
mock_init_volume.assert_called_once_with(self.INACTIVE_VOLUME)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=RPLAY)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_replay_no_expire(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_replay(self.VOLUME,
|
|
'Test Replay',
|
|
0)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.RPLAY, res, 'Unexpected ScReplay')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_replay_no_volume(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where no ScVolume is specified
|
|
res = self.scapi.create_replay(None,
|
|
'Test Replay',
|
|
60)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_create_replay_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where create ScReplay fails
|
|
res = self.scapi.create_replay(self.VOLUME,
|
|
'Test Replay',
|
|
60)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=RPLAYS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_replay(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_replay(self.VOLUME,
|
|
u'Cinder Test Replay012345678910')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.TST_RPLAY, res, 'Unexpected ScReplay')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_replay_no_replays(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where no replays are found
|
|
res = self.scapi.find_replay(self.VOLUME,
|
|
u'Cinder Test Replay012345678910')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_204)
|
|
def test_find_replay_failure(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where None is returned for replays
|
|
res = self.scapi.find_replay(self.VOLUME,
|
|
u'Cinder Test Replay012345678910')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay',
|
|
return_value=RPLAYS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_delete_replay(self,
|
|
mock_post,
|
|
mock_find_replay,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
replayId = u'Cinder Test Replay012345678910'
|
|
res = self.scapi.delete_replay(self.VOLUME,
|
|
replayId)
|
|
self.assertTrue(mock_post.called)
|
|
mock_find_replay.assert_called_once_with(self.VOLUME, replayId)
|
|
self.assertTrue(res, 'Expected True')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_delete_replay_no_replay(self,
|
|
mock_post,
|
|
mock_find_replay,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where specified ScReplay does not exist
|
|
replayId = u'Cinder Test Replay012345678910'
|
|
res = self.scapi.delete_replay(self.VOLUME,
|
|
replayId)
|
|
self.assertFalse(mock_post.called)
|
|
mock_find_replay.assert_called_once_with(self.VOLUME, replayId)
|
|
self.assertTrue(res, 'Expected True')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay',
|
|
return_value=TST_RPLAY)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_delete_replay_failure(self,
|
|
mock_post,
|
|
mock_find_replay,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where delete ScReplay results in an error
|
|
replayId = u'Cinder Test Replay012345678910'
|
|
res = self.scapi.delete_replay(self.VOLUME,
|
|
replayId)
|
|
self.assertTrue(mock_post.called)
|
|
mock_find_replay.assert_called_once_with(self.VOLUME, replayId)
|
|
self.assertFalse(res, 'Expected False')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_view_volume(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
vol_name = u'Test_create_vol'
|
|
res = self.scapi.create_view_volume(
|
|
vol_name, self.TST_RPLAY, None, None, None, None)
|
|
self.assertTrue(mock_post.called)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_view_volume_create_fldr(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where volume folder does not exist and must be created
|
|
vol_name = u'Test_create_vol'
|
|
res = self.scapi.create_view_volume(
|
|
vol_name, self.TST_RPLAY, None, None, None, None)
|
|
self.assertTrue(mock_post.called)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_create_view_volume_no_vol_fldr(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where volume folder does not exist and cannot be created
|
|
vol_name = u'Test_create_vol'
|
|
res = self.scapi.create_view_volume(
|
|
vol_name, self.TST_RPLAY, None, None, None, None)
|
|
self.assertTrue(mock_post.called)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder',
|
|
return_value=FLDR)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_create_view_volume_failure(self,
|
|
mock_post,
|
|
mock_find_volume_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where view volume create fails
|
|
vol_name = u'Test_create_vol'
|
|
res = self.scapi.create_view_volume(
|
|
vol_name, self.TST_RPLAY, None, None, None, None)
|
|
self.assertTrue(mock_post.called)
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_replay_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'update_datareduction_profile')
|
|
def test_create_view_volume_with_profiles(
|
|
self, mock_update_datareduction_profile, mock_find_replay_profiles,
|
|
mock_find_qos_profile, mock_post, mock_find_volume_folder,
|
|
mock_first_result, mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_replay_profiles.return_value = (['12345.4'], [])
|
|
mock_first_result.return_value = {'name': 'name'}
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_find_volume_folder.return_value = {'instanceId': '12345.200'}
|
|
mock_find_qos_profile.side_effect = [{'instanceId': '12345.2'},
|
|
{'instanceId': '12345.3'}]
|
|
screplay = {'instanceId': '12345.100.1'}
|
|
res = self.scapi.create_view_volume(
|
|
'name', screplay, 'replay_profile_string', 'volume_qos',
|
|
'group_qos', 'datareductionprofile')
|
|
expected_payload = {'Name': 'name',
|
|
'Notes': 'Created by Dell EMC Cinder Driver',
|
|
'VolumeFolder': '12345.200',
|
|
'ReplayProfileList': ['12345.4'],
|
|
'VolumeQosProfile': '12345.2',
|
|
'GroupQosProfile': '12345.3'}
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScReplay/12345.100.1/CreateView', expected_payload,
|
|
True)
|
|
mock_update_datareduction_profile.assert_called_once_with(
|
|
{'name': 'name'}, 'datareductionprofile')
|
|
self.assertEqual({'name': 'name'}, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_replay_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'update_datareduction_profile')
|
|
def test_create_view_volume_with_profiles_no_dr(
|
|
self, mock_update_datareduction_profile, mock_find_replay_profiles,
|
|
mock_find_qos_profile, mock_post, mock_find_volume_folder,
|
|
mock_first_result, mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_replay_profiles.return_value = (['12345.4'], [])
|
|
mock_first_result.return_value = {'name': 'name'}
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_find_volume_folder.return_value = {'instanceId': '12345.200'}
|
|
mock_find_qos_profile.side_effect = [{'instanceId': '12345.2'},
|
|
{'instanceId': '12345.3'}]
|
|
screplay = {'instanceId': '12345.100.1'}
|
|
res = self.scapi.create_view_volume('name', screplay,
|
|
'replay_profile_string',
|
|
'volume_qos',
|
|
'group_qos',
|
|
None)
|
|
expected_payload = {'Name': 'name',
|
|
'Notes': 'Created by Dell EMC Cinder Driver',
|
|
'VolumeFolder': '12345.200',
|
|
'ReplayProfileList': ['12345.4'],
|
|
'VolumeQosProfile': '12345.2',
|
|
'GroupQosProfile': '12345.3'}
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScReplay/12345.100.1/CreateView', expected_payload,
|
|
True)
|
|
mock_update_datareduction_profile.assert_not_called()
|
|
self.assertEqual({'name': 'name'}, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_create_view_volume_with_profiles_no_replayprofiles(
|
|
self, mock_find_qos_profile, mock_post, mock_find_volume_folder,
|
|
mock_first_result, mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_first_result.return_value = {'name': 'name'}
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_find_volume_folder.return_value = {'instanceId': '12345.200'}
|
|
mock_find_qos_profile.side_effect = [{'instanceId': '12345.2'},
|
|
{'instanceId': '12345.3'}]
|
|
screplay = {'instanceId': '12345.100.1'}
|
|
res = self.scapi.create_view_volume('name', screplay,
|
|
None,
|
|
'volume_qos',
|
|
'group_qos',
|
|
None)
|
|
expected_payload = {'Name': 'name',
|
|
'Notes': 'Created by Dell EMC Cinder Driver',
|
|
'VolumeFolder': '12345.200',
|
|
'VolumeQosProfile': '12345.2',
|
|
'GroupQosProfile': '12345.3'}
|
|
mock_find_volume_folder.assert_called_once_with(True)
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScReplay/12345.100.1/CreateView', expected_payload,
|
|
True)
|
|
self.assertEqual({'name': 'name'}, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_replay_profiles')
|
|
def test_create_view_volume_with_profiles_not_found(
|
|
self, mock_find_replay_profiles, mock_find_qos_profile,
|
|
mock_find_volume_folder, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
mock_find_replay_profiles.return_value = (['12345.4'], [])
|
|
mock_find_volume_folder.return_value = {'instanceId': '12345.200'}
|
|
# Our qos profile isn't found.
|
|
mock_find_qos_profile.return_value = None
|
|
screplay = {'instanceId': '12345.100.1'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_view_volume,
|
|
'name', screplay, 'replay_profile_string',
|
|
'volume_qos', 'group_qos', 'datareductionprofile')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test__expire_all_replays(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvolume = {'instanceId': '12345.1'}
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = [{'instanceId': '12345.100',
|
|
'active': False},
|
|
{'instanceId': '12345.101',
|
|
'active': True}]
|
|
self.scapi._expire_all_replays(scvolume)
|
|
mock_get.assert_called_once_with(
|
|
'StorageCenter/ScVolume/12345.1/ReplayList')
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScReplay/12345.100/Expire', {}, True)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
def test__expire_all_replays_error(self,
|
|
mock_get,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvolume = {'instanceId': '12345.1'}
|
|
mock_get.return_value = self.RESPONSE_400
|
|
self.scapi._expire_all_replays(scvolume)
|
|
mock_get.assert_called_once_with(
|
|
'StorageCenter/ScVolume/12345.1/ReplayList')
|
|
self.assertFalse(mock_post.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test__expire_all_replays_no_replays(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvolume = {'instanceId': '12345.1'}
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = None
|
|
self.scapi._expire_all_replays(scvolume)
|
|
mock_get.assert_called_once_with(
|
|
'StorageCenter/ScVolume/12345.1/ReplayList')
|
|
self.assertFalse(mock_post.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test__wait_for_cmm(
|
|
self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
cmm = {'instanceId': '12345.300'}
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1'}
|
|
replayid = '12345.200'
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = {'instanceId': '12345.300',
|
|
'state': 'Finished'}
|
|
ret = self.scapi._wait_for_cmm(cmm, scvolume, replayid)
|
|
self.assertTrue(ret)
|
|
mock_get_json.return_value['state'] = 'Erred'
|
|
ret = self.scapi._wait_for_cmm(cmm, scvolume, replayid)
|
|
self.assertFalse(ret)
|
|
mock_get_json.return_value['state'] = 'Paused'
|
|
ret = self.scapi._wait_for_cmm(cmm, scvolume, replayid)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay')
|
|
def test__wait_for_cmm_404(
|
|
self,
|
|
mock_find_replay,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
cmm = {'instanceId': '12345.300'}
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1'}
|
|
replayid = '12345.200'
|
|
mock_get.return_value = self.RESPONSE_404
|
|
mock_find_replay.return_value = {'instanceId': '12345.200'}
|
|
ret = self.scapi._wait_for_cmm(cmm, scvolume, replayid)
|
|
self.assertTrue(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay')
|
|
@mock.patch.object(eventlet, 'sleep')
|
|
def test__wait_for_cmm_timeout(
|
|
self,
|
|
mock_sleep,
|
|
mock_find_replay,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
cmm = {'instanceId': '12345.300'}
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1'}
|
|
replayid = '12345.200'
|
|
mock_get.return_value = self.RESPONSE_404
|
|
mock_find_replay.return_value = None
|
|
ret = self.scapi._wait_for_cmm(cmm, scvolume, replayid)
|
|
self.assertFalse(ret)
|
|
self.assertEqual(21, mock_sleep.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(uuid, 'uuid4')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_wait_for_cmm')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_expire_all_replays')
|
|
def test_create_cloned_volume(
|
|
self,
|
|
mock_expire_all_replays,
|
|
mock_wait_for_cmm,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_uuid4,
|
|
mock_create_replay,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = {'instanceId': '12345.2',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
cmm = {'state': 'Running'}
|
|
|
|
# our call returns
|
|
replayuuid = uuid.uuid4()
|
|
mock_uuid4.return_value = replayuuid
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = cmm
|
|
mock_create_replay.return_value = {'instanceId': '12345.100'}
|
|
mock_create_volume.return_value = newvol
|
|
mock_wait_for_cmm.return_value = True
|
|
|
|
# our call
|
|
res = self.scapi.create_cloned_volume(
|
|
vol_name, scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
mock_create_replay.assert_called_once_with(
|
|
scvolume, str(replayuuid), 60)
|
|
expected_payload = {}
|
|
expected_payload['CopyReplays'] = True
|
|
expected_payload['DestinationVolume'] = '12345.2'
|
|
expected_payload['SourceVolume'] = '12345.1'
|
|
expected_payload['StorageCenter'] = 12345
|
|
expected_payload['Priority'] = 'High'
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScCopyMirrorMigrate/Copy', expected_payload, True)
|
|
mock_wait_for_cmm.assert_called_once_with(cmm, newvol, str(replayuuid))
|
|
mock_expire_all_replays.assert_called_once_with(newvol)
|
|
self.assertEqual(newvol, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
def test_create_cloned_volume_create_vol_fail(
|
|
self,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = None
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
|
|
# our call returns
|
|
mock_create_volume.return_value = newvol
|
|
|
|
# our call
|
|
res = self.scapi.create_cloned_volume(
|
|
vol_name, scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(uuid, 'uuid4')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'delete_volume')
|
|
def test_create_cloned_volume_replay_fail(
|
|
self,
|
|
mock_delete_volume,
|
|
mock_uuid4,
|
|
mock_create_replay,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = {'instanceId': '12345.2',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
|
|
# our call returns
|
|
replayuuid = uuid.uuid4()
|
|
mock_uuid4.return_value = replayuuid
|
|
mock_create_replay.return_value = None
|
|
mock_create_volume.return_value = newvol
|
|
|
|
# our call
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_cloned_volume, vol_name,
|
|
scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
mock_create_replay.assert_called_once_with(
|
|
scvolume, str(replayuuid), 60)
|
|
mock_delete_volume.assert_called_once_with(vol_name, '12345.2')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(uuid, 'uuid4')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'delete_volume')
|
|
def test_create_cloned_volume_copy_fail(
|
|
self,
|
|
mock_delete_volume,
|
|
mock_post,
|
|
mock_uuid4,
|
|
mock_create_replay,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = {'instanceId': '12345.2',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
|
|
# our call returns
|
|
replayuuid = uuid.uuid4()
|
|
mock_uuid4.return_value = replayuuid
|
|
mock_post.return_value = self.RESPONSE_400
|
|
mock_create_replay.return_value = {'instanceId': '12345.100'}
|
|
mock_create_volume.return_value = newvol
|
|
|
|
# our call
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_cloned_volume, vol_name,
|
|
scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
mock_create_replay.assert_called_once_with(
|
|
scvolume, str(replayuuid), 60)
|
|
expected_payload = {}
|
|
expected_payload['CopyReplays'] = True
|
|
expected_payload['DestinationVolume'] = '12345.2'
|
|
expected_payload['SourceVolume'] = '12345.1'
|
|
expected_payload['StorageCenter'] = 12345
|
|
expected_payload['Priority'] = 'High'
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScCopyMirrorMigrate/Copy', expected_payload, True)
|
|
mock_delete_volume.assert_called_once_with(vol_name, '12345.2')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(uuid, 'uuid4')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'delete_volume')
|
|
def test_create_cloned_volume_cmm_erred(
|
|
self,
|
|
mock_delete_volume,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_uuid4,
|
|
mock_create_replay,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = {'instanceId': '12345.2',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
cmm = {'state': 'Erred'}
|
|
|
|
# our call returns
|
|
replayuuid = uuid.uuid4()
|
|
mock_uuid4.return_value = replayuuid
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = cmm
|
|
mock_create_replay.return_value = {'instanceId': '12345.100'}
|
|
mock_create_volume.return_value = newvol
|
|
|
|
# our call
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_cloned_volume, vol_name,
|
|
scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
mock_create_replay.assert_called_once_with(
|
|
scvolume, str(replayuuid), 60)
|
|
expected_payload = {}
|
|
expected_payload['CopyReplays'] = True
|
|
expected_payload['DestinationVolume'] = '12345.2'
|
|
expected_payload['SourceVolume'] = '12345.1'
|
|
expected_payload['StorageCenter'] = 12345
|
|
expected_payload['Priority'] = 'High'
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScCopyMirrorMigrate/Copy', expected_payload, True)
|
|
mock_delete_volume.assert_called_once_with(vol_name, '12345.2')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(uuid, 'uuid4')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'delete_volume')
|
|
def test_create_cloned_volume_cmm_paused(
|
|
self,
|
|
mock_delete_volume,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_uuid4,
|
|
mock_create_replay,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = {'instanceId': '12345.2',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
cmm = {'state': 'Paused'}
|
|
|
|
# our call returns
|
|
replayuuid = uuid.uuid4()
|
|
mock_uuid4.return_value = replayuuid
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = cmm
|
|
mock_create_replay.return_value = {'instanceId': '12345.100'}
|
|
mock_create_volume.return_value = newvol
|
|
|
|
# our call
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_cloned_volume, vol_name,
|
|
scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
mock_create_replay.assert_called_once_with(
|
|
scvolume, str(replayuuid), 60)
|
|
expected_payload = {}
|
|
expected_payload['CopyReplays'] = True
|
|
expected_payload['DestinationVolume'] = '12345.2'
|
|
expected_payload['SourceVolume'] = '12345.1'
|
|
expected_payload['StorageCenter'] = 12345
|
|
expected_payload['Priority'] = 'High'
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScCopyMirrorMigrate/Copy', expected_payload, True)
|
|
mock_delete_volume.assert_called_once_with(vol_name, '12345.2')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(uuid, 'uuid4')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_wait_for_cmm')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'delete_volume')
|
|
def test_create_cloned_volume_cmm_wait_for_cmm_fail(
|
|
self,
|
|
mock_delete_volume,
|
|
mock_wait_for_cmm,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_uuid4,
|
|
mock_create_replay,
|
|
mock_create_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# our state.
|
|
vol_name = fake.VOLUME_ID
|
|
scvolume = {'name': fake.VOLUME2_ID,
|
|
'instanceId': '12345.1',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
newvol = {'instanceId': '12345.2',
|
|
'configuredSize': '1073741824 Bytes'}
|
|
storage_profile = 'profile1'
|
|
replay_profile_list = ['profile2']
|
|
volume_qos = 'vqos'
|
|
group_qos = 'gqos'
|
|
dr_profile = 'dqos'
|
|
cmm = {'state': 'Running'}
|
|
|
|
# our call returns
|
|
replayuuid = uuid.uuid4()
|
|
mock_uuid4.return_value = replayuuid
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = cmm
|
|
mock_create_replay.return_value = {'instanceId': '12345.100'}
|
|
mock_create_volume.return_value = newvol
|
|
mock_wait_for_cmm.return_value = False
|
|
|
|
# our call
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.create_cloned_volume, vol_name,
|
|
scvolume, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
|
|
# assert expected
|
|
mock_create_volume.assert_called_once_with(
|
|
vol_name, 1, storage_profile, replay_profile_list,
|
|
volume_qos, group_qos, dr_profile)
|
|
mock_create_replay.assert_called_once_with(
|
|
scvolume, str(replayuuid), 60)
|
|
expected_payload = {}
|
|
expected_payload['CopyReplays'] = True
|
|
expected_payload['DestinationVolume'] = '12345.2'
|
|
expected_payload['SourceVolume'] = '12345.1'
|
|
expected_payload['StorageCenter'] = 12345
|
|
expected_payload['Priority'] = 'High'
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScCopyMirrorMigrate/Copy', expected_payload, True)
|
|
mock_wait_for_cmm.assert_called_once_with(cmm, newvol, str(replayuuid))
|
|
mock_delete_volume.assert_called_once_with(vol_name, '12345.2')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_expand_volume(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.expand_volume(self.VOLUME, 550)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.VOLUME, res, 'Unexpected ScVolume')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_expand_volume_failure(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.expand_volume(self.VOLUME, 550)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_200)
|
|
def test_rename_volume(self,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.rename_volume(self.VOLUME, 'newname')
|
|
self.assertTrue(mock_put.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_400)
|
|
def test_rename_volume_failure(self,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.rename_volume(self.VOLUME, 'newname')
|
|
self.assertTrue(mock_put.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
def test_delete_server(self,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._delete_server(self.SCSERVER)
|
|
self.assertTrue(mock_delete.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
def test_delete_server_del_not_allowed(self,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Test case where delete of ScServer not allowed
|
|
res = self.scapi._delete_server(self.SCSERVER_NO_DEL)
|
|
self.assertFalse(mock_delete.called)
|
|
self.assertIsNone(res, 'Expected None')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value={'test': 'test'})
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_get_user_preferences(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Not really testing anything other than the ability to mock, but
|
|
# including for completeness.
|
|
res = self.scapi._get_user_preferences()
|
|
self.assertEqual({'test': 'test'}, res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_get_user_preferences_failure(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._get_user_preferences()
|
|
self.assertEqual({}, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences',
|
|
return_value=None)
|
|
def test_update_storage_profile_noprefs(self,
|
|
mock_prefs,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.update_storage_profile(None, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences',
|
|
return_value={'allowStorageProfileSelection': False})
|
|
def test_update_storage_profile_not_allowed(self,
|
|
mock_prefs,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
LOG = self.mock_object(storagecenter_api, "LOG")
|
|
res = self.scapi.update_storage_profile(None, None)
|
|
self.assertFalse(res)
|
|
self.assertEqual(1, LOG.error.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_storage_profile',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences',
|
|
return_value={'allowStorageProfileSelection': True})
|
|
def test_update_storage_profile_prefs_not_found(self,
|
|
mock_profile,
|
|
mock_prefs,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
LOG = self.mock_object(storagecenter_api, "LOG")
|
|
res = self.scapi.update_storage_profile(None, 'Fake')
|
|
self.assertFalse(res)
|
|
self.assertEqual(1, LOG.error.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences',
|
|
return_value={'allowStorageProfileSelection': True,
|
|
'storageProfile': None})
|
|
def test_update_storage_profile_default_not_found(self,
|
|
mock_prefs,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
LOG = self.mock_object(storagecenter_api, "LOG")
|
|
res = self.scapi.update_storage_profile(None, None)
|
|
self.assertFalse(res)
|
|
self.assertEqual(1, LOG.error.call_count)
|
|
|
|
@mock.patch.object(
|
|
storagecenter_api.SCApi,
|
|
'_get_user_preferences',
|
|
return_value={'allowStorageProfileSelection': True,
|
|
'storageProfile': {'name': 'Fake',
|
|
'instanceId': 'fakeId'}})
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_200)
|
|
def test_update_storage_profile(self,
|
|
mock_put,
|
|
mock_prefs,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
LOG = self.mock_object(storagecenter_api, "LOG")
|
|
fake_scvolume = {'name': 'name', 'instanceId': 'id'}
|
|
res = self.scapi.update_storage_profile(fake_scvolume, None)
|
|
self.assertTrue(res)
|
|
self.assertIn('fakeId', repr(mock_put.call_args_list[0]))
|
|
self.assertEqual(1, LOG.info.call_count)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[RPLAY_PROFILE])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_replay_profile(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_replay_profile('guid')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertEqual(self.RPLAY_PROFILE, res, 'Unexpected Profile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[RPLAY_PROFILE, RPLAY_PROFILE])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_replay_profile_more_than_one(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.find_replay_profile,
|
|
'guid')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_find_replay_profile_empty_list(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_replay_profile('guid')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertIsNone(res, 'Unexpected return')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_find_replay_profile_error(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.find_replay_profile('guid')
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'Unexpected return')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay_profile',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=RPLAY_PROFILE)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_201)
|
|
def test_create_replay_profile(self,
|
|
mock_post,
|
|
mock_first_result,
|
|
mock_find_replay_profile,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_replay_profile('guid')
|
|
self.assertTrue(mock_find_replay_profile.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertTrue(mock_first_result.called)
|
|
self.assertEqual(self.RPLAY_PROFILE, res, 'Unexpected Profile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay_profile',
|
|
return_value=RPLAY_PROFILE)
|
|
def test_create_replay_profile_exists(self,
|
|
mock_find_replay_profile,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_replay_profile('guid')
|
|
self.assertTrue(mock_find_replay_profile.called)
|
|
self.assertEqual(self.RPLAY_PROFILE, res, 'Unexpected Profile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_replay_profile',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_create_replay_profile_fail(self,
|
|
mock_post,
|
|
mock_find_replay_profile,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.create_replay_profile('guid')
|
|
self.assertTrue(mock_find_replay_profile.called)
|
|
self.assertTrue(mock_post.called)
|
|
self.assertIsNone(res, 'Unexpected return')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
def test_delete_replay_profile(self,
|
|
mock_get_id,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
self.scapi.delete_replay_profile(profile)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_delete.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
def test_delete_replay_profile_fail(self,
|
|
mock_get_id,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.delete_replay_profile,
|
|
profile)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_delete.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_first_result',
|
|
return_value=VOLUME_CONFIG)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
def test_get_volume_configuration(self,
|
|
mock_get_id,
|
|
mock_get,
|
|
mock_first_result,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._get_volume_configuration({})
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertEqual(self.VOLUME_CONFIG, res, 'Unexpected config')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
def test_get_volume_configuration_bad_response(self,
|
|
mock_get_id,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._get_volume_configuration({})
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertIsNone(res, 'Unexpected result')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_configuration',
|
|
return_value=VOLUME_CONFIG)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
def test_update_volume_profiles(self,
|
|
mock_get_id,
|
|
mock_put,
|
|
mock_get_volume_configuration,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvolume = {'instanceId': '1'}
|
|
existingid = self.VOLUME_CONFIG[u'replayProfileList'][0][u'instanceId']
|
|
vcid = self.VOLUME_CONFIG[u'instanceId']
|
|
# First get_id is for our existing replay profile id and the second
|
|
# is for the volume config and the last is for the volume id. And
|
|
# then we do this again for the second call below.
|
|
mock_get_id.side_effect = [existingid,
|
|
vcid,
|
|
scvolume['instanceId'],
|
|
existingid,
|
|
vcid,
|
|
scvolume['instanceId']]
|
|
newid = '64702.1'
|
|
expected_payload = {'ReplayProfileList': [newid, existingid]}
|
|
expected_url = 'StorageCenter/ScVolumeConfiguration/' + vcid
|
|
res = self.scapi._update_volume_profiles(scvolume, newid, None)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_get_volume_configuration.called)
|
|
mock_put.assert_called_once_with(expected_url, expected_payload, True)
|
|
self.assertTrue(res)
|
|
|
|
# Now do a remove. (Restarting with the original config so this will
|
|
# end up as an empty list.)
|
|
expected_payload['ReplayProfileList'] = []
|
|
res = self.scapi._update_volume_profiles(scvolume, None, existingid)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_get_volume_configuration.called)
|
|
mock_put.assert_called_with(expected_url, expected_payload, True)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_configuration',
|
|
return_value=VOLUME_CONFIG)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_400)
|
|
# We set this to 1 so we can check our payload
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id')
|
|
def test_update_volume_profiles_bad_response(self,
|
|
mock_get_id,
|
|
mock_put,
|
|
mock_get_volume_configuration,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvolume = {'instanceId': '1'}
|
|
existingid = self.VOLUME_CONFIG[u'replayProfileList'][0][u'instanceId']
|
|
vcid = self.VOLUME_CONFIG[u'instanceId']
|
|
# First get_id is for our existing replay profile id and the second
|
|
# is for the volume config and the last is for the volume id. And
|
|
# then we do this again for the second call below.
|
|
mock_get_id.side_effect = [existingid,
|
|
vcid,
|
|
scvolume['instanceId'],
|
|
existingid,
|
|
vcid,
|
|
scvolume['instanceId']]
|
|
newid = '64702.1'
|
|
expected_payload = {'ReplayProfileList': [newid, existingid]}
|
|
expected_url = 'StorageCenter/ScVolumeConfiguration/' + vcid
|
|
res = self.scapi._update_volume_profiles(scvolume, newid, None)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_get_volume_configuration.called)
|
|
mock_put.assert_called_once_with(expected_url, expected_payload, True)
|
|
self.assertFalse(res)
|
|
|
|
# Now do a remove. (Restarting with the original config so this will
|
|
# end up as an empty list.)
|
|
expected_payload['ReplayProfileList'] = []
|
|
res = self.scapi._update_volume_profiles(scvolume, None, existingid)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_get_volume_configuration.called)
|
|
mock_put.assert_called_with(expected_url, expected_payload, True)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_configuration',
|
|
return_value=None)
|
|
def test_update_volume_profiles_no_config(self,
|
|
mock_get_volume_configuration,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvolume = {'instanceId': '1'}
|
|
res = self.scapi._update_volume_profiles(scvolume, '64702.2', None)
|
|
self.assertTrue(mock_get_volume_configuration.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=999)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_update_volume_profiles',
|
|
return_value=True)
|
|
def test_add_cg_volumes(self,
|
|
mock_update_volume_profiles,
|
|
mock_find_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profileid = '100'
|
|
add_volumes = [{'id': '1', 'provider_id': '1'}]
|
|
res = self.scapi._add_cg_volumes(profileid, add_volumes)
|
|
self.assertTrue(mock_find_volume.called)
|
|
mock_update_volume_profiles.assert_called_once_with(999,
|
|
addid=profileid,
|
|
removeid=None)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=999)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_update_volume_profiles',
|
|
return_value=False)
|
|
def test_add_cg_volumes_fail(self,
|
|
mock_update_volume_profiles,
|
|
mock_find_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profileid = '100'
|
|
add_volumes = [{'id': '1', 'provider_id': '1'}]
|
|
res = self.scapi._add_cg_volumes(profileid, add_volumes)
|
|
self.assertTrue(mock_find_volume.called)
|
|
mock_update_volume_profiles.assert_called_once_with(999,
|
|
addid=profileid,
|
|
removeid=None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=999)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_update_volume_profiles',
|
|
return_value=True)
|
|
def test_remove_cg_volumes(self,
|
|
mock_update_volume_profiles,
|
|
mock_find_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profileid = '100'
|
|
remove_volumes = [{'id': '1', 'provider_id': '1'}]
|
|
res = self.scapi._remove_cg_volumes(profileid, remove_volumes)
|
|
self.assertTrue(mock_find_volume.called)
|
|
mock_update_volume_profiles.assert_called_once_with(999,
|
|
addid=None,
|
|
removeid=profileid)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume',
|
|
return_value=999)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_update_volume_profiles',
|
|
return_value=False)
|
|
def test_remove_cg_volumes_false(self,
|
|
mock_update_volume_profiles,
|
|
mock_find_volume,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profileid = '100'
|
|
remove_volumes = [{'id': '1', 'provider_id': '1'}]
|
|
res = self.scapi._remove_cg_volumes(profileid, remove_volumes)
|
|
self.assertTrue(mock_find_volume.called)
|
|
mock_update_volume_profiles.assert_called_once_with(999,
|
|
addid=None,
|
|
removeid=profileid)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_remove_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_update_cg_volumes(self,
|
|
mock_get_id,
|
|
mock_add_cg_volumes,
|
|
mock_remove_cg_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
add_volumes = [{'id': '1'}]
|
|
remove_volumes = [{'id': '2'}]
|
|
res = self.scapi.update_cg_volumes(profile,
|
|
add_volumes,
|
|
remove_volumes)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_add_cg_volumes.assert_called_once_with('100', add_volumes)
|
|
mock_remove_cg_volumes.assert_called_once_with('100',
|
|
remove_volumes)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_remove_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_update_cg_volumes_no_remove(self,
|
|
mock_get_id,
|
|
mock_add_cg_volumes,
|
|
mock_remove_cg_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
add_volumes = [{'id': '1'}]
|
|
remove_volumes = []
|
|
res = self.scapi.update_cg_volumes(profile,
|
|
add_volumes,
|
|
remove_volumes)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_add_cg_volumes.assert_called_once_with('100', add_volumes)
|
|
self.assertFalse(mock_remove_cg_volumes.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_remove_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_update_cg_volumes_no_add(self,
|
|
mock_get_id,
|
|
mock_add_cg_volumes,
|
|
mock_remove_cg_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
add_volumes = []
|
|
remove_volumes = [{'id': '1'}]
|
|
res = self.scapi.update_cg_volumes(profile,
|
|
add_volumes,
|
|
remove_volumes)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_remove_cg_volumes.assert_called_once_with('100', remove_volumes)
|
|
self.assertFalse(mock_add_cg_volumes.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_remove_cg_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_cg_volumes',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_update_cg_volumes_add_fail(self,
|
|
mock_get_id,
|
|
mock_add_cg_volumes,
|
|
mock_remove_cg_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
add_volumes = [{'id': '1'}]
|
|
remove_volumes = [{'id': '2'}]
|
|
res = self.scapi.update_cg_volumes(profile,
|
|
add_volumes,
|
|
remove_volumes)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_add_cg_volumes.assert_called_once_with('100', add_volumes)
|
|
self.assertTrue(not mock_remove_cg_volumes.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_remove_cg_volumes',
|
|
return_value=False)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_add_cg_volumes',
|
|
return_value=True)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_update_cg_volumes_remove_fail(self,
|
|
mock_get_id,
|
|
mock_add_cg_volumes,
|
|
mock_remove_cg_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'name': 'guid'}
|
|
add_volumes = [{'id': '1'}]
|
|
remove_volumes = [{'id': '2'}]
|
|
res = self.scapi.update_cg_volumes(profile,
|
|
add_volumes,
|
|
remove_volumes)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_add_cg_volumes.assert_called_once_with('100', add_volumes)
|
|
mock_remove_cg_volumes.assert_called_once_with('100',
|
|
remove_volumes)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[INACTIVE_VOLUME])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_init_volume')
|
|
def test_init_cg_volumes_inactive(self,
|
|
mock_init_volume,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profileid = 100
|
|
self.scapi._init_cg_volumes(profileid)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
mock_init_volume.assert_called_once_with(self.INACTIVE_VOLUME)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[VOLUME])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_init_volume')
|
|
def test_init_cg_volumes_active(self,
|
|
mock_init_volume,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profileid = 100
|
|
self.scapi._init_cg_volumes(profileid)
|
|
self.assertTrue(mock_get.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertFalse(mock_init_volume.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_init_cg_volumes')
|
|
def test_snap_cg_replay(self,
|
|
mock_init_cg_volumes,
|
|
mock_get_id,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
replayid = 'guid'
|
|
expire = 0
|
|
profile = {'instanceId': '100'}
|
|
# See the 100 from get_id above?
|
|
expected_url = 'StorageCenter/ScReplayProfile/100/CreateReplay'
|
|
expected_payload = {'description': replayid, 'expireTime': expire}
|
|
res = self.scapi.snap_cg_replay(profile, replayid, expire)
|
|
mock_post.assert_called_once_with(expected_url, expected_payload, True)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_init_cg_volumes.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_init_cg_volumes')
|
|
def test_snap_cg_replay_bad_return(self,
|
|
mock_init_cg_volumes,
|
|
mock_get_id,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
replayid = 'guid'
|
|
expire = 0
|
|
profile = {'instanceId': '100'}
|
|
# See the 100 from get_id above?
|
|
expected_url = 'StorageCenter/ScReplayProfile/100/CreateReplay'
|
|
expected_payload = {'description': replayid, 'expireTime': expire}
|
|
res = self.scapi.snap_cg_replay(profile, replayid, expire)
|
|
mock_post.assert_called_once_with(expected_url, expected_payload, True)
|
|
self.assertTrue(mock_get_id.called)
|
|
self.assertTrue(mock_init_cg_volumes.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=CGS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_sc_cg(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_sc_cg(
|
|
{},
|
|
'GUID1-0869559e-6881-454e-ba18-15c6726d33c1')
|
|
self.assertEqual(self.CGS[0], res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=CGS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_find_sc_cg_not_found(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_sc_cg(
|
|
{},
|
|
'GUID3-0869559e-6881-454e-ba18-15c6726d33c1')
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_find_sc_cg_fail(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi._find_sc_cg(
|
|
{},
|
|
'GUID1-0869559e-6881-454e-ba18-15c6726d33c1')
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_sc_cg',
|
|
return_value={'instanceId': 101})
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=RPLAYS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
def test_find_cg_replays(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_find_sc_cg,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'instanceId': '100'}
|
|
replayid = 'Cinder Test Replay012345678910'
|
|
res = self.scapi._find_cg_replays(profile, replayid)
|
|
expected_url = 'StorageCenter/ScReplayConsistencyGroup/101/ReplayList'
|
|
mock_get.assert_called_once_with(expected_url)
|
|
self.assertTrue(mock_find_sc_cg.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
# We should fine RPLAYS
|
|
self.assertEqual(self.RPLAYS, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_sc_cg',
|
|
return_value=None)
|
|
def test_find_cg_replays_no_cg(self,
|
|
mock_find_sc_cg,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'instanceId': '100'}
|
|
replayid = 'Cinder Test Replay012345678910'
|
|
res = self.scapi._find_cg_replays(profile, replayid)
|
|
self.assertTrue(mock_find_sc_cg.called)
|
|
# We should return an empty list.
|
|
self.assertEqual([], res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_sc_cg',
|
|
return_value={'instanceId': 101})
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=None)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
def test_find_cg_replays_bad_json(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_find_sc_cg,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
profile = {'instanceId': '100'}
|
|
replayid = 'Cinder Test Replay012345678910'
|
|
res = self.scapi._find_cg_replays(profile, replayid)
|
|
expected_url = 'StorageCenter/ScReplayConsistencyGroup/101/ReplayList'
|
|
mock_get.assert_called_once_with(expected_url)
|
|
self.assertTrue(mock_find_sc_cg.called)
|
|
self.assertTrue(mock_get_json.called)
|
|
self.assertIsNone(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_cg_replays',
|
|
return_value=RPLAYS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_delete_cg_replay(self,
|
|
mock_post,
|
|
mock_find_cg_replays,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.delete_cg_replay({}, '')
|
|
expected_url = ('StorageCenter/ScReplay/' +
|
|
self.RPLAYS[0]['instanceId'] +
|
|
'/Expire')
|
|
mock_post.assert_any_call(expected_url, {}, True)
|
|
expected_url = ('StorageCenter/ScReplay/' +
|
|
self.RPLAYS[1]['instanceId'] +
|
|
'/Expire')
|
|
mock_post.assert_any_call(expected_url, {}, True)
|
|
self.assertTrue(mock_find_cg_replays.called)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_cg_replays',
|
|
return_value=RPLAYS)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_delete_cg_replay_error(self,
|
|
mock_post,
|
|
mock_find_cg_replays,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
expected_url = ('StorageCenter/ScReplay/' +
|
|
self.RPLAYS[0]['instanceId'] +
|
|
'/Expire')
|
|
res = self.scapi.delete_cg_replay({}, '')
|
|
mock_post.assert_called_once_with(expected_url, {}, True)
|
|
self.assertTrue(mock_find_cg_replays.called)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_cg_replays',
|
|
return_value=[])
|
|
def test_delete_cg_replay_cant_find(self,
|
|
mock_find_cg_replays,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
res = self.scapi.delete_cg_replay({}, '')
|
|
self.assertTrue(mock_find_cg_replays.called)
|
|
self.assertTrue(res)
|
|
|
|
def test_size_to_gb(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
gb, rem = self.scapi.size_to_gb('1.073741824E9 Byte')
|
|
self.assertEqual(1, gb)
|
|
self.assertEqual(0, rem)
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.size_to_gb,
|
|
'banana')
|
|
gb, rem = self.scapi.size_to_gb('1.073741924E9 Byte')
|
|
self.assertEqual(1, gb)
|
|
self.assertEqual(100, rem)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_volume_folder')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=VOLUME)
|
|
def test_import_one(self,
|
|
mock_get_json,
|
|
mock_put,
|
|
mock_find_volume_folder,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
newname = 'guid'
|
|
# First test is folder found. Second ist is not found.
|
|
mock_find_volume_folder.side_effect = [{'instanceId': '1'}, None]
|
|
expected_url = 'StorageCenter/ScVolume/100'
|
|
expected_payload = {'Name': newname,
|
|
'VolumeFolder': '1'}
|
|
self.scapi._import_one({'instanceId': '100'}, newname)
|
|
mock_put.assert_called_once_with(expected_url, expected_payload, True)
|
|
self.assertTrue(mock_find_volume_folder.called)
|
|
expected_payload = {'Name': newname}
|
|
self.scapi._import_one({'instanceId': '100'}, newname)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{'configuredSize':
|
|
'1.073741824E9 Bytes'}])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'size_to_gb',
|
|
return_value=(1, 0))
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_import_one',
|
|
return_value=VOLUME)
|
|
def test_manage_existing(self,
|
|
mock_import_one,
|
|
mock_find_mappings,
|
|
mock_size_to_gb,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
newname = 'guid'
|
|
existing = {'source-name': 'scvolname'}
|
|
self.scapi.manage_existing(newname, existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'), None, False)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_size_to_gb.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[])
|
|
def test_manage_existing_vol_not_found(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
|
|
# Same as above only we don't have a volume folder.
|
|
newname = 'guid'
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.ManageExistingInvalidReference,
|
|
self.scapi.manage_existing,
|
|
newname,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{}, {}, {}])
|
|
def test_manage_existing_vol_multiple_found(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
|
|
# Same as above only we don't have a volume folder.
|
|
newname = 'guid'
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.ManageExistingInvalidReference,
|
|
self.scapi.manage_existing,
|
|
newname,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{'configuredSize':
|
|
'1.073741924E9 Bytes'}])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'size_to_gb',
|
|
return_value=(1, 100))
|
|
def test_manage_existing_bad_size(self,
|
|
mock_size_to_gb,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
|
|
# Same as above only we don't have a volume folder.
|
|
newname = 'guid'
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.manage_existing,
|
|
newname,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
self.assertTrue(mock_size_to_gb.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{'configuredSize':
|
|
'1.073741824E9 Bytes'}])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'size_to_gb',
|
|
return_value=(1, 0))
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=[{}, {}])
|
|
def test_manage_existing_already_mapped(self,
|
|
mock_find_mappings,
|
|
mock_size_to_gb,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
|
|
newname = 'guid'
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.manage_existing,
|
|
newname,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_size_to_gb.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{'configuredSize':
|
|
'1.073741824E9 Bytes'}])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'size_to_gb',
|
|
return_value=(1, 0))
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_mappings',
|
|
return_value=[])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_import_one',
|
|
return_value=None)
|
|
def test_manage_existing_import_fail(self,
|
|
mock_import_one,
|
|
mock_find_mappings,
|
|
mock_size_to_gb,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# We fail on the _find_volume_folder to make this easier.
|
|
newname = 'guid'
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.manage_existing,
|
|
newname,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
self.assertTrue(mock_find_mappings.called)
|
|
self.assertTrue(mock_size_to_gb.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{'configuredSize':
|
|
'1.073741824E9 Bytes'}])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'size_to_gb',
|
|
return_value=(1, 0))
|
|
def test_get_unmanaged_volume_size(self,
|
|
mock_size_to_gb,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
existing = {'source-name': 'scvolname'}
|
|
res = self.scapi.get_unmanaged_volume_size(existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
self.assertTrue(mock_size_to_gb.called)
|
|
self.assertEqual(1, res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[])
|
|
def test_get_unmanaged_volume_size_not_found(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.ManageExistingInvalidReference,
|
|
self.scapi.get_unmanaged_volume_size,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{}, {}, {}])
|
|
def test_get_unmanaged_volume_size_many_found(self,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.ManageExistingInvalidReference,
|
|
self.scapi.get_unmanaged_volume_size,
|
|
existing)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_volume_list',
|
|
return_value=[{'configuredSize':
|
|
'1.073741924E9 Bytes'}])
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'size_to_gb',
|
|
return_value=(1, 100))
|
|
def test_get_unmanaged_volume_size_bad_size(self,
|
|
mock_size_to_gb,
|
|
mock_get_volume_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
existing = {'source-name': 'scvolname'}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.get_unmanaged_volume_size,
|
|
existing)
|
|
self.assertTrue(mock_size_to_gb.called)
|
|
mock_get_volume_list.assert_called_once_with(
|
|
existing.get('source-name'),
|
|
existing.get('source-id'),
|
|
False)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_unmanage(self,
|
|
mock_get_id,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Same as above only we don't have a volume folder.
|
|
scvolume = {'name': 'guid'}
|
|
expected_url = 'StorageCenter/ScVolume/100'
|
|
newname = 'Unmanaged_' + scvolume['name']
|
|
expected_payload = {'Name': newname}
|
|
self.scapi.unmanage(scvolume)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_put.assert_called_once_with(expected_url, expected_payload, True)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_id',
|
|
return_value='100')
|
|
def test_unmanage_fail(self,
|
|
mock_get_id,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Same as above only we don't have a volume folder.
|
|
scvolume = {'name': 'guid'}
|
|
expected_url = 'StorageCenter/ScVolume/100'
|
|
newname = 'Unmanaged_' + scvolume['name']
|
|
expected_payload = {'Name': newname}
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.unmanage,
|
|
scvolume)
|
|
self.assertTrue(mock_get_id.called)
|
|
mock_put.assert_called_once_with(expected_url, expected_payload, True)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[SCQOS])
|
|
# def _find_qos(self, qosnode):
|
|
def test__find_qos(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi._find_qos('Cinder QoS')
|
|
self.assertDictEqual(self.SCQOS, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
# def _find_qos(self, qosnode):
|
|
def test__find_qos_not_found(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# set side effect for posts.
|
|
# first empty second returns qosnode
|
|
mock_get_json.side_effect = [[], self.SCQOS]
|
|
ret = self.scapi._find_qos('Cinder QoS')
|
|
self.assertDictEqual(self.SCQOS, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
# def _find_qos(self, qosnode):
|
|
def test__find_qos_find_fail(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi._find_qos,
|
|
'Cinder QoS')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
# def _find_qos(self, qosnode):
|
|
def test__find_qos_create_fail(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.side_effect = [self.RESPONSE_200, self.RESPONSE_400]
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi._find_qos,
|
|
'Cinder QoS')
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCREPL)
|
|
def test_update_replicate_active_replay_fail(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.update_replicate_active_replay({'instanceId': '1'},
|
|
True)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCREPL)
|
|
def test_update_replicate_active_replay_nothing_to_do(
|
|
self, mock_get_json, mock_get, mock_close_connection,
|
|
mock_open_connection, mock_init):
|
|
ret = self.scapi.update_replicate_active_replay({'instanceId': '1'},
|
|
False)
|
|
self.assertTrue(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
def test_update_replicate_active_replay_not_found(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.update_replicate_active_replay({'instanceId': '1'},
|
|
True)
|
|
self.assertTrue(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
def test_update_replicate_active_replay_not_found2(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.update_replicate_active_replay({'instanceId': '1'},
|
|
True)
|
|
self.assertTrue(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[{'instanceId': '12345.1'}])
|
|
def test_get_disk_folder(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi._get_disk_folder(12345, 'name')
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'name',
|
|
'attributeValue': 'name'}]}}
|
|
mock_post.assert_called_once_with('StorageCenter/ScDiskFolder/GetList',
|
|
expected_payload)
|
|
self.assertEqual({'instanceId': '12345.1'}, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_get_disk_folder_fail(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi._get_disk_folder(12345, 'name')
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'name',
|
|
'attributeValue': 'name'}]}}
|
|
mock_post.assert_called_once_with('StorageCenter/ScDiskFolder/GetList',
|
|
expected_payload)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test_get_disk_folder_fail_bad_json(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_get_json.side_effect = (exception.VolumeBackendAPIException(''))
|
|
ret = self.scapi._get_disk_folder(12345, 'name')
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'scSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'name',
|
|
'attributeValue': 'name'}]}}
|
|
mock_post.assert_called_once_with('StorageCenter/ScDiskFolder/GetList',
|
|
expected_payload)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCREPL)
|
|
def test_get_screplication(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.get_screplication({'instanceId': '1'}, 65495)
|
|
self.assertDictEqual(self.SCREPL[0], ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
def test_get_screplication_not_found(self,
|
|
mock_get_json,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.get_screplication({'instanceId': '1'}, 65496)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_get_screplication_error(self,
|
|
mock_get,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.get_screplication({'instanceId': '1'}, 65495)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_screplication',
|
|
return_value=SCREPL[0])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_200)
|
|
def test_delete_replication(self,
|
|
mock_delete,
|
|
mock_get_screplication,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
destssn = 65495
|
|
expected = 'StorageCenter/ScReplication/%s' % (
|
|
self.SCREPL[0]['instanceId'])
|
|
expected_payload = {'DeleteDestinationVolume': True,
|
|
'RecycleDestinationVolume': True,
|
|
'DeleteRestorePoint': True}
|
|
ret = self.scapi.delete_replication(self.VOLUME, destssn)
|
|
mock_delete.assert_any_call(expected, payload=expected_payload,
|
|
async_call=True)
|
|
self.assertTrue(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_screplication',
|
|
return_value=None)
|
|
def test_delete_replication_not_found(self,
|
|
mock_get_screplication,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
destssn = 65495
|
|
ret = self.scapi.delete_replication(self.VOLUME, destssn)
|
|
self.assertFalse(ret)
|
|
ret = self.scapi.delete_replication(self.VOLUME, destssn)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_screplication',
|
|
return_value=SCREPL[0])
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete',
|
|
return_value=RESPONSE_400)
|
|
def test_delete_replication_error(self,
|
|
mock_delete,
|
|
mock_get_screplication,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
destssn = 65495
|
|
expected = 'StorageCenter/ScReplication/%s' % (
|
|
self.SCREPL[0]['instanceId'])
|
|
expected_payload = {'DeleteDestinationVolume': True,
|
|
'RecycleDestinationVolume': True,
|
|
'DeleteRestorePoint': True}
|
|
ret = self.scapi.delete_replication(self.VOLUME, destssn)
|
|
mock_delete.assert_any_call(expected, payload=expected_payload,
|
|
async_call=True)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos',
|
|
return_value=SCQOS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCREPL[0])
|
|
def test_create_replication(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# We don't test diskfolder. If one is found we include it. If not
|
|
# then we leave it out. Checking for disk folder is tested elsewhere.
|
|
ssn = 64702
|
|
destssn = 65495
|
|
qosnode = 'Cinder QoS'
|
|
notes = 'Created by Dell EMC Cinder Driver'
|
|
repl_prefix = 'Cinder repl of '
|
|
|
|
mock_find_sc.side_effect = [destssn, ssn, destssn, ssn, destssn, ssn]
|
|
payload = {'DestinationStorageCenter': destssn,
|
|
'QosNode': self.SCQOS['instanceId'],
|
|
'SourceVolume': self.VOLUME['instanceId'],
|
|
'StorageCenter': ssn,
|
|
'ReplicateActiveReplay': False,
|
|
'Type': 'Asynchronous',
|
|
'DestinationVolumeAttributes':
|
|
{'CreateSourceVolumeFolderPath': True,
|
|
'Notes': notes,
|
|
'Name': repl_prefix + self.VOLUME['name']}
|
|
}
|
|
ret = self.scapi.create_replication(self.VOLUME,
|
|
str(destssn),
|
|
qosnode,
|
|
False,
|
|
None,
|
|
False)
|
|
mock_post.assert_any_call('StorageCenter/ScReplication', payload, True)
|
|
self.assertDictEqual(self.SCREPL[0], ret)
|
|
payload['Type'] = 'Synchronous'
|
|
payload['ReplicateActiveReplay'] = True
|
|
payload['SyncMode'] = 'HighAvailability'
|
|
ret = self.scapi.create_replication(self.VOLUME,
|
|
str(destssn),
|
|
qosnode,
|
|
True,
|
|
None,
|
|
False)
|
|
mock_post.assert_any_call('StorageCenter/ScReplication', payload, True)
|
|
self.assertDictEqual(self.SCREPL[0], ret)
|
|
ret = self.scapi.create_replication(self.VOLUME,
|
|
str(destssn),
|
|
qosnode,
|
|
True,
|
|
None,
|
|
True)
|
|
mock_post.assert_any_call('StorageCenter/ScReplication', payload, True)
|
|
self.assertDictEqual(self.SCREPL[0], ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos',
|
|
return_value=SCQOS)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCREPL[0])
|
|
def test_create_replication_error(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ssn = 64702
|
|
destssn = 65495
|
|
qosnode = 'Cinder QoS'
|
|
notes = 'Created by Dell EMC Cinder Driver'
|
|
repl_prefix = 'Cinder repl of '
|
|
|
|
mock_find_sc.side_effect = [destssn, ssn, destssn, ssn]
|
|
mock_post.side_effect = [self.RESPONSE_400, self.RESPONSE_400,
|
|
self.RESPONSE_400, self.RESPONSE_400]
|
|
payload = {'DestinationStorageCenter': destssn,
|
|
'QosNode': self.SCQOS['instanceId'],
|
|
'SourceVolume': self.VOLUME['instanceId'],
|
|
'StorageCenter': ssn,
|
|
'ReplicateActiveReplay': False,
|
|
'Type': 'Asynchronous',
|
|
'DestinationVolumeAttributes':
|
|
{'CreateSourceVolumeFolderPath': True,
|
|
'Notes': notes,
|
|
'Name': repl_prefix + self.VOLUME['name']}
|
|
}
|
|
ret = self.scapi.create_replication(self.VOLUME,
|
|
str(destssn),
|
|
qosnode,
|
|
False,
|
|
None,
|
|
False)
|
|
mock_post.assert_any_call('StorageCenter/ScReplication', payload, True)
|
|
self.assertIsNone(ret)
|
|
|
|
payload['Type'] = 'Synchronous'
|
|
payload['ReplicateActiveReplay'] = True
|
|
payload['SyncMode'] = 'HighAvailability'
|
|
ret = self.scapi.create_replication(self.VOLUME,
|
|
str(destssn),
|
|
qosnode,
|
|
True,
|
|
None,
|
|
True)
|
|
mock_post.assert_any_call('StorageCenter/ScReplication', payload, True)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=SCREPL)
|
|
def test_find_repl_volume(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.find_repl_volume('guid', 65495)
|
|
self.assertDictEqual(self.SCREPL[0], ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[])
|
|
def test_find_repl_volume_empty_list(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.find_repl_volume('guid', 65495)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=[{'instanceId': '1'}, {'instanceId': '2'}])
|
|
def test_find_repl_volume_multiple_results(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.find_repl_volume('guid', 65495)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_find_repl_volume_error(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi.find_repl_volume('guid', 65495)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'get_screplication')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_repl_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_volume')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'remove_mappings')
|
|
def test_break_replication(self,
|
|
mock_remove_mappings,
|
|
mock_find_volume,
|
|
mock_find_repl_volume,
|
|
mock_get_screplication,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Find_volume doesn't actually matter. We do not gate on this.
|
|
# Switch it up just to prove that.
|
|
mock_find_volume.side_effect = [self.VOLUME, # 1
|
|
self.VOLUME, # 2
|
|
None, # 3
|
|
None] # 4
|
|
# Much like find volume we do not gate on this.
|
|
mock_get_screplication.side_effect = [self.SCREPL[0], # 1
|
|
None] # 2
|
|
# This
|
|
mock_find_repl_volume.side_effect = [self.VOLUME, # 1
|
|
self.VOLUME, # 2
|
|
self.VOLUME, # 3
|
|
self.VOLUME] # 4
|
|
mock_remove_mappings.side_effect = [True, # 1
|
|
True,
|
|
True, # 2
|
|
False,
|
|
True, # 3
|
|
True,
|
|
False] # 4
|
|
# Good path.
|
|
ret = self.scapi.break_replication('name', None, 65495)
|
|
self.assertEqual(self.VOLUME, ret)
|
|
# Source found, screpl not found.
|
|
ret = self.scapi.break_replication('name', None, 65495)
|
|
self.assertEqual(self.VOLUME, ret)
|
|
# No source vol good path.
|
|
ret = self.scapi.break_replication('name', None, 65495)
|
|
self.assertEqual(self.VOLUME, ret)
|
|
# fail remove mappings
|
|
ret = self.scapi.break_replication('name', None, 65495)
|
|
self.assertEqual(self.VOLUME, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
def test__find_user_replay_profiles(self,
|
|
mock_get_user_preferences,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_get_user_preferences.return_value = {}
|
|
ret = self.scapi._find_user_replay_profiles()
|
|
self.assertEqual([], ret)
|
|
mock_get_user_preferences.return_value = {'test': 'test',
|
|
'replayProfileList': []}
|
|
ret = self.scapi._find_user_replay_profiles()
|
|
self.assertEqual([], ret)
|
|
mock_get_user_preferences.return_value = {
|
|
'test': 'test', 'replayProfileList': [{'instanceId': 'a'},
|
|
{'instanceId': 'b'}]}
|
|
ret = self.scapi._find_user_replay_profiles()
|
|
self.assertEqual(['a', 'b'], ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test__find_daily_replay_profile(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = [{'instanceId': 'a'}]
|
|
ret = self.scapi._find_daily_replay_profile()
|
|
self.assertEqual('a', ret)
|
|
mock_get_json.return_value = []
|
|
ret = self.scapi._find_daily_replay_profile()
|
|
self.assertIsNone(ret)
|
|
mock_get_json.return_value = None
|
|
ret = self.scapi._find_daily_replay_profile()
|
|
self.assertIsNone(ret)
|
|
mock_post.return_value = self.RESPONSE_400
|
|
ret = self.scapi._find_daily_replay_profile()
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test__find_replay_profiles(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Good run.
|
|
rps = 'a,b'
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = [{'name': 'a', 'instanceId': 'a'},
|
|
{'name': 'b', 'instanceId': 'b'},
|
|
{'name': 'c', 'instanceId': 'c'}]
|
|
reta, retb = self.scapi._find_replay_profiles(rps)
|
|
self.assertEqual(['a', 'b'], reta)
|
|
self.assertEqual(['c'], retb)
|
|
# Looking for profile that doesn't exist.
|
|
rps = 'a,b,d'
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi._find_replay_profiles,
|
|
rps)
|
|
# Looking for nothing.
|
|
rps = ''
|
|
reta, retb = self.scapi._find_replay_profiles(rps)
|
|
self.assertEqual([], reta)
|
|
self.assertEqual([], retb)
|
|
# Still Looking for nothing.
|
|
rps = None
|
|
reta, retb = self.scapi._find_replay_profiles(rps)
|
|
self.assertEqual([], reta)
|
|
self.assertEqual([], retb)
|
|
# Bad call.
|
|
rps = 'a,b'
|
|
mock_post.return_value = self.RESPONSE_400
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi._find_replay_profiles,
|
|
rps)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_replay_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_user_replay_profiles')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_daily_replay_profile')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_update_volume_profiles')
|
|
def test_update_replay_profiles(self,
|
|
mock_update_volume_profiles,
|
|
mock_find_daily_replay_profile,
|
|
mock_find_user_replay_profiles,
|
|
mock_find_replay_profiles,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {}
|
|
mock_find_replay_profiles.return_value = (['a', 'b'], ['c'])
|
|
mock_update_volume_profiles.side_effect = [
|
|
True, True, True,
|
|
False,
|
|
True, True, False,
|
|
True, True, True, True, True,
|
|
True, True, True, True,
|
|
False]
|
|
ret = self.scapi.update_replay_profiles(scvol, 'a,b')
|
|
# Two adds and one remove
|
|
self.assertEqual(3, mock_update_volume_profiles.call_count)
|
|
self.assertTrue(ret)
|
|
# Now update fails.
|
|
ret = self.scapi.update_replay_profiles(scvol, 'a,b')
|
|
# 1 failed update plus 3 from before.
|
|
self.assertEqual(4, mock_update_volume_profiles.call_count)
|
|
self.assertFalse(ret)
|
|
# Fail adding Ids..
|
|
ret = self.scapi.update_replay_profiles(scvol, 'a,b')
|
|
# 3 more 4 from before.
|
|
self.assertEqual(7, mock_update_volume_profiles.call_count)
|
|
self.assertFalse(ret)
|
|
# User clearing profiles.
|
|
mock_find_replay_profiles.return_value = ([], ['a', 'b', 'c'])
|
|
mock_find_user_replay_profiles.return_value = ['d', 'u']
|
|
ret = self.scapi.update_replay_profiles(scvol, '')
|
|
# 3 removes and 2 adds plus 7 from before
|
|
self.assertEqual(12, mock_update_volume_profiles.call_count)
|
|
self.assertTrue(ret)
|
|
# User clearing profiles and no defaults. (Probably not possible.)
|
|
mock_find_user_replay_profiles.return_value = []
|
|
mock_find_daily_replay_profile.return_value = 'd'
|
|
ret = self.scapi.update_replay_profiles(scvol, '')
|
|
# 3 removes and 1 add plus 12 from before.
|
|
self.assertEqual(16, mock_update_volume_profiles.call_count)
|
|
self.assertTrue(ret)
|
|
# _find_replay_profiles blows up so we do too.
|
|
mock_find_replay_profiles.side_effect = (
|
|
exception.VolumeBackendAPIException('aaa'))
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.update_replay_profiles,
|
|
scvol,
|
|
'a,b')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Basic check
|
|
retlv = self.scapi.get_live_volume(None)
|
|
self.assertIsNone(retlv)
|
|
lv1 = {'primaryVolume': {'instanceId': '12345.1'},
|
|
'secondaryVolume': {'instanceId': '67890.1'}}
|
|
lv2 = {'primaryVolume': {'instanceId': '12345.2'}}
|
|
mock_sc_live_volumes.return_value = [lv1, lv2]
|
|
# Good Run
|
|
retlv = self.scapi.get_live_volume('12345.2')
|
|
self.assertEqual(lv2, retlv)
|
|
mock_sc_live_volumes.assert_called_once_with('12345')
|
|
self.assertFalse(mock_get_live_volumes.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume_on_secondary(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
# Basic check
|
|
retlv = self.scapi.get_live_volume(None)
|
|
self.assertIsNone(retlv)
|
|
lv1 = {'primaryVolume': {'instanceId': '12345.1'},
|
|
'secondaryVolume': {'instanceId': '67890.1'}}
|
|
lv2 = {'primaryVolume': {'instanceId': '12345.2'}}
|
|
mock_sc_live_volumes.return_value = []
|
|
mock_get_live_volumes.return_value = [lv1, lv2]
|
|
# Good Run
|
|
retlv = self.scapi.get_live_volume('12345.2')
|
|
self.assertEqual(lv2, retlv)
|
|
mock_sc_live_volumes.assert_called_once_with('12345')
|
|
mock_get_live_volumes.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume_not_found(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lv1 = {'primaryVolume': {'instanceId': '12345.1'},
|
|
'secondaryVolume': {'instanceId': '67890.1'}}
|
|
lv2 = {'primaryVolume': {'instanceId': '12345.2'},
|
|
'secondaryVolume': {'instanceId': '67890.2'}}
|
|
mock_get_live_volumes.return_value = [lv1, lv2]
|
|
mock_sc_live_volumes.return_value = []
|
|
retlv = self.scapi.get_live_volume('12345.3')
|
|
self.assertIsNone(retlv)
|
|
mock_sc_live_volumes.assert_called_once_with('12345')
|
|
mock_get_live_volumes.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume_swapped(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lv1 = {'primaryVolume': {'instanceId': '12345.1'},
|
|
'secondaryVolume': {'instanceId': '67890.1'}}
|
|
lv2 = {'primaryVolume': {'instanceId': '67890.2'},
|
|
'secondaryVolume': {'instanceId': '12345.2'}}
|
|
mock_get_live_volumes.return_value = [lv1, lv2]
|
|
mock_sc_live_volumes.return_value = []
|
|
retlv = self.scapi.get_live_volume('12345.2')
|
|
self.assertEqual(lv2, retlv)
|
|
mock_sc_live_volumes.assert_called_once_with('12345')
|
|
mock_get_live_volumes.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume_error(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_get_live_volumes.return_value = []
|
|
mock_sc_live_volumes.return_value = []
|
|
retlv = self.scapi.get_live_volume('12345.2')
|
|
self.assertIsNone(retlv)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume_by_name(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lv1 = {'primaryVolume': {'instanceId': '12345.1'},
|
|
'secondaryVolume': {'instanceId': '67890.1',
|
|
'instanceName': fake.VOLUME2_ID},
|
|
'instanceName': 'Live volume of ' + fake.VOLUME2_ID}
|
|
lv2 = {'primaryVolume': {'instanceId': '67890.2'},
|
|
'secondaryVolume': {'instanceId': '12345.2',
|
|
'instanceName': fake.VOLUME_ID},
|
|
'instanceName': 'Live volume of ' + fake.VOLUME_ID}
|
|
mock_get_live_volumes.return_value = [lv1, lv2]
|
|
mock_sc_live_volumes.return_value = []
|
|
retlv = self.scapi.get_live_volume('12345.2', fake.VOLUME_ID)
|
|
self.assertEqual(lv2, retlv)
|
|
mock_sc_live_volumes.assert_called_once_with('12345')
|
|
mock_get_live_volumes.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_sc_live_volumes')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_live_volumes')
|
|
def test_get_live_volume_by_name_unknown(self,
|
|
mock_get_live_volumes,
|
|
mock_sc_live_volumes,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
lv1 = {'primaryVolume': {'instanceId': '12345.1'},
|
|
'secondaryVolume': {'instanceId': '67890.1',
|
|
'instanceName': fake.VOLUME2_ID},
|
|
'instanceName': 'Live volume of ' + fake.VOLUME2_ID}
|
|
lv2 = {'secondaryVolume': {'instanceId': '12345.2',
|
|
'instanceName': fake.VOLUME_ID},
|
|
'instanceName': 'unknown'}
|
|
mock_get_live_volumes.return_value = [lv1, lv2]
|
|
mock_sc_live_volumes.return_value = []
|
|
retlv = self.scapi.get_live_volume('12345.3', fake.VOLUME_ID)
|
|
self.assertEqual(lv2, retlv)
|
|
mock_sc_live_volumes.assert_called_once_with('12345')
|
|
mock_get_live_volumes.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
def test_map_secondary_volume(self,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
sclivevol = {'instanceId': '101.101',
|
|
'secondaryVolume': {'instanceId': '102.101'},
|
|
'secondaryScSerialNumber': 102}
|
|
scdestsrv = {'instanceId': '102.1000'}
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = {'instanceId': '102.101.1'}
|
|
ret = self.scapi.map_secondary_volume(sclivevol, scdestsrv)
|
|
expected_payload = {'Server': '102.1000',
|
|
'Advanced': {'MapToDownServerHbas': True}}
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScLiveVolume/101.101/MapSecondaryVolume',
|
|
expected_payload, True
|
|
)
|
|
self.assertEqual({'instanceId': '102.101.1'}, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_map_secondary_volume_err(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
sclivevol = {'instanceId': '101.101',
|
|
'secondaryVolume': {'instanceId': '102.101'},
|
|
'secondaryScSerialNumber': 102}
|
|
scdestsrv = {'instanceId': '102.1000'}
|
|
mock_post.return_value = self.RESPONSE_400
|
|
ret = self.scapi.map_secondary_volume(sclivevol, scdestsrv)
|
|
expected_payload = {'Server': '102.1000',
|
|
'Advanced': {'MapToDownServerHbas': True}}
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScLiveVolume/101.101/MapSecondaryVolume',
|
|
expected_payload, True
|
|
)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
def test_create_live_volume(self,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {'instanceId': '101.1',
|
|
'name': 'name'}
|
|
sclivevol = {'instanceId': '101.101',
|
|
'secondaryVolume': {'instanceId': '102.101'},
|
|
'secondaryScSerialNumber': 102}
|
|
|
|
remotessn = '102'
|
|
active = True
|
|
sync = False
|
|
primaryqos = 'fast'
|
|
secondaryqos = 'slow'
|
|
mock_find_sc.return_value = 102
|
|
mock_find_qos.side_effect = [{'instanceId': '101.1001'},
|
|
{'instanceId': '102.1001'}]
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = sclivevol
|
|
ret = self.scapi.create_live_volume(scvol, remotessn, active, sync,
|
|
False, primaryqos, secondaryqos)
|
|
mock_find_sc.assert_called_once_with(102)
|
|
mock_find_qos.assert_any_call(primaryqos)
|
|
mock_find_qos.assert_any_call(secondaryqos, 102)
|
|
self.assertEqual(sclivevol, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
def test_create_live_volume_autofailover(self,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_get_json,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {'instanceId': '101.1',
|
|
'name': 'name'}
|
|
sclivevol = {'instanceId': '101.101',
|
|
'secondaryVolume': {'instanceId': '102.101'},
|
|
'secondaryScSerialNumber': 102}
|
|
|
|
remotessn = '102'
|
|
active = True
|
|
sync = False
|
|
primaryqos = 'fast'
|
|
secondaryqos = 'slow'
|
|
mock_find_sc.return_value = 102
|
|
mock_find_qos.side_effect = [{'instanceId': '101.1001'},
|
|
{'instanceId': '102.1001'}]
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = sclivevol
|
|
ret = self.scapi.create_live_volume(scvol, remotessn, active, sync,
|
|
True, primaryqos, secondaryqos)
|
|
mock_find_sc.assert_called_once_with(102)
|
|
mock_find_qos.assert_any_call(primaryqos)
|
|
mock_find_qos.assert_any_call(secondaryqos, 102)
|
|
self.assertEqual(sclivevol, ret)
|
|
# Make sure sync flipped and that we set HighAvailability.
|
|
expected = {'SyncMode': 'HighAvailability',
|
|
'SwapRolesAutomaticallyEnabled': False,
|
|
'SecondaryStorageCenter': 102,
|
|
'FailoverAutomaticallyEnabled': True,
|
|
'StorageCenter': 12345,
|
|
'RestoreAutomaticallyEnabled': True,
|
|
'SecondaryQosNode': '102.1001',
|
|
'ReplicateActiveReplay': True,
|
|
'PrimaryQosNode': '101.1001',
|
|
'Type': 'Synchronous',
|
|
'PrimaryVolume': '101.1',
|
|
'SecondaryVolumeAttributes':
|
|
{'Notes': 'Created by Dell EMC Cinder Driver',
|
|
'CreateSourceVolumeFolderPath': True,
|
|
'Name': 'name'}
|
|
}
|
|
mock_post.assert_called_once_with('StorageCenter/ScLiveVolume',
|
|
expected, True)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
def test_create_live_volume_error(self,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {'instanceId': '101.1',
|
|
'name': 'name'}
|
|
remotessn = '102'
|
|
active = True
|
|
sync = False
|
|
primaryqos = 'fast'
|
|
secondaryqos = 'slow'
|
|
mock_find_sc.return_value = 102
|
|
mock_find_qos.side_effect = [{'instanceId': '101.1001'},
|
|
{'instanceId': '102.1001'}]
|
|
mock_post.return_value = self.RESPONSE_400
|
|
ret = self.scapi.create_live_volume(scvol, remotessn, active, sync,
|
|
False, primaryqos, secondaryqos)
|
|
mock_find_sc.assert_called_once_with(102)
|
|
mock_find_qos.assert_any_call(primaryqos)
|
|
mock_find_qos.assert_any_call(secondaryqos, 102)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
def test_create_live_volume_no_dest(self,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {'instanceId': '101.1',
|
|
'name': 'name'}
|
|
remotessn = '102'
|
|
active = True
|
|
sync = False
|
|
primaryqos = 'fast'
|
|
secondaryqos = 'slow'
|
|
mock_find_sc.return_value = 102
|
|
mock_find_qos.return_value = {}
|
|
ret = self.scapi.create_live_volume(scvol, remotessn, active, sync,
|
|
False, primaryqos, secondaryqos)
|
|
mock_find_sc.assert_called_once_with(102)
|
|
mock_find_qos.assert_any_call(primaryqos)
|
|
mock_find_qos.assert_any_call(secondaryqos, 102)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
def test_create_live_volume_no_qos(self,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {'instanceId': '101.1',
|
|
'name': 'name'}
|
|
remotessn = '102'
|
|
active = True
|
|
sync = False
|
|
primaryqos = 'fast'
|
|
secondaryqos = 'slow'
|
|
mock_find_sc.return_value = 102
|
|
mock_find_qos.return_value = None
|
|
ret = self.scapi.create_live_volume(scvol, remotessn, active, sync,
|
|
False, primaryqos, secondaryqos)
|
|
mock_find_sc.assert_called_once_with(102)
|
|
mock_find_qos.assert_any_call(primaryqos)
|
|
mock_find_qos.assert_any_call(secondaryqos, 102)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_sc')
|
|
def test_create_live_volume_no_secondary_qos(self,
|
|
mock_find_sc,
|
|
mock_find_qos,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
scvol = {'instanceId': '101.1',
|
|
'name': 'name'}
|
|
remotessn = '102'
|
|
active = True
|
|
sync = False
|
|
primaryqos = 'fast'
|
|
secondaryqos = 'slow'
|
|
mock_find_sc.return_value = 102
|
|
mock_find_qos.side_effect = [{'instanceId': '101.1001'},
|
|
None]
|
|
ret = self.scapi.create_live_volume(scvol, remotessn, active, sync,
|
|
False, primaryqos, secondaryqos)
|
|
mock_find_sc.assert_called_once_with(102)
|
|
mock_find_qos.assert_any_call(primaryqos)
|
|
mock_find_qos.assert_any_call(secondaryqos, 102)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
def test_manage_replay(self,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
screplay = {'description': 'notguid',
|
|
'instanceId': 1}
|
|
payload = {'description': 'guid',
|
|
'expireTime': 0}
|
|
mock_put.return_value = self.RESPONSE_200
|
|
ret = self.scapi.manage_replay(screplay, 'guid')
|
|
self.assertTrue(ret)
|
|
mock_put.assert_called_once_with('StorageCenter/ScReplay/1', payload,
|
|
True)
|
|
mock_put.return_value = self.RESPONSE_400
|
|
ret = self.scapi.manage_replay(screplay, 'guid')
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
def test_unmanage_replay(self,
|
|
mock_put,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
screplay = {'description': 'guid',
|
|
'instanceId': 1}
|
|
payload = {'expireTime': 1440}
|
|
mock_put.return_value = self.RESPONSE_200
|
|
ret = self.scapi.unmanage_replay(screplay)
|
|
self.assertTrue(ret)
|
|
mock_put.assert_called_once_with('StorageCenter/ScReplay/1', payload,
|
|
True)
|
|
mock_put.return_value = self.RESPONSE_400
|
|
ret = self.scapi.unmanage_replay(screplay)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_replay_list')
|
|
def test_find_common_replay(self,
|
|
mock_get_replay_list,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
dreplays = [{'globalIndex': '11111.113'},
|
|
{'globalIndex': '11111.112'},
|
|
{'globalIndex': '11111.111'}]
|
|
sreplays = [{'globalIndex': '12345.112'},
|
|
{'globalIndex': '12345.111'},
|
|
{'globalIndex': '11111.112'},
|
|
{'globalIndex': '11111.111'}]
|
|
xreplays = [{'globalIndex': '12345.112'},
|
|
{'globalIndex': '12345.111'}]
|
|
mock_get_replay_list.side_effect = [dreplays, sreplays,
|
|
dreplays, xreplays]
|
|
ret = self.scapi.find_common_replay({'instanceId': '12345.1'},
|
|
{'instanceId': '11111.1'})
|
|
self.assertEqual({'globalIndex': '11111.112'}, ret)
|
|
ret = self.scapi.find_common_replay(None, {'instanceId': '11111.1'})
|
|
self.assertIsNone(ret)
|
|
ret = self.scapi.find_common_replay({'instanceId': '12345.1'}, None)
|
|
self.assertIsNone(ret)
|
|
ret = self.scapi.find_common_replay({'instanceId': '12345.1'},
|
|
{'instanceId': '11111.1'})
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_start_replication(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_find_qos,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
svolume = {'name': 'guida', 'instanceId': '12345.101',
|
|
'scSerialNumber': 12345}
|
|
dvolume = {'name': 'guidb', 'instanceId': '11111.101',
|
|
'scSerialNumber': 11111}
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = {'instanceId': '12345.201'}
|
|
mock_find_qos.return_value = {'instanceId': '12345.1'}
|
|
expected = {'QosNode': '12345.1',
|
|
'SourceVolume': '12345.101',
|
|
'StorageCenter': 12345,
|
|
'ReplicateActiveReplay': False,
|
|
'Type': 'Asynchronous',
|
|
'DestinationVolume': '11111.101',
|
|
'DestinationStorageCenter': 11111}
|
|
ret = self.scapi.start_replication(svolume, dvolume, 'Asynchronous',
|
|
'cinderqos', False)
|
|
self.assertEqual(mock_get_json.return_value, ret)
|
|
mock_post.assert_called_once_with('StorageCenter/ScReplication',
|
|
expected, True)
|
|
mock_post.return_value = self.RESPONSE_400
|
|
ret = self.scapi.start_replication(svolume, dvolume, 'Asynchronous',
|
|
'cinderqos', False)
|
|
self.assertIsNone(ret)
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_find_qos.return_value = None
|
|
ret = self.scapi.start_replication(svolume, dvolume, 'Asynchronous',
|
|
'cinderqos', False)
|
|
self.assertIsNone(ret)
|
|
mock_find_qos.return_value = {'instanceId': '12345.1'}
|
|
ret = self.scapi.start_replication(None, dvolume, 'Asynchronous',
|
|
'cinderqos', False)
|
|
self.assertIsNone(ret)
|
|
ret = self.scapi.start_replication(svolume, None, 'Asynchronous',
|
|
'cinderqos', False)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'find_common_replay')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'create_replay')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'start_replication')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_replicate_to_common(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_start_replication,
|
|
mock_create_replay,
|
|
mock_find_common_replay,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
creplay = {'instanceId': '11111.201'}
|
|
svolume = {'name': 'guida'}
|
|
dvolume = {'name': 'guidb', 'volumeFolder': {'instanceId': '11111.1'}}
|
|
vvolume = {'name': 'guidc'}
|
|
mock_find_common_replay.return_value = creplay
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = vvolume
|
|
mock_create_replay.return_value = {'instanceId': '12345.202'}
|
|
mock_start_replication.return_value = {'instanceId': '12345.203'}
|
|
# Simple common test.
|
|
ret = self.scapi.replicate_to_common(svolume, dvolume, 'cinderqos')
|
|
self.assertEqual(mock_start_replication.return_value, ret)
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScReplay/11111.201/CreateView',
|
|
{'Name': 'fback:guidb',
|
|
'Notes': 'Created by Dell EMC Cinder Driver',
|
|
'VolumeFolder': '11111.1'},
|
|
True)
|
|
mock_create_replay.assert_called_once_with(svolume, 'failback', 600)
|
|
mock_start_replication.assert_called_once_with(svolume, vvolume,
|
|
'Asynchronous',
|
|
'cinderqos',
|
|
False)
|
|
mock_create_replay.return_value = None
|
|
# Unable to create a replay.
|
|
ret = self.scapi.replicate_to_common(svolume, dvolume, 'cinderqos')
|
|
self.assertIsNone(ret)
|
|
mock_create_replay.return_value = {'instanceId': '12345.202'}
|
|
mock_get_json.return_value = None
|
|
# Create view volume fails.
|
|
ret = self.scapi.replicate_to_common(svolume, dvolume, 'cinderqos')
|
|
self.assertIsNone(ret)
|
|
mock_get_json.return_value = vvolume
|
|
mock_post.return_value = self.RESPONSE_400
|
|
# Post call returns an error.
|
|
ret = self.scapi.replicate_to_common(svolume, dvolume, 'cinderqos')
|
|
self.assertIsNone(ret)
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_find_common_replay.return_value = None
|
|
# No common replay found.
|
|
ret = self.scapi.replicate_to_common(svolume, dvolume, 'cinderqos')
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'delete_replication')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'start_replication')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'rename_volume')
|
|
def test_flip_replication(self,
|
|
mock_rename_volume,
|
|
mock_start_replication,
|
|
mock_delete_replication,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
svolume = {'scSerialNumber': '12345.1'}
|
|
dvolume = {'scSerialNumber': '11111.1'}
|
|
name = 'guid'
|
|
replicationtype = 'Synchronous'
|
|
qosnode = 'cinderqos'
|
|
activereplay = True
|
|
mock_delete_replication.return_value = True
|
|
mock_start_replication.return_value = {'instanceId': '11111.101'}
|
|
mock_rename_volume.return_value = True
|
|
# Good run.
|
|
ret = self.scapi.flip_replication(svolume, dvolume, name,
|
|
replicationtype, qosnode,
|
|
activereplay)
|
|
self.assertTrue(ret)
|
|
mock_delete_replication.assert_called_once_with(svolume, '11111.1',
|
|
False)
|
|
mock_start_replication.assert_called_once_with(dvolume, svolume,
|
|
replicationtype,
|
|
qosnode, activereplay)
|
|
mock_rename_volume.assert_any_call(svolume, 'Cinder repl of guid')
|
|
mock_rename_volume.assert_any_call(dvolume, 'guid')
|
|
mock_rename_volume.return_value = False
|
|
# Unable to rename volumes.
|
|
ret = self.scapi.flip_replication(svolume, dvolume, name,
|
|
replicationtype, qosnode,
|
|
activereplay)
|
|
self.assertFalse(ret)
|
|
mock_rename_volume.return_value = True
|
|
mock_start_replication.return_value = None
|
|
# Start replication call fails.
|
|
ret = self.scapi.flip_replication(svolume, dvolume, name,
|
|
replicationtype, qosnode,
|
|
activereplay)
|
|
self.assertFalse(ret)
|
|
mock_delete_replication.return_value = False
|
|
mock_start_replication.return_value = {'instanceId': '11111.101'}
|
|
# Delete old replication call fails.
|
|
ret = self.scapi.flip_replication(svolume, dvolume, name,
|
|
replicationtype, qosnode,
|
|
activereplay)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
def test_replication_progress(self,
|
|
mock_get,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_get.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = {'synced': True,
|
|
'amountRemaining': '0 Bytes'}
|
|
# Good run
|
|
retbool, retnum = self.scapi.replication_progress('11111.101')
|
|
self.assertTrue(retbool)
|
|
self.assertEqual(0.0, retnum)
|
|
# SC replication ID is None.
|
|
retbool, retnum = self.scapi.replication_progress(None)
|
|
self.assertIsNone(retbool)
|
|
self.assertIsNone(retnum)
|
|
mock_get.return_value = self.RESPONSE_400
|
|
# Get progress call fails.
|
|
retbool, retnum = self.scapi.replication_progress('11111.101')
|
|
self.assertIsNone(retbool)
|
|
self.assertIsNone(retnum)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'delete')
|
|
def test_delete_live_volume(self,
|
|
mock_delete,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_delete.return_value = self.RESPONSE_200
|
|
ret = self.scapi.delete_live_volume({'instanceId': '12345.101'},
|
|
True)
|
|
self.assertTrue(ret)
|
|
mock_delete.return_value = self.RESPONSE_400
|
|
ret = self.scapi.delete_live_volume({'instanceId': '12345.101'},
|
|
True)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_swap_roles_live_volume(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
lv = {'instanceId': '12345.0'}
|
|
ret = self.scapi.swap_roles_live_volume(lv)
|
|
self.assertTrue(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test_swap_roles_live_volume_fail(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_400
|
|
lv = {'instanceId': '12345.0'}
|
|
ret = self.scapi.swap_roles_live_volume(lv)
|
|
self.assertFalse(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_qos_profile(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = [{'instanceId': '12345.0'}]
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'ScSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'Name',
|
|
'attributeValue': 'Default'},
|
|
{'filterType': 'Equals', 'attributeName': 'profileType',
|
|
'attributeValue': 'VolumeQosProfile'}]}}
|
|
ret = self.scapi._find_qos_profile('Default', False)
|
|
self.assertEqual({'instanceId': '12345.0'}, ret)
|
|
mock_post.assert_called_once_with('StorageCenter/ScQosProfile/GetList',
|
|
expected_payload)
|
|
|
|
def test__find_qos_no_qosprofile(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi._find_qos_profile('', False)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_qos_error(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_400
|
|
ret = self.scapi._find_qos_profile('Default', False)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_qos_profile_empty_list(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = []
|
|
ret = self.scapi._find_qos_profile('Default', False)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_qos_profile_group(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = [{'instanceId': '12345.0'}]
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'ScSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'Name',
|
|
'attributeValue': 'Default'},
|
|
{'filterType': 'Equals', 'attributeName': 'profileType',
|
|
'attributeValue': 'GroupQosProfile'}]}}
|
|
ret = self.scapi._find_qos_profile('Default', True)
|
|
self.assertEqual({'instanceId': '12345.0'}, ret)
|
|
mock_post.assert_called_once_with('StorageCenter/ScQosProfile/GetList',
|
|
expected_payload)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_datareduction_profile(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = [{'instanceId': '12345.0'}]
|
|
expected_payload = {'filter': {'filterType': 'AND', 'filters': [
|
|
{'filterType': 'Equals', 'attributeName': 'ScSerialNumber',
|
|
'attributeValue': 12345},
|
|
{'filterType': 'Equals', 'attributeName': 'type',
|
|
'attributeValue': 'Compression'}]}}
|
|
ret = self.scapi._find_data_reduction_profile('Compression')
|
|
self.assertEqual({'instanceId': '12345.0'}, ret)
|
|
mock_post.assert_called_once_with(
|
|
'StorageCenter/ScDataReductionProfile/GetList', expected_payload)
|
|
|
|
def test__find_datareduction_profile_no_drprofile(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
ret = self.scapi._find_data_reduction_profile('')
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_datareduction_profile_error(self,
|
|
mock_post,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_400
|
|
ret = self.scapi._find_data_reduction_profile('Compression')
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post')
|
|
def test__find_datareduction_profile_empty_list(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
mock_post.return_value = self.RESPONSE_200
|
|
mock_get_json.return_value = []
|
|
ret = self.scapi._find_data_reduction_profile('Compression')
|
|
self.assertIsNone(ret)
|
|
|
|
def test__check_add_profile_payload(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
payload = {}
|
|
profile = {'instanceId': '12345.0'}
|
|
self.scapi._check_add_profile_payload(payload, profile,
|
|
'Profile1', 'GroupQosProfile')
|
|
self.assertEqual({'GroupQosProfile': '12345.0'}, payload)
|
|
|
|
def test__check_add_profile_payload_no_name(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
payload = {}
|
|
profile = {'instanceId': '12345.0'}
|
|
self.scapi._check_add_profile_payload(payload, profile,
|
|
None, 'GroupQosProfile')
|
|
self.assertEqual({}, payload)
|
|
|
|
def test__check_add_profile_payload_no_profile(self,
|
|
mock_close_connection,
|
|
mock_open_connection,
|
|
mock_init):
|
|
payload = {}
|
|
profile = None
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi._check_add_profile_payload,
|
|
payload, profile, 'Profile1',
|
|
'VolumeQosProfile')
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile(
|
|
self, mock_find_datareduction_profile, mock_put, mock_prefs,
|
|
mock_close_connection, mock_open_connection, mock_init):
|
|
# Test we get and set our default
|
|
mock_find_datareduction_profile.return_value = {}
|
|
mock_prefs.return_value = {
|
|
'allowDataReductionSelection': True,
|
|
'dataReductionProfile': {'name': 'Default',
|
|
'instanceId': '12345.0'}}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
mock_put.return_value = self.RESPONSE_200
|
|
expected = {'dataReductionProfile': '12345.0'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, None)
|
|
self.assertTrue(res)
|
|
mock_put.assert_called_once_with(
|
|
'StorageCenter/ScVolumeConfiguration/12345.101', expected, True)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile_error(
|
|
self, mock_find_datareduction_profile, mock_put, mock_prefs,
|
|
mock_close_connection, mock_open_connection, mock_init):
|
|
# Test we get and set our default
|
|
mock_find_datareduction_profile.return_value = {}
|
|
mock_prefs.return_value = {
|
|
'allowDataReductionSelection': True,
|
|
'dataReductionProfile': {'name': 'Default',
|
|
'instanceId': '12345.0'}}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
mock_put.return_value = self.RESPONSE_400
|
|
expected = {'dataReductionProfile': '12345.0'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
mock_put.assert_called_once_with(
|
|
'StorageCenter/ScVolumeConfiguration/12345.101', expected, True)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile_not_found(
|
|
self, mock_find_datareduction_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_datareduction_profile.return_value = None
|
|
mock_prefs.return_value = {'allowDataReductionSelection': True}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, 'Profile')
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile_not_allowed(
|
|
self, mock_find_datareduction_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_datareduction_profile.return_value = None
|
|
mock_prefs.return_value = {'allowDataReductionSelection': False}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile_prefs_not_found(
|
|
self, mock_find_datareduction_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_datareduction_profile.return_value = None
|
|
mock_prefs.return_value = None
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile_default_not_found(
|
|
self, mock_find_datareduction_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_datareduction_profile.return_value = None
|
|
mock_prefs.return_value = {'allowDataReductionSelection': True}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_datareduction_profile_default(
|
|
self, mock_find_datareduction_profile, mock_put, mock_prefs,
|
|
mock_close_connection, mock_open_connection, mock_init):
|
|
# Test we get and set our default
|
|
mock_find_datareduction_profile.return_value = None
|
|
mock_prefs.return_value = {
|
|
'allowDataReductionSelection': True,
|
|
'dataReductionProfile': {'name': 'Default',
|
|
'instanceId': '12345.0'}}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_datareduction_profile(scvolume, None)
|
|
self.assertTrue(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_update_qos_profile(
|
|
self, mock_find_qos_profile, mock_put, mock_prefs,
|
|
mock_close_connection, mock_open_connection, mock_init):
|
|
# Test we get and set our default
|
|
mock_find_qos_profile.return_value = {}
|
|
mock_prefs.return_value = {
|
|
'allowQosProfileSelection': True,
|
|
'volumeQosProfile': {'name': 'Default',
|
|
'instanceId': '12345.0'}}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
mock_put.return_value = self.RESPONSE_200
|
|
expected = {'volumeQosProfile': '12345.0'}
|
|
res = self.scapi.update_qos_profile(scvolume, None)
|
|
self.assertTrue(res)
|
|
mock_put.assert_called_once_with(
|
|
'StorageCenter/ScVolumeConfiguration/12345.101', expected, True)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_data_reduction_profile')
|
|
def test_update_qos_profile_error(
|
|
self, mock_find_qos_profile, mock_put, mock_prefs,
|
|
mock_close_connection, mock_open_connection, mock_init):
|
|
# Test we get and set our default
|
|
mock_find_qos_profile.return_value = {}
|
|
mock_prefs.return_value = {
|
|
'allowQosProfileSelection': True,
|
|
'volumeQosProfile': {'name': 'Default',
|
|
'instanceId': '12345.0'}}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
mock_put.return_value = self.RESPONSE_400
|
|
expected = {'volumeQosProfile': '12345.0'}
|
|
res = self.scapi.update_qos_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
mock_put.assert_called_once_with(
|
|
'StorageCenter/ScVolumeConfiguration/12345.101', expected, True)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_update_qos_profile_not_found(
|
|
self, mock_find_qos_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_qos_profile.return_value = None
|
|
mock_prefs.return_value = {'allowQosProfileSelection': True}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_qos_profile(scvolume, 'Profile')
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_update_qos_profile_not_allowed(
|
|
self, mock_find_qos_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_qos_profile.return_value = None
|
|
mock_prefs.return_value = {'allowQosProfileSelection': False}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_qos_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_update_qos_profile_prefs_not_found(
|
|
self, mock_find_qos_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_qos_profile.return_value = None
|
|
mock_prefs.return_value = None
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_qos_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_update_qos_profile_default_not_found(
|
|
self, mock_find_qos_profile, mock_prefs,
|
|
mock_close_connection, mock_open_connection,
|
|
mock_init):
|
|
mock_find_qos_profile.return_value = None
|
|
mock_prefs.return_value = {'allowQosProfileSelection': True}
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_qos_profile(scvolume, None)
|
|
self.assertFalse(res)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_user_preferences')
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'put')
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_find_qos_profile')
|
|
def test_update_qos_profile_default(
|
|
self, mock_find_qos_profile, mock_put, mock_prefs,
|
|
mock_close_connection, mock_open_connection, mock_init):
|
|
# Test we get and set our default
|
|
mock_find_qos_profile.return_value = None
|
|
mock_prefs.return_value = {
|
|
'allowQosProfileSelection': True,
|
|
'volumeQosProfile': {'name': 'Default',
|
|
'instanceId': '12345.0'}}
|
|
mock_put.return_value = self.RESPONSE_200
|
|
scvolume = {'name': fake.VOLUME_ID, 'instanceId': '12345.101'}
|
|
res = self.scapi.update_qos_profile(scvolume, None)
|
|
self.assertTrue(res)
|
|
|
|
|
|
class DellSCSanAPIConnectionTestCase(test.TestCase):
|
|
|
|
"""DellSCSanAPIConnectionTestCase
|
|
|
|
Class to test the Storage Center API connection using Mock.
|
|
"""
|
|
|
|
# Create a Response object that indicates OK
|
|
response_ok = models.Response()
|
|
response_ok.status_code = 200
|
|
response_ok.reason = u'ok'
|
|
RESPONSE_200 = response_ok
|
|
|
|
# Create a Response object with no content
|
|
response_nc = models.Response()
|
|
response_nc.status_code = 204
|
|
response_nc.reason = u'duplicate'
|
|
RESPONSE_204 = response_nc
|
|
|
|
# Create a Response object is a pure error.
|
|
response_bad = models.Response()
|
|
response_bad.status_code = 400
|
|
response_bad._content = ''
|
|
response_bad._content_consumed = True
|
|
response_bad.reason = u'bad request'
|
|
response_bad._content = ''
|
|
response_bad._content_consumed = True
|
|
RESPONSE_400 = response_bad
|
|
|
|
APIDICT = {u'instanceId': u'0',
|
|
u'hostName': u'192.168.0.200',
|
|
u'userId': 434226,
|
|
u'connectionKey': u'',
|
|
u'minApiVersion': u'0.1',
|
|
u'webServicesPort': 3033,
|
|
u'locale': u'en_US',
|
|
u'objectType': u'ApiConnection',
|
|
u'secureString': u'',
|
|
u'applicationVersion': u'2.0.1',
|
|
u'source': u'REST',
|
|
u'commandLine': False,
|
|
u'application': u'Cinder REST Driver',
|
|
u'sessionKey': 1436460614863,
|
|
u'provider': u'EnterpriseManager',
|
|
u'instanceName': u'ApiConnection',
|
|
u'connected': True,
|
|
u'userName': u'Admin',
|
|
u'useHttps': False,
|
|
u'providerVersion': u'15.3.1.186',
|
|
u'apiVersion': u'2.2',
|
|
u'apiBuild': 199}
|
|
|
|
def setUp(self):
|
|
super(DellSCSanAPIConnectionTestCase, self).setUp()
|
|
|
|
# Configuration is a mock. A mock is pretty much a blank
|
|
# slate. I believe mock's done in setup are not happy time
|
|
# mocks. So we just do a few things like driver config here.
|
|
self.configuration = mock.Mock()
|
|
|
|
self.configuration.san_is_local = False
|
|
self.configuration.san_ip = "192.168.0.1"
|
|
self.configuration.san_login = "admin"
|
|
self.configuration.san_password = "mmm"
|
|
self.configuration.dell_sc_ssn = 12345
|
|
self.configuration.dell_sc_server_folder = 'openstack'
|
|
self.configuration.dell_sc_volume_folder = 'openstack'
|
|
# Note that we set this to True even though we do not
|
|
# test this functionality. This is sent directly to
|
|
# the requests calls as the verify parameter and as
|
|
# that is a third party library deeply stubbed out is
|
|
# not directly testable by this code. Note that in the
|
|
# case that this fails the driver fails to even come
|
|
# up.
|
|
self.configuration.dell_sc_verify_cert = True
|
|
self.configuration.dell_sc_api_port = 3033
|
|
self.configuration.target_ip_address = '192.168.1.1'
|
|
self.configuration.target_port = 3260
|
|
self._context = context.get_admin_context()
|
|
self.asynctimeout = 15
|
|
self.synctimeout = 30
|
|
self.apiversion = '2.0'
|
|
|
|
# Set up the SCApi
|
|
self.scapi = storagecenter_api.SCApi(
|
|
self.configuration.san_ip,
|
|
self.configuration.dell_sc_api_port,
|
|
self.configuration.san_login,
|
|
self.configuration.san_password,
|
|
self.configuration.dell_sc_verify_cert,
|
|
self.asynctimeout,
|
|
self.synctimeout,
|
|
self.apiversion)
|
|
|
|
# Set up the scapi configuration vars
|
|
self.scapi.ssn = self.configuration.dell_sc_ssn
|
|
self.scapi.sfname = self.configuration.dell_sc_server_folder
|
|
self.scapi.vfname = self.configuration.dell_sc_volume_folder
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=APIDICT)
|
|
def test_open_connection(self,
|
|
mock_get_json,
|
|
mock_post):
|
|
self.scapi.open_connection()
|
|
self.assertTrue(mock_post.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_check_version_fail',
|
|
return_value=RESPONSE_400)
|
|
def test_open_connection_failure(self,
|
|
mock_check_version_fail,
|
|
mock_post):
|
|
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.scapi.open_connection)
|
|
self.assertTrue(mock_check_version_fail.called)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_check_version_fail',
|
|
return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'_get_json',
|
|
return_value=APIDICT)
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_400)
|
|
def test_open_connection_sc(self,
|
|
mock_post,
|
|
mock_get_json,
|
|
mock_check_version_fail):
|
|
self.scapi.open_connection()
|
|
self.assertTrue(mock_check_version_fail.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_204)
|
|
def test_close_connection(self,
|
|
mock_post):
|
|
self.scapi.close_connection()
|
|
self.assertTrue(mock_post.called)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'post',
|
|
return_value=RESPONSE_200)
|
|
def test_close_connection_failure(self,
|
|
mock_post):
|
|
self.scapi.close_connection()
|
|
self.assertTrue(mock_post.called)
|
|
|
|
|
|
class DellHttpClientTestCase(test.TestCase):
|
|
|
|
"""DellSCSanAPIConnectionTestCase
|
|
|
|
Class to test the Storage Center API connection using Mock.
|
|
"""
|
|
|
|
ASYNCTASK = {"state": "Running",
|
|
"methodName": "GetScUserPreferencesDefaults",
|
|
"error": "",
|
|
"started": True,
|
|
"userName": "",
|
|
"localizedError": "",
|
|
"returnValue": "https://localhost:3033/api/rest/"
|
|
"ApiConnection/AsyncTask/1418394170395",
|
|
"storageCenter": 0,
|
|
"errorState": "None",
|
|
"successful": False,
|
|
"stepMessage": "Running Method [Object: ScUserPreferences] "
|
|
"[Method: GetScUserPreferencesDefaults]",
|
|
"localizedStepMessage": "",
|
|
"warningList": [],
|
|
"totalSteps": 2,
|
|
"timeFinished": "1969-12-31T18:00:00-06:00",
|
|
"timeStarted": "2015-01-07T14:07:10-06:00",
|
|
"currentStep": 1,
|
|
"objectTypeName": "ScUserPreferences",
|
|
"objectType": "AsyncTask",
|
|
"instanceName": "1418394170395",
|
|
"instanceId": "1418394170395"}
|
|
|
|
# Create a Response object that indicates OK
|
|
response_ok = models.Response()
|
|
response_ok.status_code = 200
|
|
response_ok.reason = u'ok'
|
|
response_ok._content = ''
|
|
response_ok._content_consumed = True
|
|
RESPONSE_200 = response_ok
|
|
|
|
# Create a Response object with no content
|
|
response_nc = models.Response()
|
|
response_nc.status_code = 204
|
|
response_nc.reason = u'duplicate'
|
|
response_nc._content = ''
|
|
response_nc._content_consumed = True
|
|
RESPONSE_204 = response_nc
|
|
|
|
# Create a Response object is a pure error.
|
|
response_bad = models.Response()
|
|
response_bad.status_code = 400
|
|
response_bad.reason = u'bad request'
|
|
response_bad._content = ''
|
|
response_bad._content_consumed = True
|
|
RESPONSE_400 = response_bad
|
|
|
|
def setUp(self):
|
|
super(DellHttpClientTestCase, self).setUp()
|
|
self.host = 'localhost'
|
|
self.port = '3033'
|
|
self.user = 'johnnyuser'
|
|
self.password = 'password'
|
|
self.verify = False
|
|
self.asynctimeout = 15
|
|
self.synctimeout = 30
|
|
self.apiversion = '3.1'
|
|
self.httpclient = storagecenter_api.HttpClient(
|
|
self.host, self.port, self.user, self.password, self.verify,
|
|
self.asynctimeout, self.synctimeout, self.apiversion)
|
|
|
|
def test_get_async_url(self):
|
|
url = self.httpclient._get_async_url(self.ASYNCTASK)
|
|
self.assertEqual('api/rest/ApiConnection/AsyncTask/1418394170395', url)
|
|
|
|
def test_get_async_url_no_id_on_url(self):
|
|
badTask = self.ASYNCTASK.copy()
|
|
badTask['returnValue'] = ('https://localhost:3033/api/rest/'
|
|
'ApiConnection/AsyncTask/')
|
|
url = self.httpclient._get_async_url(badTask)
|
|
self.assertEqual('api/rest/ApiConnection/AsyncTask/1418394170395', url)
|
|
|
|
def test_get_async_url_none(self):
|
|
self.assertRaises(AttributeError, self.httpclient._get_async_url, None)
|
|
|
|
def test_get_async_url_no_id(self):
|
|
badTask = self.ASYNCTASK.copy()
|
|
badTask['returnValue'] = ('https://localhost:3033/api/rest/'
|
|
'ApiConnection/AsyncTask/')
|
|
badTask['instanceId'] = ''
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.httpclient._get_async_url, badTask)
|
|
|
|
def test_get_async_url_no_returnvalue(self):
|
|
badTask = self.ASYNCTASK.copy()
|
|
badTask['returnValue'] = None
|
|
url = self.httpclient._get_async_url(badTask)
|
|
self.assertEqual('api/rest/ApiConnection/AsyncTask/1418394170395', url)
|
|
|
|
def test_get_async_url_no_blank_returnvalue(self):
|
|
badTask = self.ASYNCTASK.copy()
|
|
badTask['returnValue'] = ''
|
|
url = self.httpclient._get_async_url(badTask)
|
|
self.assertEqual('api/rest/ApiConnection/AsyncTask/1418394170395', url)
|
|
|
|
def test_get_async_url_xml_returnvalue(self):
|
|
badTask = self.ASYNCTASK.copy()
|
|
badTask['returnValue'] = ('<compapi><ApiMethodReturn><Error></Error>'
|
|
'<ErrorCode>1</ErrorCode>'
|
|
'<ErrorDetail></ErrorDetail>'
|
|
'<Locale>1</Locale>'
|
|
'<LocalizedError></LocalizedError>'
|
|
'<ObjectType>ApiMethodReturn</ObjectType>'
|
|
'<ReturnObjectEncode>1</ReturnObjectEncode>'
|
|
'<Successful>True</Successful>'
|
|
'</ApiMethodReturn>'
|
|
'<ReturnBool>false</ReturnBool></compapi>')
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.httpclient._get_async_url, badTask)
|
|
|
|
def test_rest_ret(self):
|
|
rest_response = self.RESPONSE_200
|
|
response = self.httpclient._rest_ret(rest_response, False)
|
|
self.assertEqual(self.RESPONSE_200, response)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'_wait_for_async_complete',
|
|
return_value=RESPONSE_200)
|
|
def test_rest_ret_async(self,
|
|
mock_wait_for_async_complete):
|
|
mock_rest_response = mock.MagicMock()
|
|
mock_rest_response.status_code = 202
|
|
response = self.httpclient._rest_ret(mock_rest_response, True)
|
|
self.assertEqual(self.RESPONSE_200, response)
|
|
self.assertTrue(mock_wait_for_async_complete.called)
|
|
|
|
def test_rest_ret_async_error(self):
|
|
mock_rest_response = mock.MagicMock()
|
|
mock_rest_response.status_code = 400
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.httpclient._rest_ret, mock_rest_response, True)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_wait_for_async_complete(self,
|
|
mock_get):
|
|
ret = self.httpclient._wait_for_async_complete(self.ASYNCTASK)
|
|
self.assertEqual(self.RESPONSE_200, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'_get_async_url',
|
|
return_value=None)
|
|
def test_wait_for_async_complete_bad_url(self,
|
|
mock_get_async_url):
|
|
ret = self.httpclient._wait_for_async_complete(self.ASYNCTASK)
|
|
self.assertIsNone(ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_400)
|
|
def test_wait_for_async_complete_bad_result(self,
|
|
mock_get):
|
|
ret = self.httpclient._wait_for_async_complete(self.ASYNCTASK)
|
|
self.assertEqual(self.RESPONSE_400, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_wait_for_async_complete_loop(self,
|
|
mock_get):
|
|
mock_response = mock.MagicMock()
|
|
mock_response.content = mock.MagicMock()
|
|
mock_response.json = mock.MagicMock()
|
|
mock_response.json.side_effect = [self.ASYNCTASK,
|
|
{'objectType': 'ScVol'}]
|
|
ret = self.httpclient._wait_for_async_complete(self.ASYNCTASK)
|
|
self.assertEqual(self.RESPONSE_200, ret)
|
|
|
|
@mock.patch.object(storagecenter_api.HttpClient,
|
|
'get')
|
|
def test_wait_for_async_complete_get_raises(self,
|
|
mock_get):
|
|
mock_get.side_effect = (exception.DellDriverRetryableException())
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
self.httpclient._wait_for_async_complete,
|
|
self.ASYNCTASK)
|
|
|
|
@mock.patch.object(requests.Session,
|
|
'get',
|
|
return_value=RESPONSE_200)
|
|
def test_get(self,
|
|
mock_get):
|
|
ret = self.httpclient.get('url')
|
|
self.assertEqual(self.RESPONSE_200, ret)
|
|
expected_headers = self.httpclient.header.copy()
|
|
mock_get.assert_called_once_with('https://localhost:3033/api/rest/url',
|
|
headers=expected_headers,
|
|
timeout=30,
|
|
verify=False)
|
|
|
|
@mock.patch.object(requests.Session, 'post', return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.HttpClient, '_rest_ret')
|
|
def test_post(self, mock_rest_ret, mock_post):
|
|
payload = {'payload': 'payload'}
|
|
self.httpclient.post('url', payload, True)
|
|
expected_headers = self.httpclient.header.copy()
|
|
expected_headers['async'] = 'True'
|
|
mock_post.assert_called_once_with(
|
|
'https://localhost:3033/api/rest/url',
|
|
data=json.dumps(payload, ensure_ascii=False).encode('utf-8'),
|
|
headers=expected_headers,
|
|
timeout=15,
|
|
verify=False)
|
|
|
|
@mock.patch.object(requests.Session, 'post', return_value=RESPONSE_200)
|
|
@mock.patch.object(storagecenter_api.HttpClient, '_rest_ret')
|
|
def test_post_sync(self, mock_rest_ret, mock_post):
|
|
payload = {'payload': 'payload'}
|
|
self.httpclient.post('url', payload, False)
|
|
expected_headers = self.httpclient.header.copy()
|
|
mock_post.assert_called_once_with(
|
|
'https://localhost:3033/api/rest/url',
|
|
data=json.dumps(payload, ensure_ascii=False).encode('utf-8'),
|
|
headers=expected_headers,
|
|
timeout=30,
|
|
verify=False)
|
|
|
|
|
|
class DellStorageCenterApiHelperTestCase(test.TestCase):
|
|
|
|
"""DellStorageCenterApiHelper test case
|
|
|
|
Class to test the Storage Center API helper using Mock.
|
|
"""
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'open_connection')
|
|
def test_setup_connection(self,
|
|
mock_open_connection):
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.dell_sc_volume_folder = 'a'
|
|
config.dell_sc_server_folder = 'a'
|
|
config.dell_sc_verify_cert = False
|
|
config.san_port = 3033
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'FC')
|
|
ret = helper._setup_connection()
|
|
self.assertEqual(12345, ret.primaryssn)
|
|
self.assertEqual(12345, ret.ssn)
|
|
self.assertEqual('FibreChannel', ret.protocol)
|
|
mock_open_connection.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'open_connection')
|
|
def test_setup_connection_iscsi(self,
|
|
mock_open_connection):
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.dell_sc_volume_folder = 'a'
|
|
config.dell_sc_server_folder = 'a'
|
|
config.dell_sc_verify_cert = False
|
|
config.san_port = 3033
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'iSCSI')
|
|
ret = helper._setup_connection()
|
|
self.assertEqual(12345, ret.primaryssn)
|
|
self.assertEqual(12345, ret.ssn)
|
|
self.assertEqual('Iscsi', ret.protocol)
|
|
mock_open_connection.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApi,
|
|
'open_connection')
|
|
def test_setup_connection_failover(self,
|
|
mock_open_connection):
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.dell_sc_volume_folder = 'a'
|
|
config.dell_sc_server_folder = 'a'
|
|
config.dell_sc_verify_cert = False
|
|
config.san_port = 3033
|
|
helper = storagecenter_api.SCApiHelper(config, '67890', 'iSCSI')
|
|
ret = helper._setup_connection()
|
|
self.assertEqual(12345, ret.primaryssn)
|
|
self.assertEqual(67890, ret.ssn)
|
|
self.assertEqual('Iscsi', ret.protocol)
|
|
mock_open_connection.assert_called_once_with()
|
|
|
|
@mock.patch.object(storagecenter_api.SCApiHelper,
|
|
'_setup_connection')
|
|
def test_open_connection(self,
|
|
mock_setup_connection):
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.san_port = 3033
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'FC')
|
|
mock_connection = mock.MagicMock()
|
|
mock_connection.apiversion = '3.1'
|
|
mock_setup_connection.return_value = mock_connection
|
|
ret = helper.open_connection()
|
|
self.assertEqual('3.1', ret.apiversion)
|
|
self.assertEqual('192.168.0.101', helper.san_ip)
|
|
self.assertEqual('username', helper.san_login)
|
|
self.assertEqual('password', helper.san_password)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApiHelper,
|
|
'_setup_connection')
|
|
def test_open_connection_fail_no_secondary(self,
|
|
mock_setup_connection):
|
|
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.san_port = 3033
|
|
config.secondary_san_ip = ''
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'FC')
|
|
mock_setup_connection.side_effect = (
|
|
exception.VolumeBackendAPIException('abc'))
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
helper.open_connection)
|
|
mock_setup_connection.assert_called_once_with()
|
|
self.assertEqual('192.168.0.101', helper.san_ip)
|
|
self.assertEqual('username', helper.san_login)
|
|
self.assertEqual('password', helper.san_password)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApiHelper,
|
|
'_setup_connection')
|
|
def test_open_connection_secondary(self,
|
|
mock_setup_connection):
|
|
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.san_port = 3033
|
|
config.secondary_san_ip = '192.168.0.102'
|
|
config.secondary_san_login = 'username2'
|
|
config.secondary_san_password = 'password2'
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'FC')
|
|
mock_connection = mock.MagicMock()
|
|
mock_connection.apiversion = '3.1'
|
|
mock_setup_connection.side_effect = [
|
|
(exception.VolumeBackendAPIException('abc')), mock_connection]
|
|
ret = helper.open_connection()
|
|
self.assertEqual('3.1', ret.apiversion)
|
|
self.assertEqual(2, mock_setup_connection.call_count)
|
|
self.assertEqual('192.168.0.102', helper.san_ip)
|
|
self.assertEqual('username2', helper.san_login)
|
|
self.assertEqual('password2', helper.san_password)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApiHelper,
|
|
'_setup_connection')
|
|
def test_open_connection_fail_partial_secondary_config(
|
|
self, mock_setup_connection):
|
|
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.san_port = 3033
|
|
config.secondary_san_ip = '192.168.0.102'
|
|
config.secondary_san_login = 'username2'
|
|
config.secondary_san_password = ''
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'FC')
|
|
mock_setup_connection.side_effect = (
|
|
exception.VolumeBackendAPIException('abc'))
|
|
self.assertRaises(exception.VolumeBackendAPIException,
|
|
helper.open_connection)
|
|
mock_setup_connection.assert_called_once_with()
|
|
self.assertEqual('192.168.0.101', helper.san_ip)
|
|
self.assertEqual('username', helper.san_login)
|
|
self.assertEqual('password', helper.san_password)
|
|
|
|
@mock.patch.object(storagecenter_api.SCApiHelper,
|
|
'_setup_connection')
|
|
def test_open_connection_to_secondary_and_back(self,
|
|
mock_setup_connection):
|
|
|
|
config = mock.MagicMock()
|
|
config.dell_sc_ssn = 12345
|
|
config.san_ip = '192.168.0.101'
|
|
config.san_login = 'username'
|
|
config.san_password = 'password'
|
|
config.san_port = 3033
|
|
config.secondary_san_ip = '192.168.0.102'
|
|
config.secondary_san_login = 'username2'
|
|
config.secondary_san_password = 'password2'
|
|
helper = storagecenter_api.SCApiHelper(config, None, 'FC')
|
|
mock_connection = mock.MagicMock()
|
|
mock_connection.apiversion = '3.1'
|
|
mock_setup_connection.side_effect = [
|
|
(exception.VolumeBackendAPIException('abc')), mock_connection,
|
|
(exception.VolumeBackendAPIException('abc')), mock_connection]
|
|
helper.open_connection()
|
|
self.assertEqual('192.168.0.102', helper.san_ip)
|
|
self.assertEqual('username2', helper.san_login)
|
|
self.assertEqual('password2', helper.san_password)
|
|
self.assertEqual(2, mock_setup_connection.call_count)
|
|
helper.open_connection()
|
|
self.assertEqual('192.168.0.101', helper.san_ip)
|
|
self.assertEqual('username', helper.san_login)
|
|
self.assertEqual('password', helper.san_password)
|