def test_valid_proxy(self, send):
send().content = self.send_content
make_xml_rpc_api_call('http://something.com/path/to/resource',
'getObject',
proxy='http://localhost:3128')
send.assert_called_with(
ANY,
proxies={'https': 'http://localhost:3128',
'http': 'http://localhost:3128'},
timeout=None)
def test_valid_proxy(self, send):
send().content = self.send_content
transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource',
'getObject',
proxy='http://localhost:3128')
send.assert_called_with(mock.ANY,
proxies={
'https': 'http://localhost:3128',
'http': 'http://localhost:3128'
},
timeout=None)
def test_valid_proxy(self, request):
request.return_value = self.response
transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource',
'getObject',
proxy='http://localhost:3128')
request.assert_called_with(
'POST',
mock.ANY,
headers=None,
proxies={'https': 'http://localhost:3128',
'http': 'http://localhost:3128'},
data=mock.ANY,
timeout=None)
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><nil/></value></member>
</struct></value>
</param>
</params>
</methodCall>
'''
resp = transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource', 'getObject')
args = request.call_args
self.assertIsNotNone(args)
args, kwargs = args
request.assert_called_with('POST',
'http://something.com/path/to/resource',
headers=None,
proxies=None,
data=data,
timeout=None)
self.assertEqual(resp, [])
def test_call(self, send):
send().content = """<?xml version="1.0" encoding="utf-8"?>
<params>
<param>
<value>
<array>
<data/>
</array>
</value>
</param>
</params>
"""
data = """<?xml version='1.0'?>
<methodCall>
<methodName>getObject</methodName>
<params>
<param>
<value><struct>
<member>
<name>headers</name>
<value><nil/></value></member>
</struct></value>
</param>
</params>
</methodCall>
"""
resp = make_xml_rpc_api_call("http://something.com/path/to/resource", "getObject")
args = send.call_args
self.assertIsNotNone(args)
args, kwargs = args
send.assert_called_with(ANY, timeout=None)
self.assertEqual(resp, [])
self.assertEquals(args[0].body, data)
def test_call(self, post):
post().content = '''<?xml version="1.0" encoding="utf-8"?>
<params>
<param>
<value>
<array>
<data/>
</array>
</value>
</param>
</params>
'''
data = '''<?xml version='1.0'?>
<methodCall>
<methodName>getObject</methodName>
<params>
<param>
<value><struct>
<member>
<name>headers</name>
<value><nil/></value></member>
</struct></value>
</param>
</params>
</methodCall>
'''
resp = make_xml_rpc_api_call(
'http://something.com/path/to/resource', 'getObject')
self.assertEqual(resp, [])
post.assert_called_with(
'http://something.com/path/to/resource',
data=data,
headers=None,
timeout=None,)
def test_call(self, send):
send().content = self.send_content
data = '''<?xml version='1.0'?>
<methodCall>
<methodName>getObject</methodName>
<params>
<param>
<value><struct>
<member>
<name>headers</name>
<value><nil/></value></member>
</struct></value>
</param>
</params>
</methodCall>
'''
resp = transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource', 'getObject')
args = send.call_args
self.assertIsNotNone(args)
args, kwargs = args
send.assert_called_with(mock.ANY, proxies=None, timeout=None)
self.assertEqual(resp, [])
self.assertEqual(args[0].body, data)
def test_valid_proxy(self, request):
request.return_value = self.response
transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource',
'getObject',
proxy='http://localhost:3128')
request.assert_called_with(
'POST',
mock.ANY,
headers=None,
proxies={'https': 'http://localhost:3128',
'http': 'http://localhost:3128'},
data=mock.ANY,
timeout=None,
cert=None,
verify=True)
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><nil/></value></member>
</struct></value>
</param>
</params>
</methodCall>
'''
resp = transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource', 'getObject')
args = request.call_args
self.assertIsNotNone(args)
args, kwargs = args
request.assert_called_with('POST',
'http://something.com/path/to/resource',
headers=None,
proxies=None,
data=data,
timeout=None,
cert=None,
verify=True)
self.assertEqual(resp, [])
def test_call(self, send):
send().content = self.send_content
data = '''<?xml version='1.0'?>
<methodCall>
<methodName>getObject</methodName>
<params>
<param>
<value><struct>
<member>
<name>headers</name>
<value><nil/></value></member>
</struct></value>
</param>
</params>
</methodCall>
'''
resp = transports.make_xml_rpc_api_call(
'http://something.com/path/to/resource', 'getObject')
args = send.call_args
self.assertIsNotNone(args)
args, kwargs = args
send.assert_called_with(mock.ANY, proxies=None, timeout=None)
self.assertEqual(resp, [])
self.assertEqual(args[0].body, data)
def test_no_hostname(self):
try:
request = transports.Request()
request.endpoint = 'http://notvalidsoftlayer.com'
request.service = 'SoftLayer_Account'
request.method = 'getObject'
request.id = 1234
# This test will fail if 'notvalidsoftlayer.com' becomes a thing
transports.make_xml_rpc_api_call(request)
except SoftLayer.SoftLayerAPIError as ex:
self.assertIn('not known', str(ex))
self.assertIn('not known', ex.faultString)
self.assertEqual(ex.faultCode, 0)
else:
self.fail('No Exception Raised')
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.Client()
>>> 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 not service.startswith(self._prefix):
service = self._prefix + service
headers = kwargs.get("headers", {})
if self.auth:
headers.update(self.auth.get_headers())
if kwargs.get("id") is not None:
headers[service + "InitParameters"] = {"id": kwargs.get("id")}
if kwargs.get("mask") is not None:
headers.update(self.__format_object_mask(kwargs.get("mask"), service))
if kwargs.get("filter") is not None:
headers["%sObjectFilter" % service] = kwargs.get("filter")
if kwargs.get("limit"):
headers["resultLimit"] = {"limit": kwargs.get("limit"), "offset": kwargs.get("offset", 0)}
http_headers = {"User-Agent": consts.USER_AGENT, "Content-Type": "application/xml"}
if kwargs.get("compress", True):
http_headers["Accept"] = "*/*"
http_headers["Accept-Encoding"] = "gzip, deflate, compress"
if kwargs.get("raw_headers"):
http_headers.update(kwargs.get("raw_headers"))
uri = "/".join([self.endpoint_url, service])
return transports.make_xml_rpc_api_call(
uri, method, args, headers=headers, http_headers=http_headers, timeout=self.timeout, proxy=self.proxy
)
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.Client()
>>> 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 not service.startswith(self._prefix):
service = self._prefix + service
headers = kwargs.get('headers', {})
if self.auth:
headers.update(self.auth.get_headers())
if kwargs.get('id') is not None:
headers[service + 'InitParameters'] = {'id': kwargs.get('id')}
if kwargs.get('mask') is not None:
headers.update(
self.__format_object_mask(kwargs.get('mask'), service))
if kwargs.get('filter') is not None:
headers['%sObjectFilter' % service] = kwargs.get('filter')
if kwargs.get('limit'):
headers['resultLimit'] = {
'limit': kwargs.get('limit'),
'offset': kwargs.get('offset', 0),
}
http_headers = {
'User-Agent': self.user_agent or consts.USER_AGENT,
'Content-Type': 'application/xml',
}
if kwargs.get('compress', True):
http_headers['Accept'] = '*/*'
http_headers['Accept-Encoding'] = 'gzip, deflate, compress'
if kwargs.get('raw_headers'):
http_headers.update(kwargs.get('raw_headers'))
uri = '/'.join([self.endpoint_url, service])
return transports.make_xml_rpc_api_call(uri,
method,
args,
headers=headers,
http_headers=http_headers,
timeout=self.timeout,
proxy=self.proxy)
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.Client()
>>> 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 not service.startswith(self._prefix):
service = self._prefix + service
headers = kwargs.get('headers', {})
if self.auth:
headers.update(self.auth.get_headers())
if kwargs.get('id') is not None:
headers[service + 'InitParameters'] = {'id': kwargs.get('id')}
if kwargs.get('mask') is not None:
headers.update(self.__format_object_mask(kwargs.get('mask'),
service))
if kwargs.get('filter') is not None:
headers['%sObjectFilter' % service] = kwargs.get('filter')
if kwargs.get('limit'):
headers['resultLimit'] = {
'limit': kwargs.get('limit'),
'offset': kwargs.get('offset', 0),
}
http_headers = {
'User-Agent': self.user_agent or consts.USER_AGENT,
'Content-Type': 'application/xml',
}
if kwargs.get('compress', True):
http_headers['Accept'] = '*/*'
http_headers['Accept-Encoding'] = 'gzip, deflate, compress'
if kwargs.get('raw_headers'):
http_headers.update(kwargs.get('raw_headers'))
uri = '/'.join([self.endpoint_url, service])
return transports.make_xml_rpc_api_call(uri, method, args,
headers=headers,
http_headers=http_headers,
timeout=self.timeout,
proxy=self.proxy)
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.Client()
>>> 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 not service.startswith(self._prefix):
service = self._prefix + service
http_headers = {
'User-Agent': self.user_agent or consts.USER_AGENT,
'Content-Type': 'application/xml',
}
if kwargs.get('compress', True):
http_headers['Accept'] = '*/*'
http_headers['Accept-Encoding'] = 'gzip, deflate, compress'
if kwargs.get('raw_headers'):
http_headers.update(kwargs.get('raw_headers'))
request = transports.Request()
request.endpoint = self.endpoint_url
request.service = service
request.method = method
request.args = args
request.transport_headers = http_headers
request.timeout = self.timeout
request.proxy = self.proxy
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)
return transports.make_xml_rpc_api_call(request)
