def setup_client(self):
http_client = SynchronousHttpClient()
http_client.set_basic_auth(
urlparse(self.http_uri).netloc.split(':')[0], self.ari_user,
self.ari_pass)
self.client = SwaggerClient(self.ari_url, http_client=http_client)
logger.info('ARI client setup done.')
def __init__(self):
LogDefine()
self.http_client = SynchronousHttpClient()
# self.host
# self.port
# self.method
# self.parameters
# self.data
self.verification = []
def test_simple_get(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
uut = SynchronousHttpClient()
resp = uut.request('GET', "http://swagger.py/client-test",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
def test_simple_get(self):
httpretty.register_uri(httpretty.GET,
"http://swagger.py/client-test",
body='expected')
uut = SynchronousHttpClient()
resp = uut.request('GET',
"http://swagger.py/client-test",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
def test_api_key(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
uut = SynchronousHttpClient()
uut.set_api_key("swagger.py",
'abc123', param_name='test')
resp = uut.request('GET', "http://swagger.py/client-test",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar'], 'test': ['abc123']},
httpretty.last_request().querystring)
def make_request(method, url, parameters=None, data=None):
http_client = SynchronousHttpClient()
"""
method = 'get'
parameters = {
'keywords': '刘德华',
}
参数根据swagger定义的参数进行传递
"""
z = http_client.request(
method=method, url=url, params=parameters,
data=data) #Request请求传入method= 'get'|'post'|'put' 等,传入url 传入请求参数
#http_client.websockets.difference()
return z
def test_auth_leak(self):
httpretty.register_uri(httpretty.GET,
"http://hackerz.py",
body='expected')
uut = SynchronousHttpClient()
uut.set_basic_auth("swagger.py", 'unit', 'peekaboo')
resp = uut.request('GET', "http://hackerz.py", params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertTrue(
httpretty.last_request().headers.get('Authorization') is None)
def test_real_post(self):
httpretty.register_uri(
httpretty.POST, "http://swagger.py/client-test",
body='expected', content_type='text/json')
uut = SynchronousHttpClient()
resp = uut.request('POST', "http://swagger.py/client-test",
data={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual('application/x-www-form-urlencoded',
httpretty.last_request().headers['content-type'])
self.assertEqual("foo=bar",
httpretty.last_request().body)
def test_auth_leak(self):
httpretty.register_uri(
httpretty.GET, "http://hackerz.py",
body='expected')
uut = SynchronousHttpClient()
uut.set_basic_auth("swagger.py", 'unit', 'peekaboo')
resp = uut.request('GET', "http://hackerz.py",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertTrue(
httpretty.last_request().headers.get('Authorization') is None)
def test_basic_auth(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
uut = SynchronousHttpClient()
uut.set_basic_auth("swagger.py", 'unit', 'peekaboo')
resp = uut.request('GET', "http://swagger.py/client-test",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertEqual('Basic %s' % base64.b64encode("unit:peekaboo"),
httpretty.last_request().headers.get('Authorization'))
def test_real_post(self):
httpretty.register_uri(httpretty.POST,
"http://swagger.py/client-test",
body='expected',
content_type='text/json')
uut = SynchronousHttpClient()
resp = uut.request('POST',
"http://swagger.py/client-test",
data={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual('application/x-www-form-urlencoded',
httpretty.last_request().headers['content-type'])
self.assertEqual("foo=bar", httpretty.last_request().body)
def test_unicode_to_utf8_encode_params(self):
httpretty.register_uri(httpretty.GET,
"http://swagger.py/client-test",
body='expected')
client = SynchronousHttpClient()
params = self._default_params()
params['params'] = {'foo': u'酒場'}
resp = client.start_request(params).wait()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': [u'酒場']},
httpretty.last_request().querystring)
def test_basic_auth(self):
httpretty.register_uri(httpretty.GET,
"http://swagger.py/client-test",
body='expected')
uut = SynchronousHttpClient()
uut.set_basic_auth("swagger.py", 'unit', 'peekaboo')
resp = uut.request('GET',
"http://swagger.py/client-test",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertEqual('Basic %s' % base64.b64encode("unit:peekaboo"),
httpretty.last_request().headers.get('Authorization'))
def from_url(cls,
url,
http_client=None,
api_base_path=None,
request_options=None):
"""
Build a :class:`SwaggerClient` from a url to api docs describing the
api.
:param url: url pointing at the swagger api docs
:type url: str
:param http_client: an HTTP client used to perform requests
:type http_client: :class:`swaggerpy.http_client.HttpClient`
:param api_base_path: a url, override the path used to make api requests
:type api_base_path: str
:param request_options: extra values to pass with api docs requests
:type request_options: dict
"""
log.debug(u"Loading from %s" % url)
http_client = http_client or SynchronousHttpClient()
return cls.from_resource_listing(load_resource_listing(
url, http_client, None, request_options),
http_client=http_client,
api_base_path=api_base_path,
url=url)
class InterfaceModel():
def __init__(self):
LogDefine()
self.http_client = SynchronousHttpClient()
# self.host
# self.port
# self.method
# self.parameters
# self.data
self.verification = []
def define_request_method(self, method, url, parameters=None, data=None):
"""请求模板"""
try:
res = self.http_client.request(method=method,
url=url,
params=parameters,
data=data)
http_code = res.status_code
if http_code == HTTP_CODE_SUCCESS:
logging.info("if code == 200 ,request success!")
print u"返回200，请求成功", res.url
print res.text
return res
else:
logging.error("not return code 200 ,request hava some problem")
print res.url
print u"响应出错 code %s" % http_code
print res.text
except Exception, e:
logging.info(u"请求出问题了 %s ", e)
print e
def from_resource_listing(cls,
resource_listing,
http_client=None,
api_base_path=None,
url=None):
"""
Build a :class:`SwaggerClient` from swagger api docs
:param resource_listing: a dict with a list of api definitions
:param http_client: an HTTP client used to perform requests
:type http_client: :class:`swaggerpy.http_client.HttpClient`
:param api_base_path: a url, override the path used to make api requests
:type api_base_path: str
:param url: the url used to retrieve the resource listing
:type url: str
"""
url = url or resource_listing.get(u'url')
log.debug(u"Using resources from %s" % url)
if url:
url_base = "{uri.scheme}://{uri.netloc}".format(uri=urlparse(url))
else:
url_base = None
resources = build_resources_from_spec(
http_client or SynchronousHttpClient(),
map(append_name_to_api, resource_listing['apis']), api_base_path,
url_base)
return cls(url, resources)
def test_headers_present_when_loading_resource_through_Synchronous(self):
self.response['apis'] = []
self.register_urls()
sync_http_client = SynchronousHttpClient(headers={'foo': 'bar'})
SwaggerClient(u'http://localhost/api-docs',
http_client=sync_http_client)
self.assertEqual('bar', httpretty.last_request().headers['foo'])
def __init__(self,
url_or_resource,
http_client=None,
extra_processors=None):
if not http_client:
http_client = SynchronousHttpClient()
self.http_client = http_client
processors = [WebsocketProcessor(), ClientProcessor()]
if extra_processors is not None:
processors.extend(extra_processors)
loader = swaggerpy.Loader(http_client, processors)
if isinstance(url_or_resource, basestring):
log.debug("Loading from %s" % url_or_resource)
self.api_docs = loader.load_resource_listing(url_or_resource)
else:
log.debug("Loading from %s" % url_or_resource.get('basePath'))
self.api_docs = url_or_resource
loader.process_resource_listing(self.api_docs)
self.resources = {
resource['name']: Resource(resource, http_client)
for resource in self.api_docs['apis']
}
def from_url(
cls,
url,
http_client=None,
api_base_path=None,
api_doc_request_headers=None):
"""
Build a :class:`SwaggerClient` from a url to api docs describing the
api.
:param url: url pointing at the swagger api docs
:type url: str
:param http_client: an HTTP client used to perform requests
:type http_client: :class:`swaggerpy.http_client.HttpClient`
:param api_base_path: a url, override the path used to make api requests
:type api_base_path: str
:param api_doc_request_headers: Headers to pass with api docs requests
:type api_doc_request_headers: dict
"""
log.debug(u"Loading from %s" % url)
http_client = http_client or SynchronousHttpClient()
# TODO: better way to customize the request for api-docs, so we don't
# have to add new kwargs for everything
loader = Loader(
http_client,
api_doc_request_headers=api_doc_request_headers)
return cls.from_resource_listing(
loader.load_resource_listing(url),
http_client=http_client,
api_base_path=api_base_path,
url=url)
def test_api_key(self):
httpretty.register_uri(httpretty.GET,
"http://swagger.py/client-test",
body='expected')
uut = SynchronousHttpClient()
uut.set_api_key("swagger.py", 'abc123', param_name='test')
resp = uut.request('GET',
"http://swagger.py/client-test",
params={'foo': 'bar'})
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({
'foo': ['bar'],
'test': ['abc123']
},
httpretty.last_request().querystring)
def test_headers(self):
self.uut = SwaggerClient(self.resource_listing,
SynchronousHttpClient(headers={'foo': 'bar'}))
httpretty.register_uri(httpretty.GET,
"http://swagger.py/swagger-test/pet",
body='[]')
self.uut.pet.listPets().result()
self.assertEqual('bar', httpretty.last_request().headers['foo'])
def test_real_post(self):
httpretty.register_uri(httpretty.POST,
"http://swagger.py/client-test",
body='expected',
content_type='text/json')
client = SynchronousHttpClient()
params = self._default_params()
params['data'] = {'foo': 'bar'}
params['method'] = 'POST'
resp = client.start_request(params).wait()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual('application/x-www-form-urlencoded',
httpretty.last_request().headers['content-type'])
self.assertEqual("foo=bar", httpretty.last_request().body)
def test_auth_leak(self):
httpretty.register_uri(httpretty.GET,
"http://hackerz.py",
body='expected')
client = SynchronousHttpClient()
client.set_basic_auth("swagger.py", 'unit', 'peekaboo')
params = self._default_params()
params['params'] = {'foo': 'bar'}
params['url'] = 'http://hackerz.py'
resp = client.start_request(params).wait()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertTrue(
httpretty.last_request().headers.get('Authorization') is None)
def test_api_key(self):
httpretty.register_uri(httpretty.GET,
"http://swagger.py/client-test",
body='expected')
client = SynchronousHttpClient()
client.set_api_key("swagger.py", 'abc123', param_name='test')
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = client.start_request(params).wait()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({
'foo': ['bar'],
'test': ['abc123']
},
httpretty.last_request().querystring)
def resource(self, auth_type, *args):
args_values = [getattr(self, arg) for arg in args]
if all(args_values):
http_client = SynchronousHttpClient(verify=self.verify)
auth = getattr(http_client, 'set_{}'.format(auth_type))
# auth method will be one of: set_basic_auth, set_token, set_jwt depending on params passed to
# constructor.
auth(*args_values)
return SwaggerClient(self.resources,
http_client=http_client,
extra_processors=[AgaveProcessor()])
def __init__(self,
url_or_resource,
http_client=None,
api_base_path=None,
raise_with=None):
if not http_client:
http_client = SynchronousHttpClient()
# Wrap http client's errors with raise_with
http_client.raise_with = raise_with
self._http_client = http_client
# Load Swagger APIs always synchronously
loader = Loader(SynchronousHttpClient(headers=http_client._headers),
[ClientProcessor()])
forced_api_base_path = api_base_path is not None
# url_or_resource can be url of type str,
# OR a dict of resource itself.
if isinstance(url_or_resource, (str, unicode)):
log.debug(u"Loading from %s" % url_or_resource)
self._api_docs = loader.load_resource_listing(url_or_resource)
parsed_uri = urlparse(url_or_resource)
if not api_base_path:
api_base_path = "{uri.scheme}://{uri.netloc}".format(
uri=parsed_uri)
else:
log.debug(u"Loading from %s" % url_or_resource.get(u'url'))
self._api_docs = url_or_resource
loader.process_resource_listing(self._api_docs)
if not api_base_path:
api_base_path = url_or_resource.get(u'url')
self._resources = {}
for resource in self._api_docs[u'apis']:
if forced_api_base_path and 'api_declaration' in resource:
resource['api_declaration']['basePath'] = api_base_path
self._resources[resource[u'name']] = Resource(
resource, http_client, api_base_path)
setattr(self, resource['name'],
self._get_resource(resource[u'name']))
def load_url(url, http_client=None, **kwargs):
"""Loads a resource listing.
:param resource_listing_url: URL for a resource listing.
:param http_client: HTTP client interface.
:param base_url: Optional URL to be the base URL for finding API
declarations. If not specified, 'basePath' from the
resource listing is used.
:return: Processed object model from
:raise: IOError, URLError: On error reading api-docs.
"""
http_client = http_client or SynchronousHttpClient()
return load_resource_listing(url, http_client, **kwargs)
def __init__(self, url_or_resource, http_client=None,
api_base_path=None, raise_with=None):
if not http_client:
http_client = SynchronousHttpClient()
# Wrap http client's errors with raise_with
http_client.raise_with = raise_with
self._http_client = http_client
# Load Swagger APIs always synchronously
loader = Loader(
SynchronousHttpClient(headers=http_client._headers),
[ClientProcessor()])
forced_api_base_path = api_base_path is not None
# url_or_resource can be url of type str,
# OR a dict of resource itself.
if isinstance(url_or_resource, (str, unicode)):
log.debug(u"Loading from %s" % url_or_resource)
self._api_docs = loader.load_resource_listing(url_or_resource)
parsed_uri = urlparse(url_or_resource)
if not api_base_path:
api_base_path = "{uri.scheme}://{uri.netloc}".format(
uri=parsed_uri)
else:
log.debug(u"Loading from %s" % url_or_resource.get(u'url'))
self._api_docs = url_or_resource
loader.process_resource_listing(self._api_docs)
if not api_base_path:
api_base_path = url_or_resource.get(u'url')
self._resources = {}
for resource in self._api_docs[u'apis']:
if forced_api_base_path and 'api_declaration' in resource:
resource['api_declaration']['basePath'] = api_base_path
self._resources[resource[u'name']] = Resource(
resource, http_client, api_base_path)
setattr(self, resource['name'],
self._get_resource(resource[u'name']))
def load_json(resource_listing, http_client=None, processors=None):
"""Process a resource listing that has already been parsed.
:param resource_listing: Parsed resource listing.
:type resource_listing: dict
:param http_client:
:param processors:
:return: Processed resource listing.
"""
if http_client is None:
http_client = SynchronousHttpClient()
loader = Loader(http_client=http_client, processors=processors)
loader.process_resource_listing(resource_listing)
return resource_listing
def __init__(self, url_or_resource, http_client=None):
if not http_client:
http_client = SynchronousHttpClient()
self.http_client = http_client
loader = Loader(http_client, [WebsocketProcessor(), ClientProcessor()])
if isinstance(url_or_resource, str):
log.debug("Loading from %s" % url_or_resource)
self.api_docs = loader.load_resource_listing(url_or_resource)
else:
log.debug("Loading from %s" % url_or_resource.get('basePath'))
self.api_docs = url_or_resource
loader.process_resource_listing(self.api_docs)
self.resources = {
resource['name']: Resource(resource, http_client)
for resource in self.api_docs['apis']
}
def load_url(resource_listing_url, http_client=None, processors=None,
base_url=None):
"""Loads a resource listing, applying the given processors.
:param resource_listing_url: URL for a resource listing.
:param http_client: HTTP client interface.
:param processors: List of SwaggerProcessors to apply to the resulting
resource.
:param base_url: Optional URL to be the base URL for finding API
declarations. If not specified, 'basePath' from the
resource listing is used.
:return: Processed object model from
:raise: IOError, URLError: On error reading api-docs.
"""
if http_client is None:
http_client = SynchronousHttpClient()
loader = Loader(http_client=http_client, processors=processors)
return loader.load_resource_listing(
resource_listing_url, base_url=base_url)
#!/usr/bin/env python
import json
from swaggerpy.client import SwaggerClient
from swaggerpy.http_client import SynchronousHttpClient
http_client = SynchronousHttpClient()
bitMEX = SwaggerClient(
"https://www.bitmex.com/api/explorer/resources",
http_client=http_client)
res = bitMEX.trade.trade_getRecent({symbol: 'XBTP14', count: 40})
print(res)