166 lines
6.2 KiB
Python
166 lines
6.2 KiB
Python
# Copyright 2016 IBM Corp. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import mock
|
|
|
|
from nova.compute import manager as compute_manager
|
|
from nova.test import TestCase
|
|
from nova_dpm.tests.unit.virt.dpm import fakeutils
|
|
from nova_dpm.tests.unit.virt.dpm import fakezhmcclient
|
|
from nova_dpm.virt.dpm import vm
|
|
|
|
|
|
"""
|
|
vm unit testcase
|
|
"""
|
|
|
|
|
|
def getMockInstance():
|
|
session = fakezhmcclient.Session("hostip", "dummyhost", "dummyhost")
|
|
client = fakezhmcclient.Client(session)
|
|
cpc = fakezhmcclient.getFakeCPC()
|
|
inst = vm.PartitionInstance(fakeutils.getFakeInstance(), cpc, client)
|
|
inst.partition = fakezhmcclient.getFakePartition()
|
|
return inst
|
|
|
|
|
|
class VmFunctionTestCase(TestCase):
|
|
def setUp(self):
|
|
super(VmFunctionTestCase, self).setUp()
|
|
self.valid_name = (
|
|
'OpenStack-foo-6511ee0f-0d64-4392-b9e0-cdbea10a17c3')
|
|
self.invalid_name = 'OpenStack-Instance-6511ee0f'
|
|
self.cpc = fakezhmcclient.getFakeCPC()
|
|
|
|
@mock.patch.object(vm.CONF, 'host', 'foo')
|
|
def test_is_valid_partition_name(self):
|
|
self.assertTrue(vm.is_valid_partition_name(self.valid_name))
|
|
self.assertFalse(vm.is_valid_partition_name(self.invalid_name))
|
|
|
|
@mock.patch.object(vm.CONF, 'host', 'foo')
|
|
def test_partition_list(self):
|
|
partition_list = vm.cpcsubset_partition_list(self.cpc)
|
|
list = self.cpc.partitions.list()
|
|
length = len(list)
|
|
for i in range(length):
|
|
self.assertEqual(list[i].get_property('name'),
|
|
partition_list[i].get_property('name'))
|
|
|
|
|
|
class InstancePropertiesTestCase(TestCase):
|
|
def setUp(self):
|
|
super(InstancePropertiesTestCase, self).setUp()
|
|
self.mock_nova_inst = mock.Mock()
|
|
self.mock_nova_inst.uuid = 'foo-id'
|
|
vm.CONF.set_override("host", "foo")
|
|
|
|
@mock.patch.object(vm.PartitionInstance, 'get_partition')
|
|
def test_partition_name(self, mock_get_part):
|
|
inst = vm.PartitionInstance(
|
|
self.mock_nova_inst, mock.Mock())
|
|
self.assertEqual("OpenStack-foo-foo-id", inst.partition_name)
|
|
|
|
@mock.patch.object(vm.PartitionInstance, 'get_partition')
|
|
def test_partition_description(self, mock_get_part):
|
|
inst = vm.PartitionInstance(
|
|
self.mock_nova_inst, mock.Mock())
|
|
self.assertEqual("OpenStack CPCSubset=foo",
|
|
inst.partition_description)
|
|
|
|
@mock.patch.object(vm.PartitionInstance, 'get_partition')
|
|
def test_properties(self, mock_get_part):
|
|
mock_flavor = mock.Mock()
|
|
mock_flavor.vcpus = 5
|
|
mock_flavor.memory_mb = 2000
|
|
|
|
inst = vm.PartitionInstance(
|
|
self.mock_nova_inst, mock.Mock(), flavor=mock_flavor)
|
|
props = inst.properties()
|
|
self.assertEqual('OpenStack-foo-foo-id', props['name'])
|
|
self.assertEqual('OpenStack CPCSubset=foo', props['description'])
|
|
self.assertEqual(5, props['ifl-processors'])
|
|
self.assertEqual(2000, props['initial-memory'])
|
|
self.assertEqual(2000, props['maximum-memory'])
|
|
|
|
|
|
class VmNicTestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
super(VmNicTestCase, self).setUp()
|
|
vm.zhmcclient = fakezhmcclient
|
|
self.conf = fakeutils.getFakeCPCconf()
|
|
|
|
self.inst = getMockInstance()
|
|
self.inst.partition.nics = fakezhmcclient.getFakeNicManager()
|
|
|
|
@mock.patch.object(vm.LOG, 'debug')
|
|
def test_attach_nic(self, mock_debug):
|
|
|
|
vif1 = {'id': 1234, 'type': 'dpm_vswitch',
|
|
'address': '12-34-56-78-9A-BC',
|
|
'details':
|
|
{'object_id': '00000000-aaaa-bbbb-cccc-abcdabcdabcd'}}
|
|
|
|
ret_val = mock.MagicMock()
|
|
# Required to satisfy dict[..] operations on mocks
|
|
ret_val .__getitem__.side_effect = dict.__getitem__
|
|
with mock.patch.object(fakezhmcclient.NicManager, 'create',
|
|
return_value=ret_val) as mock_create:
|
|
nic_interface = self.inst.attach_nic(self.conf, vif1)
|
|
self.assertEqual(ret_val, nic_interface)
|
|
self.assertTrue(mock_create.called)
|
|
call_arg_dict = mock_create.mock_calls[0][1][0]
|
|
# Name
|
|
self.assertTrue(call_arg_dict['name'].startswith('OpenStack'))
|
|
self.assertIn(str(1234), call_arg_dict['name'])
|
|
# Description
|
|
self.assertTrue(call_arg_dict['description'].startswith('OpenStack'))
|
|
self.assertIn('mac=12-34-56-78-9A-BC', call_arg_dict['description'])
|
|
self.assertIn('CPCSubset=' + self.conf['cpcsubset_name'],
|
|
call_arg_dict['description'])
|
|
# virtual-switch-uri
|
|
self.assertEqual(
|
|
'/api/virtual-switches/00000000-aaaa-bbbb-cccc-abcdabcdabcd',
|
|
call_arg_dict['virtual-switch-uri'])
|
|
|
|
|
|
class VmHBATestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
super(VmHBATestCase, self).setUp()
|
|
vm.zhmcclient = fakezhmcclient
|
|
self.conf = fakeutils.getFakeCPCconf()
|
|
|
|
self.inst = getMockInstance()
|
|
|
|
self.conf['physical_storage_adapter_mappings'] = \
|
|
["aaaaaaaa-bbbb-cccc-1123-567890abcdef:1"]
|
|
self.inst.partition.hbas = fakezhmcclient.getFakeHbaManager()
|
|
|
|
@mock.patch.object(vm.LOG, 'debug')
|
|
@mock.patch.object(compute_manager.ComputeManager, '_prep_block_device',
|
|
return_value="blockdeviceinfo")
|
|
def test_build_resources(self, mock_prep_block_dev, mock_debug):
|
|
context = None
|
|
novainstance = fakeutils.getFakeInstance()
|
|
block_device_mapping = None
|
|
resources = self.inst._build_resources(
|
|
context, novainstance, block_device_mapping)
|
|
self.assertEqual(resources['block_device_info'],
|
|
"blockdeviceinfo")
|
|
|
|
@mock.patch.object(vm.LOG, 'debug')
|
|
def test_attach_hba(self, mock_debug):
|
|
self.inst.attachHba(self.conf)
|