def test_vios_busy_helper(self, mock_sleep, mock_sess):
# Try with 1 retries
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=1)
error = pvmex.Error('yo', response=self.http_error.response)
mock_sess.request.side_effect = error
adpt = adp.Adapter(mock_sess, use_cache=False, helpers=hlp)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
# Test that the request method was called twice and sleep was called
self.assertEqual(mock_sess.request.call_count, 2)
mock_sleep.assert_called_once_with(5 * 1)
# Test with more retries and sleep values
retries = 10
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=retries,
delay=15)
mock_sess.reset_mock()
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body',
helpers=hlp)
# Should have tried 'retries' times plus the initial one
self.assertEqual(mock_sess.request.call_count, retries + 1)
# Test with None response
mock_sess.reset_mock()
error = pvmex.Error('yo', response=None)
mock_sess.request.side_effect = error
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=1,
delay=15)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body',
helpers=hlp)
# There should be no retries since the response was None
self.assertEqual(mock_sess.request.call_count, 1)
# Test with a Service Unavailable exception
mock_sess.reset_mock()
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=1)
error = pvmex.Error('yo', response=self.http_error_sa.response)
mock_sess.request.side_effect = error
adpt = adp.Adapter(mock_sess, use_cache=False, helpers=hlp)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
self.assertEqual(mock_sess.request.call_count, 2)
def test_invalid_helper(self, mock_sess):
hlp = "bad helper, shame on you"
mock_sess.request.return_value = 'Should not get returned'
adpt = adp.Adapter(mock_sess, helpers=hlp)
with self.assertRaises(TypeError):
adpt._request('method', 'path')
adpt = adp.Adapter(mock_sess)
with self.assertRaises(TypeError):
adpt._request('method', 'path', helpers=[hlp])
def init_host(self, host):
"""Initialize anything that is necessary for the driver to function.
Includes catching up with currently running VMs on the given host.
"""
# Build the adapter. May need to attempt the connection multiple times
# in case the PowerVM management API service is starting.
# TODO(efried): Implement async compute service enable/disable like
# I73a34eb6e0ca32d03e54d12a5e066b2ed4f19a61
self.adapter = pvm_apt.Adapter(
pvm_apt.Session(conn_tries=60),
helpers=[log_hlp.log_helper, vio_hlp.vios_busy_retry_helper])
# Make sure the Virtual I/O Server(s) are available.
pvm_par.validate_vios_ready(self.adapter)
self.host_wrapper = pvm_ms.System.get(self.adapter)[0]
# Do a scrub of the I/O plane to make sure the system is in good shape
LOG.info("Clearing stale I/O connections on driver init.")
pvm_stor.ComprehensiveScrub(self.adapter).execute()
# Initialize the disk adapter
# TODO(efried): Other disk adapters (localdisk), by conf selection.
self.disk_dvr = ssp.SSPDiskAdapter(self.adapter,
self.host_wrapper.uuid)
self.image_api = image.API()
LOG.info("The PowerVM compute driver has been initialized.")
def test_multi_list(self):
hlp1 = functools.partial(cat_string_helper, string="1")
hlp2 = functools.partial(cat_string_helper, string="2")
adpt = adp.Adapter('mock_session',
use_cache=False,
helpers=[hlp1, hlp2])
self.assertEqual([hlp1, hlp2], adpt.helpers)
def test_create(self, mock_session):
"""Test create() method found in the Adapter class."""
# Init test data
adapter = adp.Adapter(self.sess, use_cache=False)
new_scsi = pvm_stor.VSCSIClientAdapterElement.bld(adapter)
element = new_scsi
root_type = 'ManagedSystem'
root_id = 'id'
child_type = 'LogicalPartition'
create_response = self._mk_response(200, response_text)
# Mock out the method and class we are not currently testing
session = mock_session.return_value
session.request.return_value = create_response
# Run the actual test
ret_create_value = adapter.create(element, root_type, root_id,
child_type)
# Verify Correct path was built in build_path()
reqpath = adp.Adapter.build_path('uom',
root_type,
root_id,
child_type,
xag=[])
# Verify the return value
# self.assertIsInstance(ret_create_value, adp.Response)
self.assertEqual('PUT', ret_create_value.reqmethod)
self.assertEqual(200, ret_create_value.status)
self.assertEqual(reqpath, ret_create_value.reqpath)
def test_read(self, mock_session):
"""Test read() method found in the Adapter class."""
# Init test data
root_type = 'ManagedSystem'
root_id = 'caae9209-25e5-35cd-a71a-ed55c03f294d'
child_type = 'child'
child_id = 'child'
suffix_type = 'quick'
adapter = adp.Adapter(self.sess, use_cache=False)
# Create a Response object, that will serve as a mock return value
read_response = self._mk_response(200, response_text)
# Mock out the method and class we are not currently testing
session = mock_session.return_value
session.request.return_value = read_response
# Run the actual test
ret_read_value = adapter.read(root_type, root_id, child_type, child_id,
suffix_type)
# Verify Correct path was built in build_path()
reqpath = adp.Adapter.build_path('uom', root_type, root_id, child_type,
child_id, suffix_type)
# Verify the return value
# self.assertIsInstance(ret_read_value, adp.Response)
self.assertEqual('GET', ret_read_value.reqmethod)
self.assertEqual(200, ret_read_value.status)
self.assertEqual(reqpath, ret_read_value.reqpath)
def init_host(self, host):
"""Initialize anything that is necessary for the driver to function.
Includes catching up with currently running VMs on the given host.
"""
LOG.warning(
'The powervm virt driver is deprecated and may be removed in a '
'future release. The driver is not tested by the OpenStack '
'project nor does it have clear maintainers and thus its quality'
'can not be ensured. If you are using the driver in production '
'please let us know the openstack-discuss mailing list or on IRC'
)
# Build the adapter. May need to attempt the connection multiple times
# in case the PowerVM management API service is starting.
# TODO(efried): Implement async compute service enable/disable like
# I73a34eb6e0ca32d03e54d12a5e066b2ed4f19a61
self.adapter = pvm_apt.Adapter(
pvm_apt.Session(conn_tries=60),
helpers=[log_hlp.log_helper, vio_hlp.vios_busy_retry_helper])
# Make sure the Virtual I/O Server(s) are available.
pvm_par.validate_vios_ready(self.adapter)
self.host_wrapper = pvm_ms.System.get(self.adapter)[0]
# Do a scrub of the I/O plane to make sure the system is in good shape
LOG.info("Clearing stale I/O connections on driver init.")
pvm_stor.ComprehensiveScrub(self.adapter).execute()
# Initialize the disk adapter
self.disk_dvr = importutils.import_object_ns(
DISK_ADPT_NS, DISK_ADPT_MAPPINGS[CONF.powervm.disk_driver.lower()],
self.adapter, self.host_wrapper.uuid)
self.image_api = glance.API()
LOG.info("The PowerVM compute driver has been initialized.")
def test_read_by_href(self, mock_read_by_path, mock_log):
"""Ensure read_by_href correctly extends, preserves query strings."""
def validate_read_by_path(expected):
def _read_by_path(path, etag, timeout, auditmemento, age,
sensitive, helpers):
self._assert_paths_equivalent(expected, path)
for param in (etag, auditmemento, helpers):
self.assertIsNone(param)
for param2 in (age, timeout):
self.assertEqual(-1, param2)
self.assertFalse(sensitive)
return _read_by_path
self.sess.host = 'foo'
self.sess.port = 123
adapter = adp.Adapter(self.sess)
mock_read_by_path.side_effect = validate_read_by_path(
'/rest/api/uom/Bar?k=v&group=None#frag')
adapter.read_by_href('http://foo:123/rest/api/uom/Bar?k=v#frag')
self.assertFalse(mock_log.debug.called)
self.sess.host = 'bar'
mock_read_by_path.side_effect = validate_read_by_path(
'/rest/api/uom/Bar?k=v&group=None#frag')
adapter.read_by_href('http://foo:123/rest/api/uom/Bar?k=v#frag')
self.assertTrue(mock_log.debug.called)
mock_read_by_path.side_effect = validate_read_by_path(
'/rest/api/uom/Bar?k=v&group=RealGroup#frag')
adapter.read_by_href(
'http://foo:123/rest/api/uom/Bar?k=v&group=RealGroup#frag')
def test_upload(self, mock_session):
# Build the adapter
adapter = adp.Adapter(self.sess, use_cache=False)
# Mock data
filedesc_mock = mock.MagicMock()
filedesc_mock.findtext.side_effect = ['uuid', 'mime']
mock_request = mock.MagicMock()
adapter._request = mock_request
# Invoke
adapter.upload_file(filedesc_mock, None)
# Validate
expected_headers = {
'Accept': 'application/vnd.ibm.powervm.web+xml',
'Content-Type': 'mime'
}
expected_path = '/rest/api/web/File/contents/uuid'
mock_request.assert_called_with('PUT',
expected_path,
helpers=None,
headers=expected_headers,
timeout=-1,
auditmemento=None,
filehandle=None,
chunksize=65536)
def test_single_list(self):
hlp = functools.partial(cat_string_helper, string="purple!")
hlp_list = [hlp]
adpt = adp.Adapter('mock_session', helpers=hlp_list)
self.assertEqual(hlp_list, adpt.helpers)
# Use this test to ensure the list returned is a copy
self.assertNotEqual(id(hlp_list), id(adpt.helpers))
def test_update(self, mock_session):
"""Test update() method found in the Adapter class."""
# Init test data
data = 'data'
etag = 'etag'
root_type = 'root type'
root_id = 'root id'
adapter = adp.Adapter(self.sess, use_cache=False)
update_response = self._mk_response(200, response_text)
# Mock out the method and class we are not currently testing
session = mock_session.return_value
session.request.return_value = update_response
# Run the actual test
ret_update_value = adapter.update(data, etag, root_type, root_id)
# Verify Correct path was built in build_path()
reqpath = adp.Adapter.build_path('uom', root_type, root_id)
# Verify the return value
# self.assertIsInstance(ret_update_value, adp.Response)
self.assertEqual('POST', ret_update_value.reqmethod)
self.assertEqual(200, ret_update_value.status)
self.assertEqual(reqpath, ret_update_value.reqpath)
def test_sample_helper(self, mock_sleep):
helpers = smpl_hlp.sample_retry_helper
fake_resp1 = adp.Response('GET',
'/some/path',
200,
'OK', ['headers'],
body='Some Text HSCL3205 More Text')
self.sess.request.side_effect = pvmex.Error('yo', response=fake_resp1)
adpt = adp.Adapter(self.sess, helpers=helpers)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
# Test that the request method was called twice and sleep was called
self.assertEqual(self.sess.request.call_count, 2)
mock_sleep.assert_called_once_with(5 * 1)
hlp = functools.partial(smpl_hlp.sample_retry_helper, max_retries=5)
self.sess.reset_mock()
try:
adpt._request('method', 'path', body='the body', helpers=hlp)
except Exception:
# Should have tried 6 times total
self.assertEqual(self.sess.request.call_count, 6)
def test_crt_related_href(self, mock_sess):
"""Tests to make sure that related elements are well formed."""
mock_sess.dest = 'root'
adapter = adpt.Adapter(mock_sess)
href = vios.VStorageMapping.crt_related_href(adapter, 'host', 'lpar')
self.assertEqual(
'root/rest/api/uom/ManagedSystem/host/'
'LogicalPartition/lpar', href)
def test_headers(self, mock_request):
def validate_hdrs_func(acc=None, inm=None):
expected_headers = {}
if acc is not None:
expected_headers['Accept'] = acc
if inm is not None:
expected_headers['If-None-Match'] = inm
def validate_request(meth, path, **kwargs):
self.assertEqual(expected_headers, kwargs['headers'])
return validate_request
adpt = adp.Adapter(mock.Mock())
basepath = c.API_BASE_PATH + 'uom/SomeRootObject'
uuid = "abcdef01-2345-2345-2345-67890abcdef0"
hdr_xml = 'application/atom+xml'
hdr_json = 'application/json'
etag = 'abc123'
# Root feed
mock_request.side_effect = validate_hdrs_func(acc=hdr_xml)
adpt._read_by_path(basepath, None, None, None, None)
# Root instance with etag
mock_request.side_effect = validate_hdrs_func(acc=hdr_xml, inm=etag)
adpt._read_by_path(basepath + '/' + uuid, etag, None, None, None)
# Quick root anchor (produces XML report of available quick properties
mock_request.side_effect = validate_hdrs_func(acc=hdr_xml)
adpt._read_by_path(basepath + '/quick', None, None, None, None)
# Quick root instance (JSON of all quick properties)
mock_request.side_effect = validate_hdrs_func(acc=hdr_json)
adpt._read_by_path('/'.join([basepath, uuid, 'quick']), None, None,
None, None)
# Specific quick property
mock_request.side_effect = validate_hdrs_func(acc=hdr_json)
adpt._read_by_path('/'.join([basepath, uuid, 'quick', 'property']),
None, None, None, None)
# Explicit JSON file
mock_request.side_effect = validate_hdrs_func(acc=hdr_json)
adpt._read_by_path('/'.join([basepath, 'somefile.json']), None, None,
None, None)
# Object that happens to end in 'json'
mock_request.side_effect = validate_hdrs_func(acc=hdr_xml)
adpt._read_by_path('/'.join([basepath, 'xml_about_json']), None, None,
None, None)
# Quick with query params and fragments
mock_request.side_effect = validate_hdrs_func(acc=hdr_json)
adpt._read_by_path(
'/'.join([basepath, uuid, 'quick']) + '?group=None#frag', None,
None, None, None)
def test_runs(self, mock_sess):
hlp1 = functools.partial(cat_string_helper, string="1")
hlp2 = functools.partial(cat_string_helper, string="2")
hlp3 = functools.partial(cat_string_helper, string="3")
mock_sess.request.return_value = 'countdown:'
adpt = adp.Adapter(mock_sess, helpers=[hlp1, hlp2, hlp3])
self.assertEqual('countdown:321', adpt._request('method', 'path'))
# Override adapter helpers
self.assertEqual('countdown:2',
adpt._request('method', 'path', helpers=hlp2))
# No adapter helpers, but request helper
adpt = adp.Adapter(mock_sess)
self.assertEqual('countdown:1',
adpt._request('method', 'path', helpers=[hlp1]))
def refresh(self):
"""Do the query and get the response."""
print("Connecting.")
adap = adp.Adapter()
print("Reading path: " + self.path)
self.response = adap.read(self.path)
print("Received " + str(self.response))
def main(argv):
new_response = pvmhttp.PVMResp()
output_file = None
file_to_refresh = None
aindex = 0
while aindex < len(argv):
if argv[aindex] == '-path':
aindex += 1
new_response.path = argv[aindex]
elif argv[aindex] == '-comment':
aindex += 1
new_response.comment = argv[aindex]
elif argv[aindex] == '-output':
aindex += 1
output_file = argv[aindex]
elif argv[aindex] == '-refresh':
aindex += 1
file_to_refresh = argv[aindex]
else:
print("Unknown argument ", argv[aindex])
usage()
aindex += 1
if file_to_refresh:
rc = refresh_response(file_to_refresh)
exit(rc)
if new_response.path is None or output_file is None:
usage()
print("Connecting.")
adap = adp.Adapter()
print("Reading path: ", new_response.path)
new_response.response = adap.read(new_response.path)
print("Received ", new_response.response)
orig_file_name = output_file
dirname = os.path.dirname(output_file)
if dirname is None or dirname == '':
dirname = os.path.dirname(__file__)
output_file = os.path.join(dirname, output_file)
new_response.save(output_file)
print("Response has been saved in ", output_file)
print("Use the pvmhttp.load_pvm_resp('%s') method "
"to load it in your testcase " % orig_file_name)
print("You can have the %s file rebuilt by running: "
"create_httpresp -refresh %s" % (orig_file_name, orig_file_name))
def init_host(self, host):
"""Initialize anything that is necessary for the driver to function.
Includes catching up with currently running VMs on the given host.
"""
# Build the adapter. May need to attempt the connection multiple times
# in case the PowerVM management API service is starting.
# TODO(efried): Implement async compute service enable/disable like
# I73a34eb6e0ca32d03e54d12a5e066b2ed4f19a61
self.adapter = pvm_apt.Adapter(
pvm_apt.Session(conn_tries=60),
helpers=[log_hlp.log_helper, vio_hlp.vios_busy_retry_helper])
# Make sure the Virtual I/O Server(s) are available.
pvm_par.validate_vios_ready(self.adapter)
self.host_wrapper = pvm_ms.System.get(self.adapter)[0]
LOG.info("The PowerVM compute driver has been initialized.")
def __init__(self):
super(PowerVMInspector, self).__init__()
# Build the adapter to the PowerVM API.
self.adpt = pvm_adpt.Adapter(
pvm_adpt.Session(),
helpers=[log_hlp.log_helper, vio_hlp.vios_busy_retry_helper])
# Get the host system UUID
host_uuid = self._get_host_uuid(self.adpt)
# Ensure that metrics gathering is running for the host.
pvm_mon_util.ensure_ltm_monitors(self.adpt, host_uuid)
# Get the VM Metric Utility
self.vm_metrics = pvm_mon_util.LparMetricCache(self.adpt, host_uuid)
def __init__(self, conf):
super(PowerVMInspector, self).__init__(conf)
# Build the adapter. May need to attempt the connection multiple times
# in case the REST server is starting.
session = pvm_adpt.Session(conn_tries=300)
self.adpt = pvm_adpt.Adapter(
session,
helpers=[log_hlp.log_helper, vio_hlp.vios_busy_retry_helper])
# Get the host system UUID
host_uuid = self._get_host_uuid(self.adpt)
# Ensure that metrics gathering is running for the host.
pvm_mon_util.ensure_ltm_monitors(self.adpt, host_uuid)
# Get the VM Metric Utility
self.vm_metrics = pvm_mon_util.LparMetricCache(self.adpt, host_uuid)
def test_unauthorized_error(self, mock_session, mock_log):
"""401 (unauthorized) calling Adapter.create()."""
# Init test data
adapter = adp.Adapter(self.sess, use_cache=False)
new_scsi = pvm_stor.VSCSIClientAdapterElement.bld(adapter)
element = new_scsi
root_type = 'ManagedSystem'
root_id = 'id'
child_type = 'LogicalPartition'
create_response = self._mk_response(401)
# Mock out the method and class we are not currently testing
session = mock_session.return_value
session.request.return_value = create_response
# Run the actual test
self.assertRaises(pvmex.HttpError, adapter.create, element, root_type,
root_id, child_type)
mock_log.warn.assert_called_once_with(mock.ANY)
def test_delete(self, mock_session):
"""Test delete() method found in the Adapter class."""
# Init test data
root_type = 'ManagedSystem'
root_id = 'id'
adapter = adp.Adapter(self.sess, use_cache=False)
delete_response = self._mk_response(204)
# Mock out the method and class we are not currently testing
session = mock_session.return_value
session.request.return_value = delete_response
# Run the actual test
ret_delete_value = adapter.delete(root_type, root_id)
# Verify Correct path was built in build_path()
reqpath = adp.Adapter.build_path('uom', root_type, root_id, xag=[])
# Verify the return value
# self.assertIsInstance(ret_delete_value, adp.Response)
self.assertEqual('DELETE', ret_delete_value.reqmethod)
self.assertEqual(204, ret_delete_value.status)
self.assertEqual(reqpath, ret_delete_value.reqpath)
def test_log_helper(self, mock_log):
helpers = log_hlp.log_helper
response = adp.Response('GET', '/some/path', 200, 'OK', ['headers'])
self.sess.request.return_value = response
adpt = adp.Adapter(self.sess, helpers=helpers)
# Test that we get the response we expect passed back unharmed
self.assertEqual(response,
adpt._request('method', 'path', body='the body'))
# Should be 1 req/resp in the log now, which would be 4 info messages
mock_log.reset_mock()
log_hlp._write_thread_log()
self.assertEqual(mock_log.info.call_count, 4)
# Should be empty now
mock_log.reset_mock()
log_hlp._write_thread_log()
self.assertEqual(mock_log.info.call_count, 0)
# Test that we limit the number of entries
mock_log.reset_mock()
for x in range(0, 30):
adpt._request('method1', 'path', body='the body %d' % x)
log_hlp._write_thread_log()
# Each req/resp pair is 2 log entries but headers and body
# are logged separately, so with maxlogs=3, it's 3 * 2 * 2.
self.assertEqual(mock_log.info.call_count, (3 * 2 * 2))
mock_log.reset_mock()
# Add a few records
adpt._request('method1', 'path', body='the body')
# Ensure a 412 (special case) doesn't dump, but does raise
self.sess.request.side_effect = pvmex.HttpError(
mock.Mock(status=c.HTTPStatus.ETAG_MISMATCH))
self.assertRaises(pvmex.HttpError,
adpt._request,
'method2',
'path',
body='the body')
self.assertEqual(0, mock_log.info.call_count)
# Ensure a non-412 exception dumps the logs and is then raised
self.sess.request.side_effect = pvmex.HttpError(
mock.Mock(status=c.HTTPStatus.INTERNAL_ERROR))
mock_log.reset_mock()
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
# Should be 10 entries. 4 * 2 req/resp, 2 for this req.
self.assertEqual(mock_log.info.call_count, 10)
# Ensure the log storage is initialized correctly, and we can change
# the default value
hlp_size = functools.partial(log_hlp.log_helper, max_logs=12)
adpt1 = adp.Adapter(self.sess, helpers=hlp_size)
self.sess.request.side_effect = None
with mock.patch('pypowervm.helpers.log_helper.'
'_init_thread_stg') as mock_init:
adpt1._request('method1', 'path', body='the body')
# Should be called with 24 since 12 * 2 entries.
self.assertEqual(mock_init.call_args_list,
[mock.call(max_entries=24)])
def setup_adapter(self):
"""Configures the pypowervm adapter and utilities."""
self.adapter = pvm_adpt.Adapter(
pvm_adpt.Session(),
helpers=[log_hlp.log_helper, vio_hlp.vios_busy_retry_helper])
self.host_uuid = utils.get_host_uuid(self.adapter)
def test_traits_into_wrappers(self, mock_request):
# Note traits param is None, which reflects the real value of
# self.traits during _logon's request.
httpresp = req_mod.Response()
httpresp._content = _logon_response_text
httpresp.status_code = 200
httpresp.headers = req_struct.CaseInsensitiveDict({
'X-MC-Type':
'PVM',
'content-type':
'application/vnd.ibm.powervm.web+xml; type=LogonResponse'
})
mock_request.return_value = httpresp
sess = adp.Session()
self.assertEqual('PVM', sess.mc_type)
self.assertIsNotNone(sess.traits)
self.assertTrue(sess.traits.local_api)
self.assertFalse(sess.traits._is_hmc)
adapter = adp.Adapter(sess)
self.assertEqual(sess.traits, adapter.traits)
# Response => Feed => Entrys => EntryWrappers => sub-ElementWrappers
httpresp._content = _feed_file
resp = adapter.read('NetworkBridge')
self.assertEqual(sess.traits, resp.adapter.traits)
nblist = net.NetBridge.wrap(resp)
for nb in nblist:
self.assertIsInstance(nb, net.NetBridge)
self.assertEqual(sess.traits, nb.traits)
seas = nblist[0].seas
for sea in seas:
self.assertIsInstance(sea, net.SEA)
self.assertEqual(sess.traits, sea.traits)
trunk = seas[0].primary_adpt
self.assertIsInstance(trunk, net.TrunkAdapter)
self.assertEqual(sess.traits, trunk.traits)
# Response => Entry => EntryWrapper => sub-EntryWrappers
# => sub-sub-ElementWrapper
httpresp._content = _entry_file
resp = adapter.read('VolumeGroup', root_id='abc123')
self.assertEqual(sess.traits, resp.adapter.traits)
vgent = stor.VG.wrap(resp)
self.assertIsInstance(vgent, stor.VG)
self.assertEqual(sess.traits, vgent.traits)
pvs = vgent.phys_vols
for pvent in pvs:
self.assertIsInstance(pvent, stor.PV)
self.assertEqual(sess.traits, pvent.traits)
# Building raw wrappers from scratch
class MyEntryWrapper(ewrap.EntryWrapper):
schema_type = 'SomeObject'
@classmethod
def bld(cls, adpt):
return super(MyEntryWrapper, cls)._bld(adpt)
mew = MyEntryWrapper.bld(adapter)
self.assertIsInstance(mew, MyEntryWrapper)
self.assertEqual(sess.traits, mew.traits)
class MyElementWrapper(ewrap.ElementWrapper):
schema_type = 'SomeObject'
@classmethod
def bld(cls, adpt):
return super(MyElementWrapper, cls)._bld(adpt)
mew = MyElementWrapper.bld(adapter)
self.assertIsInstance(mew, MyElementWrapper)
self.assertEqual(sess.traits, mew.traits)
def test_none(self):
adpt = adp.Adapter('mock_session', helpers=None)
self.assertEqual([], adpt.helpers)
def test_single(self):
hlp = functools.partial(cat_string_helper, string="purple!")
adpt = adp.Adapter('mock_session', helpers=hlp)
self.assertEqual([hlp], adpt.helpers)
def test_no_helpers(self, mock_sess):
mock_sess.request.return_value = 'ReturnValue'
adpt = adp.Adapter(mock_sess)
self.assertEqual('ReturnValue', adpt._request('method', 'path'))
def test_extend_path(self, mock_session):
# Init test data
adapter = adp.Adapter(self.sess, use_cache=False)
path = adapter.extend_path('basepath',
suffix_type='suffix',
suffix_parm='suffix_parm',
detail='detail',
xag=[pvm_vios.VIOS.xags.FC_MAPPING])
expected_path = ('basepath/suffix/suffix_parm?detail=detail&'
'group=ViosFCMapping')
self._assert_paths_equivalent(expected_path, path)
# Multiple XAGs in a set
path = adapter.extend_path(
'basepath',
suffix_type='suffix',
suffix_parm='suffix_parm',
detail='detail',
xag={pvm_vios.VIOS.xags.FC_MAPPING, pvm_vios.VIOS.xags.NETWORK})
expected_path = ('basepath/suffix/suffix_parm?detail=detail&'
'group=ViosFCMapping,ViosNetwork')
self._assert_paths_equivalent(expected_path, path)
# Verify sorting
path = adapter.extend_path(
'basepath',
suffix_type='suffix',
suffix_parm='suffix_parm',
detail='detail',
xag=[pvm_vios.VIOS.xags.NETWORK, pvm_vios.VIOS.xags.FC_MAPPING])
expected_path = ('basepath/suffix/suffix_parm?detail=detail&'
'group=ViosFCMapping,ViosNetwork')
self._assert_paths_equivalent(expected_path, path)
# Explicitly no XAG
path = adapter.extend_path('basepath',
suffix_type='suffix',
suffix_parm='suffix_parm',
detail='detail',
xag=[])
expected_path = 'basepath/suffix/suffix_parm?detail=detail'
self._assert_paths_equivalent(expected_path, path)
# Ensure unspecified XAG defaults to group=None
path = adapter.extend_path('basepath',
suffix_type='suffix',
suffix_parm='suffix_parm')
expected_path = 'basepath/suffix/suffix_parm?group=None'
self._assert_paths_equivalent(expected_path, path)
# ...except for specific suffix types 'quick' and 'do'
path = adapter.extend_path('basepath',
suffix_type='quick',
suffix_parm='suffix_parm')
expected_path = 'basepath/quick/suffix_parm'
self._assert_paths_equivalent(expected_path, path)
path = adapter.extend_path('basepath',
suffix_type='do',
suffix_parm='suffix_parm')
expected_path = 'basepath/do/suffix_parm'
self._assert_paths_equivalent(expected_path, path)
# Ensure arg xags and path xags interact correctly
# path_xag=None, arg_xag=None => group=None
self._assert_paths_equivalent('basepath?group=None',
adapter.extend_path('basepath'))
# path_xag='None', arg_xag=None => group=None
self._assert_paths_equivalent(
'basepath?group=None', adapter.extend_path('basepath?group=None'))
# path_xag='a,b,c', arg_xag=None => group=a,b,c
self._assert_paths_equivalent(
'basepath?group=a,b,c',
adapter.extend_path('basepath?group=a,b,c'))
# path_xag=None, arg_xag=() => no group=
self._assert_paths_equivalent('basepath',
adapter.extend_path('basepath', xag=()))
# path_xag='None', arg_xag={} => no group=
self._assert_paths_equivalent(
'basepath', adapter.extend_path('basepath?group=None', xag={}))
# path_xag='a,b,c', arg_xag=[] => ValueError
self.assertRaises(ValueError,
adapter.extend_path,
'basepath?group=a,b,c',
xag=[])
# path_xag=None, arg_xag='a,b,c' => group='a,b,c'
self._assert_paths_equivalent(
'basepath?group=a,b,c',
adapter.extend_path('basepath', xag={'a', 'b', 'c'}))
# path_xag='None', arg_xag='a,b,c' => group='a,b,c'
self._assert_paths_equivalent(
'basepath?group=a,b,c',
adapter.extend_path('basepath?group=None', xag=('a', 'b', 'c')))
# path_xag='a,b,c', arg_xag='a,b,c' => group='a,b,c'
self._assert_paths_equivalent(
'basepath?group=a,b,c',
adapter.extend_path('basepath?group=a,b,c', xag=['a', 'b', 'c']))
# path_xag='a,b,c', arg_xag='d,e,f' => ValueError
self.assertRaises(ValueError,
adapter.extend_path,
'basepath?group=a,b,c',
xag=['d', 'e', 'f'])
# Multi-instance query params properly reassembled.
self._assert_paths_equivalent(
'basepath?foo=1,2,3&group=a,b,c&foo=4,5,6',
adapter.extend_path('basepath?foo=4,5,6&group=None&foo=1,2,3',
xag=['a', 'b', 'c']))
def test_empty_init(self, mock_sess):
adp.Adapter()
mock_sess.assert_called_with()
