def _mk_response(self, status, content=None):
reasons = {200: 'OK', 204: 'No Content', 401: 'Unauthorized'}
# Create a Response object, that will serve as a mock return value
my_response = req_mod.Response()
my_response.status_code = status
my_response.reason = reasons[status]
clen = '0'
if status == 200 and content:
clen = str(len(content))
dict_headers = {
'content-length':
clen,
'x-powered-by':
'Servlet/3.0',
'set-cookie':
'JSESSIONID=0000a41BnJsGTNQvBGERA' +
'3wR1nj:759878cb-4f9a-4b05-a09a-3357abfea3b4; ' +
'Path=/; Secure; HttpOnly, CCFWSESSION=E4C0FFBE9' +
'130431DBF1864171ECC6A6E; Path=/; Secure; HttpOnly',
'expires':
'Thu, 01 Dec 1994 16:00:00 GMT',
'x-transaction-id':
'XT10000073',
'cache-control':
'no-cache="set-cookie, ' + 'set-cookie2"',
'date':
'Wed, 23 Jul 2014 21:51:10 GMT',
'content-type':
'application/vnd.ibm.powervm'
}
my_response.headers = req_struct.CaseInsensitiveDict(dict_headers)
my_response._content = content
return my_response
def send(self, request, **kwargs): # pylint: disable=unused-argument
self._recorder.append(request)
resp = models.Response()
resp.url = request.url
resp.status_code = self._status
resp.raw = six.BytesIO(self._data.encode())
return resp
def _create_response(self, status=500, payload=None):
resp = models.Response()
resp.status_code = status
if payload:
resp.raw = io.BytesIO(payload.encode())
exc = requests.exceptions.RequestException('Test error', response=resp)
return resp, exc
def send(self, request, **kwargs):
request._extra_kwargs = kwargs
self._recorder.append(request)
resp = models.Response()
resp.url = request.url
resp.status_code = self._status
resp.raw = self._data.encode()
return resp
def send(self, request, **kwargs):
del kwargs
self._recorder.append(request)
resp = models.Response()
resp.url = request.url
resp.status_code = self._status
resp.raw = six.BytesIO(self._data.encode())
return resp
def test_from_response_unknown_middleware(self):
r = models.Response()
r.status_code = 400
r.headers['Content-Type'] = "application/json"
r._content = json.dumps({"unknown": "random message"}).encode('utf-8')
exc = exceptions.from_response(r)
self.assertIsInstance(exc, exceptions.ClientException)
self.assertEqual('{"unknown": "random message"}', exc.message)
def mocked_request(*args, **kwargs):
if args[2].endswith('api/session/create'):
response = models.Response()
response.status_code = 200
response.headers = {
'Set-Cookie': 'JSESSIONID=%s;junk' % JSESSIONID
}
return response
return orig_request(*args, **kwargs)
def test_from_response_404(self):
r = models.Response()
r.status_code = 404
r.headers['Content-Type'] = "application/json"
r._content = json.dumps(
{"description": "Archive policy rule foobar does not exist"}
).encode('utf-8')
exc = exceptions.from_response(r)
self.assertIsInstance(exc, exceptions.ArchivePolicyRuleNotFound)
def test_resource_type_before_resource(self):
r = models.Response()
r.status_code = 404
r.headers['Content-Type'] = "application/json"
r._content = json.dumps(
{"description": "Resource type foobar does not exist"}
).encode('utf-8')
exc = exceptions.from_response(r)
self.assertIsInstance(exc, exceptions.ResourceTypeNotFound)
def send(self, request, **kwargs): # pylint: disable=arguments-differ
request._extra_kwargs = kwargs
self._recorder.append(request)
resp = models.Response()
resp.url = request.url
resp.status_code = self._statuses[self._current_response]
resp.raw = io.BytesIO(self._responses[self._current_response].encode())
self._current_response = min(self._current_response + 1, len(self._responses) - 1)
return resp
def test_from_response_keystone_401(self):
r = models.Response()
r.status_code = 401
r.headers['Content-Type'] = "application/json"
r._content = json.dumps({"error": {
"message": "The request you have made requires authentication.",
"code": 401, "title": "Unauthorized"}}
).encode('utf-8')
exc = exceptions.from_response(r)
self.assertIsInstance(exc, exceptions.Unauthorized)
self.assertEqual("The request you have made requires authentication.",
exc.message)
def test_from_response_404_with_detail(self):
r = models.Response()
r.status_code = 404
r.headers['Content-Type'] = "application/json"
r._content = json.dumps({
"code": 404,
"description": {
"cause": "Aggregation method does not exist for this metric",
"detail": {
"aggregation_method": "rate:mean",
"metric": "a914dad6-b8f6-42f6-b090-6daa29725caf",
}},
"title": "Not Found"
}).encode('utf-8')
exc = exceptions.from_response(r)
self.assertIsInstance(exc, exceptions.ClientException)
def send(self, request, **kwargs):
"""Suppresses sending of the request. A default response is returned
with status code 200, `Content-Type` and `Location` headers and a
copy of the body from the request.
"""
self.last_request = request
self.last_request_kwargs = kwargs
response = models.Response()
response.request = request
response.connection = self
response.status_code = 200
response.reason = 'OK'
response.headers = {
'Content-Type': 'application/json',
'location': request.url,
}
if request.body is not None:
response._content = bytes(request.body.encode('utf-8'))
return response
def get_sess_create_resp():
sess_create_response = models.Response()
sess_create_response.status_code = 200
sess_create_response.headers = {'Set-Cookie': 'JSESSIONID=abc;'}
return sess_create_response
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_logon(self, mock_session, mock_validate_cert):
"""Ensure a Session can be created and log on to PowerVM."""
# Init test data
host = '0.0.0.0'
user = '******'
pwd = 'pwd'
auditmemento = 'audit'
# Create a Response object, that will serve as a mock return value
my_response = req_mod.Response()
my_response.status_code = 200
my_response.reason = 'OK'
dict_headers = {'content-length': '576',
'x-powered-by': 'Servlet/3.0',
'set-cookie': 'JSESSIONID=0000a41BnJsGTNQvBGERA3wR1nj:'
'759878cb-4f9a-4b05-a09a-3357abfea3b4; P'
'ath=/; Secure; HttpOnly, CCFWSESSION=E4'
'C0FFBE9130431DBF1864171ECC6A6E; Path=/;'
' Secure; HttpOnly',
'expires': 'Thu, 01 Dec 1994 16:00:00 GMT',
'x-transaction-id': 'XT10000073',
'cache-control': 'no-cache="set-cookie, set-cookie2"',
'date': 'Wed, 23 Jul 2014 21:51:10 GMT',
'content-type': 'application/vnd.ibm.powervm.web+xml; '
'type=LogonResponse'}
my_response.headers = req_struct.CaseInsensitiveDict(dict_headers)
my_response._content = _logon_response_password
# Mock out the method and class we are not currently testing
session = mock_session.return_value
session.request.return_value = my_response
# Run the actual test
result = adp.Session(host, user, pwd, auditmemento=auditmemento)
# Verify the result
self.assertTrue(result._logged_in)
self.assertEqual('PUIoR6x0kP6fQqA7qZ8sLZQJ8MLx9JHfLCYzT4oGFSE2WaGIhaFX'
'IyQYvbqdKNS8QagjBpPi9NP7YR_h61SOJ3krS_RvKAp-oCf2p8x8'
'uvQrrDv-dUzc17IT5DkR7_jv2qc8iUD7DJ6Rw53a17rY0p63KqPg'
'9oUGd6Bn3fNDLiEwaBR4WICftVxUFj-tfWMOyZZY2hWEtN2K8ScX'
'vyFMe-w3SleyRbGnlR34jb0A99s=', result._sessToken)
self.assertEqual(1, mock_validate_cert.call_count)
# No X-MC-Type header => 'HMC' is assumed.
self.assertEqual('HMC', result.mc_type)
# Now test file-based authentication and X-MC-Type
my_response._content = _logon_response_file
# Local/HMC is bad
self.assertRaises(pvmex.Error, adp.Session)
my_response.headers['X-MC-Type'] = 'PVM'
result = adp.Session()
# Verify the result.
self.assertTrue(result._logged_in)
# Token read from token_file, as indicated by logon_file.xml response.
self.assertEqual('file-based-auth-token', result._sessToken)
# validate_certificate should not have been called again
self.assertEqual(1, mock_validate_cert.call_count)
self.assertEqual('PVM', result.mc_type)
def _MockResponse(status_code, content):
requests_response = models.Response()
requests_response.status_code = status_code
requests_response._content = content
return requests._Response(requests_response)
