def _bld_mocks_for_instance_disk(self):
inst = mock.Mock()
inst.name = 'my-instance-name'
lpar_wrap = mock.Mock()
lpar_wrap.id = 4
# Build mock VIOS Wrappers as the returns from VIOS.wrap.
# vios1 and vios2 will both have the mapping for client ID 4 and LU
# named boot_my_instance_name.
vios1 = pvm_vios.VIOS.wrap(
pvmhttp.load_pvm_resp('fake_vios_ssp_npiv.txt',
adapter=self.apt).get_response())
vios1.scsi_mappings[3].backing_storage._name('boot_my_instance_name')
resp1 = self._bld_resp(entry_or_list=vios1.entry)
vios2 = copy.deepcopy(vios1)
# Change name and UUID so we can tell the difference:
vios2.name = 'vios2'
vios2.entry.properties['id'] = '7C6475B3-73A5-B9FF-4799-B23B20292951'
resp2 = self._bld_resp(entry_or_list=vios2.entry)
# vios3 will not have the mapping
vios3 = pvm_vios.VIOS.wrap(
pvmhttp.load_pvm_resp('fake_vios_ssp_npiv.txt',
adapter=self.apt).get_response())
vios3.name = 'vios3'
vios3.entry.properties['id'] = 'B9FF4799-B23B-2029-2951-7C6475B373A5'
resp3 = self._bld_resp(entry_or_list=vios3.entry)
return inst, lpar_wrap, resp1, resp2, resp3
def setUp(self):
super(TestMSEntryWrapper, self).setUp()
self.ms_http = pvmhttp.load_pvm_resp(_MS_HTTPRESP_FILE)
self.assertNotEqual(self.ms_http, None,
"Could not load %s " % _MS_HTTPRESP_FILE)
entries = self.ms_http.response.feed.findentries(
ms._SYSTEM_NAME, _MS_NAME)
self.assertNotEqual(
entries, None,
"Could not find %s in %s" % (_MS_NAME, _MS_HTTPRESP_FILE))
self.myentry = entries[0]
self.wrapper = ms.System.wrap(self.myentry)
# Set a hardcoded value for MemoryUsedByHypervisor
fw_mem = self.myentry.element.find(
'AssociatedSystemMemoryConfiguration/MemoryUsedByHypervisor')
fw_mem.text = '1536'
mc_http = pvmhttp.load_pvm_resp(_MC_HTTPRESP_FILE)
self.assertNotEqual(mc_http, None,
"Could not load %s" % _MC_HTTPRESP_FILE)
self.test_ioslot_unassigned = self.wrapper.asio_config.io_slots[0]
self.test_ioslot_assigned = self.wrapper.asio_config.io_slots[1]
""" Create a bad wrapper to use when
retrieving properties which don't exist """
self.bad_wrapper = ms.System.wrap(mc_http.response.feed.entries[0])
def setUp(self):
super(TestPowerVMDriver, self).setUp()
ms_http = pvmhttp.load_pvm_resp(MS_HTTPRESP_FILE)
self.assertIsNotNone(ms_http, "Could not load %s " % MS_HTTPRESP_FILE)
entries = ms_http.response.feed.findentries(pvm_ms._SYSTEM_NAME,
MS_NAME)
self.assertNotEqual(entries, None,
"Could not find %s in %s" %
(MS_NAME, MS_HTTPRESP_FILE))
self.wrapper = pvm_ms.System.wrap(entries[0])
self.flags(disk_driver='localdisk', group='powervm')
self.drv_fix = self.useFixture(fx.PowerVMComputeDriver())
self.drv = self.drv_fix.drv
self.apt = self.drv.adapter
self._setup_lpm()
self.disk_dvr = self.drv.disk_dvr
self.vol_fix = self.useFixture(fx.VolumeAdapter())
self.vol_drv = self.vol_fix.drv
self.crt_lpar_p = mock.patch('nova_powervm.virt.powervm.vm.crt_lpar')
self.crt_lpar = self.crt_lpar_p.start()
self.addCleanup(self.crt_lpar_p.stop)
self.get_inst_wrap_p = mock.patch('nova_powervm.virt.powervm.vm.'
'get_instance_wrapper')
self.get_inst_wrap = self.get_inst_wrap_p.start()
self.addCleanup(self.get_inst_wrap_p.stop)
wrap = pvm_lpar.LPAR.wrap(pvmhttp.load_pvm_resp(
LPAR_HTTPRESP_FILE).response)[0]
self.crt_lpar.return_value = wrap
self.get_inst_wrap.return_value = wrap
self.build_tx_feed_p = mock.patch('nova_powervm.virt.powervm.vios.'
'build_tx_feed_task')
self.build_tx_feed = self.build_tx_feed_p.start()
self.addCleanup(self.build_tx_feed_p.stop)
self.useFixture(pvm_fx.FeedTaskFx([pvm_vios.VIOS.wrap(
pvmhttp.load_pvm_resp(VIOS_HTTPRESP_FILE).response)]))
self.stg_ftsk = pvm_tx.FeedTask('fake', pvm_vios.VIOS.getter(self.apt))
self.build_tx_feed.return_value = self.stg_ftsk
scrub_stg_p = mock.patch('pypowervm.tasks.storage.'
'add_lpar_storage_scrub_tasks')
self.scrub_stg = scrub_stg_p.start()
self.addCleanup(scrub_stg_p.stop)
def setUp(self):
super(TestLogicalPartition, self).setUp()
self.adptfx = self.useFixture(fx.AdapterFx(traits=fx.LocalPVMTraits))
self.adpt = self.adptfx.adpt
self.TC = TestLogicalPartition
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE,
adapter=self.adpt)
self.assertIsNotNone(lpar_http,
"Could not load %s " %
LPAR_HTTPRESP_FILE)
entries = lpar_http.response.feed.findentries(
bp._BP_NAME, SHARED_LPAR_NAME)
self.assertIsNotNone(entries,
"Could not find %s in %s" %
(SHARED_LPAR_NAME, LPAR_HTTPRESP_FILE))
self.TC._shared_entry = entries[0]
entries = lpar_http.response.feed.findentries(
bp._BP_NAME, DEDICATED_LPAR_NAME)
self.assertIsNotNone(entries,
"Could not find %s in %s" %
(DEDICATED_LPAR_NAME, LPAR_HTTPRESP_FILE))
self.TC._dedicated_entry = entries[0]
TestLogicalPartition._shared_wrapper = lpar.LPAR.wrap(
self.TC._shared_entry)
TestLogicalPartition._dedicated_wrapper = lpar.LPAR.wrap(
self.TC._dedicated_entry)
mc_http = pvmhttp.load_pvm_resp(MC_HTTPRESP_FILE, adapter=self.adpt)
self.assertIsNotNone(mc_http,
"Could not load %s" %
MC_HTTPRESP_FILE)
# Create a bad wrapper to use when retrieving properties which don't
# exist
TestLogicalPartition._bad_wrapper = lpar.LPAR.wrap(
mc_http.response.feed.entries[0])
TestLogicalPartition._skip_setup = True
def _init_host(self, *args):
ms_http = pvmhttp.load_pvm_resp(
MS_HTTPRESP_FILE, adapter=mock.Mock()).get_response()
# Pretend it just returned one host
ms_http.feed.entries = [ms_http.feed.entries[0]]
self.drv.adapter.read.return_value = ms_http
self.drv.init_host('FakeHost')
def test_find_or_create_vnet(self):
"""Tests that the virtual network can be found/created."""
vn = pvmhttp.load_pvm_resp(VNET_FILE).get_response()
self.adpt.read.return_value = vn
fake_vs = mock.Mock()
fake_vs.switch_id = 0
fake_vs.name = 'ETHERNET0'
host_uuid = '67dca605-3923-34da-bd8f-26a378fc817f'
fake_vs.related_href = ('https://9.1.2.3:12443/rest/api/uom/'
'ManagedSystem/'
'67dca605-3923-34da-bd8f-26a378fc817f/'
'VirtualSwitch/'
'ec8aaa54-9837-3c23-a541-a4e4be3ae489')
# This should find a vnet.
vnet_resp = cna._find_or_create_vnet(self.adpt, host_uuid, '2227',
fake_vs)
self.assertIsNotNone(vnet_resp)
# Now flip to a CNA that requires a create...
resp = adp.Response('reqmethod', 'reqpath', 'status', 'reason', {})
resp.entry = ewrap.EntryWrapper._bld(
self.adpt, tag='VirtualNetwork').entry
self.adpt.create.return_value = resp
vnet_resp = cna._find_or_create_vnet(self.adpt, host_uuid, '2228',
fake_vs)
self.assertIsNotNone(vnet_resp)
self.assertEqual(1, self.adpt.create.call_count)
def _init_host(self, *args):
ms_http = pvmhttp.load_pvm_resp(MS_HTTPRESP_FILE,
adapter=mock.Mock()).get_response()
# Pretend it just returned one host
ms_http.feed.entries = [ms_http.feed.entries[0]]
self.drv.adapter.read.return_value = ms_http
self.drv.init_host('FakeHost')
def setUp(self):
super(TestHttpError, self).setUp()
self.http_error = pvmhttp.load_pvm_resp(HTTPRESP_FILE)
self.assertIsNotNone(self.http_error,
"Could not load %s " %
HTTPRESP_FILE)
def setUp(self):
super(TestHttpError, self).setUp()
self.http_error = pvmhttp.load_pvm_resp(HTTPRESP_FILE)
self.assertIsNotNone(self.http_error,
"Could not load %s " %
HTTPRESP_FILE)
def setUp(self):
super(TestMgmt, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " % LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def setUp(self):
super(TestMgmt, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " % LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def setUp(self):
super(TestVM, self).setUp()
self.apt = self.useFixture(
pvm_fx.AdapterFx(traits=pvm_fx.LocalPVMTraits)).adpt
self.apt.helpers = [pvm_log.log_helper]
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " % LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def refresh_response(file_to_refresh):
"""Reload the file and redo the query."""
print("Loading original file: ", file_to_refresh)
new_http = pvmhttp.load_pvm_resp(file_to_refresh)
if new_http is None or new_http.refresh() is False:
print("Unable to refresh ", file_to_refresh)
return 1
print("Saving refreshed file: ", file_to_refresh)
new_http.save(file_to_refresh)
return 0
def refresh_response(file_to_refresh):
"""Reload the file and redo the query."""
print("Loading original file: ", file_to_refresh)
new_http = pvmhttp.load_pvm_resp(file_to_refresh)
if new_http is None or new_http.refresh() is False:
print("Unable to refresh ", file_to_refresh)
return 1
print("Saving refreshed file: ", file_to_refresh)
new_http.save(file_to_refresh)
return 0
def setUp(self):
super(TestVM, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx(
traits=pvm_fx.LocalPVMTraits)).adpt
self.apt.helpers = [pvm_log.log_helper]
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " %
LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def _bld_mocks_for_instance_disk(self):
inst = mock.Mock()
inst.name = 'my-instance-name'
lpar_wrap = mock.Mock()
lpar_wrap.id = 4
# Build mock VIOS Wrappers as the returns from VIOS.wrap.
# vios1 and vios2 will both have the mapping for client ID 4 and LU
# named boot_my_instance_name.
vios1 = pvm_vios.VIOS.wrap(pvmhttp.load_pvm_resp(
'fake_vios_ssp_npiv.txt', adapter=self.apt).get_response())
vios1.scsi_mappings[3].backing_storage._name('boot_my_instance_name')
resp1 = self._bld_resp(entry_or_list=vios1.entry)
vios2 = copy.deepcopy(vios1)
# Change name and UUID so we can tell the difference:
vios2.name = 'vios2'
vios2.entry.properties['id'] = '7C6475B3-73A5-B9FF-4799-B23B20292951'
resp2 = self._bld_resp(entry_or_list=vios2.entry)
# vios3 will not have the mapping
vios3 = pvm_vios.VIOS.wrap(pvmhttp.load_pvm_resp(
'fake_vios_ssp_npiv.txt', adapter=self.apt).get_response())
vios3.name = 'vios3'
vios3.entry.properties['id'] = 'B9FF4799-B23B-2029-2951-7C6475B373A5'
resp3 = self._bld_resp(entry_or_list=vios3.entry)
return inst, lpar_wrap, resp1, resp2, resp3
def setUp(self):
super(TestPowerVMHost, self).setUp()
ms_http = pvmhttp.load_pvm_resp(MS_HTTPRESP_FILE)
self.assertNotEqual(ms_http, None,
"Could not load %s " % MS_HTTPRESP_FILE)
entries = ms_http.response.feed.findentries(pvm_ms._SYSTEM_NAME,
MS_NAME)
self.assertNotEqual(
entries, None,
"Could not find %s in %s" % (MS_NAME, MS_HTTPRESP_FILE))
self.ms_entry = entries[0]
self.wrapper = pvm_ms.System.wrap(self.ms_entry)
def setUp(self):
super(TestVM, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx(
traits=pvm_fx.LocalPVMTraits)).adpt
self.apt.helpers = [pvm_log.log_helper]
self.san_lpar_name = self.useFixture(fixtures.MockPatch(
'pypowervm.util.sanitize_partition_name_for_api')).mock
self.san_lpar_name.side_effect = lambda name: name
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " %
LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def setUp(self):
super(TestVM, self).setUp()
self.apt = self.useFixture(
pvm_fx.AdapterFx(traits=pvm_fx.LocalPVMTraits)).adpt
self.apt.helpers = [pvm_log.log_helper]
self.san_lpar_name = self.useFixture(
fixtures.MockPatch(
'pypowervm.util.sanitize_partition_name_for_api')).mock
self.san_lpar_name.side_effect = lambda name: name
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " % LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def _init_host(self, *args):
ms_http = pvmhttp.load_pvm_resp(
MS_HTTPRESP_FILE, adapter=mock.Mock()).get_response()
# Pretend it just returned one host
ms_http.feed.entries = [ms_http.feed.entries[0]]
# Mock active vios
self.get_active_vios = self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.partition.get_active_vioses')).mock
self.get_active_vios.return_value = ['mock_vios']
self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.partition.validate_vios_ready'))
self.drv.adapter.read.return_value = ms_http
self.drv.session = self.drv.adapter.session
self.drv.init_host('FakeHost')
def setUp(self):
super(TestPowerVMHost, self).setUp()
ms_http = pvmhttp.load_pvm_resp(MS_HTTPRESP_FILE)
self.assertNotEqual(ms_http, None,
"Could not load %s " %
MS_HTTPRESP_FILE)
entries = ms_http.response.feed.findentries(pvm_ms._SYSTEM_NAME,
MS_NAME)
self.assertNotEqual(entries, None,
"Could not find %s in %s" %
(MS_NAME, MS_HTTPRESP_FILE))
self.ms_entry = entries[0]
self.wrapper = pvm_ms.System.wrap(self.ms_entry)
def load_file(file_name, adapter=None):
"""Helper method to load the responses from a given location."""
return pvmhttp.load_pvm_resp(file_name, adapter).get_response()
def setUp(self):
super(TestVIOSBusyHelper, self).setUp()
self.http_error = pvmhttp.load_pvm_resp(HTTPRESP_FILE)
self.http_error_sa = pvmhttp.load_pvm_resp(HTTPRESP_SA_FILE)
def load(fname):
resp = pvmhttp.load_pvm_resp(fname, adapter=self.adpt).response
self.assertIsNotNone(resp, "Could not load %s " % fname)
return jwrap.Job.wrap(resp)
import unittest
import mock
import requests.models as req_mod
import requests.structures as req_struct
import pypowervm.adapter as adp
import pypowervm.tests.lib as testlib
from pypowervm.tests.test_utils import pvmhttp
from pypowervm import traits
import pypowervm.wrappers.entry_wrapper as ewrap
import pypowervm.wrappers.network as net
import pypowervm.wrappers.storage as stor
_logon_response_text = testlib.file2b("logon_file.xml")
_feed_file = pvmhttp.load_pvm_resp(
"fake_network_bridge.txt").response.body.encode('utf-8')
_entry_file = pvmhttp.load_pvm_resp(
"fake_volume_group.txt").response.body.encode('utf-8')
class TestTraits(unittest.TestCase):
@mock.patch('pypowervm.adapter.Session')
def test_traits(self, mock_sess):
# PVM MC, local auth
mock_sess.mc_type = 'PVM'
mock_sess.use_file_auth = True
t = traits.APITraits(mock_sess)
self.assertFalse(t.vnet_aware)
self.assertFalse(t._is_hmc)
self.assertTrue(t.local_api)
import unittest
import mock
import requests.models as req_mod
import requests.structures as req_struct
import pypowervm.adapter as adp
import pypowervm.tests.lib as testlib
from pypowervm.tests.test_utils import pvmhttp
from pypowervm import traits
import pypowervm.wrappers.entry_wrapper as ewrap
import pypowervm.wrappers.network as net
import pypowervm.wrappers.storage as stor
_logon_response_text = testlib.file2b("logon_file.xml")
_feed_file = pvmhttp.load_pvm_resp(
"fake_network_bridge.txt").response.body.encode('utf-8')
_entry_file = pvmhttp.load_pvm_resp(
"fake_volume_group.txt").response.body.encode('utf-8')
class TestTraits(unittest.TestCase):
@mock.patch('pypowervm.adapter.Session')
def test_traits(self, mock_sess):
# PVM MC, local auth
mock_sess.mc_type = 'PVM'
mock_sess.use_file_auth = True
t = traits.APITraits(mock_sess)
self.assertFalse(t.vnet_aware)
self.assertFalse(t._is_hmc)
self.assertTrue(t.local_api)
self.assertFalse(t.has_lpar_profiles)
def resp(file_name):
return pvmhttp.load_pvm_resp(file_name).get_response()
def setUp(self):
super(TestElementWrapper, self).setUp()
self.resp = pvmhttp.load_pvm_resp(NET_BRIDGE_FILE).get_response()
self.nb1 = self.resp.feed.entries[0]
self.resp2 = pvmhttp.load_pvm_resp(NET_BRIDGE_FILE).get_response()
self.nb2 = self.resp2.feed.entries[0]
def setUp(self):
super(TestVIOSBusyHelper, self).setUp()
self.http_error = pvmhttp.load_pvm_resp(HTTPRESP_FILE)
self.http_error_sa = pvmhttp.load_pvm_resp(HTTPRESP_SA_FILE)
def setUp(self):
super(TestElementWrapper, self).setUp()
self.resp = pvmhttp.load_pvm_resp(NET_BRIDGE_FILE).get_response()
self.nb1 = self.resp.feed.entries[0]
self.resp2 = pvmhttp.load_pvm_resp(NET_BRIDGE_FILE).get_response()
self.nb2 = self.resp2.feed.entries[0]
def resp(file_name):
return pvmhttp.load_pvm_resp(file_name,
adapter=self.adpt).get_response()
def load(fname):
resp = pvmhttp.load_pvm_resp(fname, adapter=self.adpt).response
self.assertIsNotNone(resp, "Could not load %s " % fname)
return jwrap.Job.wrap(resp)
def resp(file_name):
return pvmhttp.load_pvm_resp(
file_name, adapter=self.adpt).get_response()
def resp(file_name):
return pvmhttp.load_pvm_resp(file_name).get_response()
