def test_valid_proxy(self, request):
request.return_value = self.response
self.transport.proxy = 'http://localhost:3128'
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'Resource'
self.transport(req)
request.assert_called_with('POST',
mock.ANY,
proxies={
'https': 'http://localhost:3128',
'http': 'http://localhost:3128'
},
data=mock.ANY,
headers=mock.ANY,
timeout=None,
cert=None,
verify=True,
auth=None)
def test_old_mask(self, request):
request.return_value = self.response
req = transports.Request()
req.endpoint = "http://something.com"
req.service = "SoftLayer_Service"
req.method = "getObject"
req.mask = {"something": "nested"}
self.transport(req)
args, kwargs = request.call_args
self.assertIn(
"""<member>
<name>mask</name>
<value><struct>
<member>
<name>something</name>
<value><string>nested</string></value>
</member>
</struct></value>
</member>""", kwargs['data'])
def test_valid_proxy(self, request):
request().text = '{}'
self.transport.proxy = 'http://localhost:3128'
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'Resource'
self.transport(req)
request.assert_called_with(
'GET', 'http://something.com/SoftLayer_Service/Resource.json',
proxies={'https': 'http://localhost:3128',
'http': 'http://localhost:3128'},
auth=None,
data=None,
params={},
verify=True,
cert=None,
timeout=mock.ANY,
headers=mock.ANY)
def test_call(self, request):
request.return_value = self.response
data = '''<?xml version='1.0'?>
<methodCall>
<methodName>getObject</methodName>
<params>
<param>
<value><struct>
<member>
<name>headers</name>
<value><struct>
</struct></value>
</member>
</struct></value>
</param>
</params>
</methodCall>
'''
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'getObject'
resp = self.transport(req)
request.assert_called_with('POST',
'http://something.com/SoftLayer_Service',
headers={
'Content-Type': 'application/xml',
'User-Agent': consts.USER_AGENT
},
proxies=None,
data=data,
timeout=None,
cert=None,
verify=True,
auth=None)
self.assertEqual(resp, [])
self.assertIsInstance(resp, transports.SoftLayerListResult)
self.assertEqual(resp.total_count, 10)
def test_with_args(self, request):
request().content = '{}'
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'getObject'
req.args = ('test', 1)
resp = self.transport(req)
self.assertEqual(resp, {})
request.assert_called_with(
'POST',
'http://something.com/SoftLayer_Service/getObject.json',
headers=mock.ANY,
auth=None,
data='{"parameters": ["test", 1]}',
params={},
verify=True,
cert=None,
proxies=None,
timeout=None)
def test_with_id(self, request):
request().content = '{}'
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'getObject'
req.identifier = 2
resp = self.transport(req)
self.assertEqual(resp, {})
request.assert_called_with(
'GET',
'http://something.com/SoftLayer_Service/2/getObject.json',
headers=mock.ANY,
auth=None,
data=None,
params={},
verify=True,
cert=None,
proxies=None,
timeout=None)
def test_with_filter(self, request):
request().content = '{}'
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'getObject'
req.filter = {'TYPE': {'attribute': {'operation': '^= prefix'}}}
resp = self.transport(req)
self.assertEqual(resp, {})
request.assert_called_with(
'GET',
'http://something.com/SoftLayer_Service/getObject.json',
params={'objectFilter':
'{"TYPE": {"attribute": {"operation": "^= prefix"}}}'},
headers=mock.ANY,
auth=None,
data=None,
verify=True,
cert=None,
proxies=None,
timeout=None)
def test_basic(self, request):
request().content = '[]'
request().headers = requests.structures.CaseInsensitiveDict({
'SoftLayer-Total-Items': '10',
})
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'Resource'
resp = self.transport(req)
self.assertEqual(resp, [])
self.assertIsInstance(resp, transports.SoftLayerListResult)
self.assertEqual(resp.total_count, 10)
request.assert_called_with(
'GET', 'http://something.com/SoftLayer_Service/Resource.json',
headers=mock.ANY,
auth=None,
data=None,
params={},
verify=True,
cert=None,
proxies=None,
timeout=None)
def test_with_limit_offset(self, request):
request().text = '{}'
req = transports.Request()
req.service = 'SoftLayer_Service'
req.method = 'getObject'
req.identifier = 2
req.limit = 10
req.offset = 5
resp = self.transport(req)
self.assertEqual(resp, {})
request.assert_called_with(
'GET',
'http://something9999999999999999999999.com/SoftLayer_Service/2/getObject.json',
headers=mock.ANY,
auth=None,
data=None,
params={'resultLimit': '5,10'},
verify=True,
cert=None,
proxies=None,
timeout=None)
def test_print_reproduceable(self):
req = transports.Request()
req.service = 'SoftLayer_Account'
req.method = 'getObject'
output_text = self.transport.print_reproduceable(self.req)
self.assertEqual('SoftLayer_Account', output_text)
def test_call(self):
req = transports.Request()
req.service = 'SoftLayer_Account'
req.method = 'getObject'
resp = self.transport(req)
self.assertEqual(resp['accountId'], 1234)
def test_no_method(self):
req = transports.Request()
req.service = 'SoftLayer_Account'
req.method = 'getObjectzzzz'
self.assertRaises(NotImplementedError, self.transport, req)
def test_no_module(self):
req = transports.Request()
req.service = 'Doesnt_Exist'
req.method = 'getObject'
self.assertRaises(NotImplementedError, self.transport, req)
def call(self, service, method, *args, **kwargs):
"""Make a SoftLayer API call
:param service: the name of the SoftLayer API service
:param method: the method to call on the service
:param \\*args: same optional arguments that ``Service.call`` takes
:param \\*\\*kwargs: same optional keyword arguments that
``Service.call`` takes
:param service: the name of the SoftLayer API service
Usage:
>>> import SoftLayer
>>> client = SoftLayer.create_client_from_env()
>>> client['Account'].getVirtualGuests(mask="id", limit=10)
[...]
"""
if kwargs.pop('iter', False):
return self.iter_call(service, method, *args, **kwargs)
invalid_kwargs = set(kwargs.keys()) - VALID_CALL_ARGS
if invalid_kwargs:
raise TypeError(
'Invalid keyword arguments: %s' % ','.join(invalid_kwargs))
if self._prefix and not service.startswith(self._prefix):
service = self._prefix + service
http_headers = {'Accept': '*/*'}
if kwargs.get('compress', True):
http_headers['Accept-Encoding'] = 'gzip, deflate, compress'
else:
http_headers['Accept-Encoding'] = None
if kwargs.get('raw_headers'):
http_headers.update(kwargs.get('raw_headers'))
request = transports.Request()
request.service = service
request.method = method
request.args = args
request.transport_headers = http_headers
request.identifier = kwargs.get('id')
request.mask = kwargs.get('mask')
request.filter = kwargs.get('filter')
request.limit = kwargs.get('limit')
request.offset = kwargs.get('offset')
if self.auth:
extra_headers = self.auth.get_headers()
if extra_headers:
warnings.warn("auth.get_headers() is deprecated and will be "
"removed in the next major version",
DeprecationWarning)
request.headers.update(extra_headers)
request = self.auth.get_request(request)
request.headers.update(kwargs.get('headers', {}))
return self.transport(request)
def test_get_request(self):
req = transports.Request()
authed_req = self.auth.get_request(req)
self.assertEqual(authed_req.transport_user, 'USERNAME')
self.assertEqual(authed_req.transport_password, 'APIKEY')
def call(self, service, method, *args, **kwargs):
"""Make a SoftLayer API call.
:param method: the method to call on the service
:param \\*args: (optional) arguments for the remote call
:param id: (optional) id for the resource
:param mask: (optional) object mask
:param dict filter: (optional) filter dict
:param dict headers: (optional) optional XML-RPC headers
:param boolean compress: (optional) Enable/Disable HTTP compression
:param dict raw_headers: (optional) HTTP transport headers
:param int limit: (optional) return at most this many results
:param int offset: (optional) offset results by this many
:param boolean iter: (optional) if True, returns a generator with the results
:param bool verify: verify SSL cert
:param cert: client certificate path
Usage:
>>> import SoftLayer
>>> client = SoftLayer.create_client_from_env()
>>> client.call('Account', 'getVirtualGuests', mask="id", limit=10)
[...]
"""
if kwargs.pop('iter', False):
# Most of the codebase assumes a non-generator will be returned, so casting to list
# keeps those sections working
return list(self.iter_call(service, method, *args, **kwargs))
invalid_kwargs = set(kwargs.keys()) - VALID_CALL_ARGS
if invalid_kwargs:
raise TypeError('Invalid keyword arguments: %s' %
','.join(invalid_kwargs))
prefixes = (self._prefix, 'BluePages_Search',
'IntegratedOfferingTeam_Region')
if self._prefix and not service.startswith(prefixes):
service = self._prefix + service
http_headers = {'Accept': '*/*'}
if kwargs.get('compress', True):
http_headers['Accept-Encoding'] = 'gzip, deflate, compress'
else:
http_headers['Accept-Encoding'] = None
if kwargs.get('raw_headers'):
http_headers.update(kwargs.get('raw_headers'))
request = transports.Request()
request.service = service
request.method = method
request.args = args
request.transport_headers = http_headers
request.identifier = kwargs.get('id')
request.mask = kwargs.get('mask')
request.filter = kwargs.get('filter')
request.limit = kwargs.get('limit')
request.offset = kwargs.get('offset')
if kwargs.get('verify') is not None:
request.verify = kwargs.get('verify')
if self.auth:
extra_headers = self.auth.get_headers()
if extra_headers:
warnings.warn(
"auth.get_headers() is deprecated and will be "
"removed in the next major version", DeprecationWarning)
request.headers.update(extra_headers)
request = self.auth.get_request(request)
request.headers.update(kwargs.get('headers', {}))
return self.transport(request)
