def test_error_if_response_is_null_and_allow_null_not_given(self):
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http",
body=json.dumps(None))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
self.assertRaises(TypeError, resource.testHTTP().result)
def test_success_on_passing_datetime_in_param(self):
query_parameter = {
"paramType": "query",
"name": "test_param",
"type": "string",
"format": "date-time"
}
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter
]
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http",
body='')
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
some_datetime = datetime.datetime(2014,
6,
10,
23,
49,
54,
728000,
tzinfo=tzutc())
resource.testHTTP(test_param=some_datetime).result()
self.assertEqual(['2014-06-10 23:49:54.728000 00:00'],
httpretty.last_request().querystring['test_param'])
def test_success_on_post_with_form_params(self):
form_parameter_1 = {
"paramType": "form",
"name": "param_id",
"type": "integer"
}
form_parameter_2 = {
"paramType": "form",
"name": "param_name",
"type": "string"
}
self.response["apis"][0]["operations"][0]["method"] = "POST"
self.response["apis"][0]["operations"][0]["parameters"] = [
form_parameter_1, form_parameter_2
]
self.register_urls()
httpretty.register_uri(httpretty.POST,
"http://localhost/test_http?",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP(param_id=42, param_name='str').result()
self.assertEqual('application/x-www-form-urlencoded',
httpretty.last_request().headers['content-type'])
self.assertEqual({
'param_name': ['str'],
'param_id': ['42']
}, urlparse.parse_qs(httpretty.last_request().body))
def test_success_on_get_with_array_in_path_and_query_params(self):
query_parameter = {
"paramType": "query",
"name": "test_params",
"type": "string"
}
path_parameter = {
"paramType": "path",
"name": "param_ids",
"type": "array",
"items": {
"type": "integer"
}
}
self.response["apis"][0]["path"] = "/params/{param_ids}/test_http"
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter, path_parameter
]
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/params/40,41,42/test_http?",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_params=["foo", "bar"],
param_ids=[40, 41, 42]).result()
self.assertEqual(["foo", "bar"],
httpretty.last_request().querystring['test_params'])
self.assertEqual(None, resp)
def test_success_on_post_with_form_params_with_files(self):
form_parameter_1 = {
"paramType": "form",
"name": "param_id",
"type": "integer"
}
form_parameter_2 = {
"paramType": "form",
"name": "file_name",
"type": "File"
}
self.response["apis"][0]["operations"][0]["method"] = "POST"
self.response["apis"][0]["operations"][0]["parameters"] = [
form_parameter_1, form_parameter_2
]
self.register_urls()
httpretty.register_uri(httpretty.POST,
"http://localhost/test_http?",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
with open("test-data/1.2/simple/simple.json", "rb") as f:
resource.testHTTP(param_id=42, file_name=f).result()
content_type = httpretty.last_request().headers['content-type']
self.assertTrue(content_type.startswith('multipart/form-data'))
self.assertTrue("42" in httpretty.last_request().body)
# instead of asserting the contents, just assert filename is there
self.assertTrue("simple.json" in httpretty.last_request().body)
def test_success_on_post_with_path_query_and_body_params(self):
query_parameter = self.parameter
path_parameter = {
"paramType": "path",
"name": "param_id",
"type": "string"
}
body_parameter = {
"paramType": "body",
"name": "body",
"type": "string"
}
self.response["apis"][0]["path"] = "/params/{param_id}/test_http"
operations = self.response["apis"][0]["operations"]
operations[0]["method"] = "POST"
operations[0]["parameters"] = [query_parameter,
path_parameter,
body_parameter]
self.register_urls()
httpretty.register_uri(
httpretty.POST,
"http://localhost/params/42/test_http?test_param=foo", body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo", param_id="42",
body="some_test").result()
self.assertEqual('some_test', httpretty.last_request().body)
self.assertEqual(None, resp)
def test_error_if_response_is_null_and_allow_null_not_given(self):
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(None))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
self.assertRaises(TypeError, resource.testHTTP().result)
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 test_success_on_post_with_path_query_and_body_params(self):
query_parameter = self.parameter
path_parameter = {
"paramType": "path",
"name": "param_id",
"type": "string"
}
body_parameter = {
"paramType": "body",
"name": "body",
"type": "string"
}
self.response["apis"][0]["path"] = "/params/{param_id}/test_http"
operations = self.response["apis"][0]["operations"]
operations[0]["method"] = "POST"
operations[0]["parameters"] = [
query_parameter, path_parameter, body_parameter
]
self.register_urls()
httpretty.register_uri(
httpretty.POST,
"http://localhost/params/42/test_http?test_param=foo",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo",
param_id="42",
body="some_test").result()
self.assertEqual('some_test', httpretty.last_request().body)
self.assertEqual(None, resp)
def test_success_on_post_with_form_params_with_files(self):
form_parameter_1 = {
"paramType": "form",
"name": "param_id",
"type": "integer"
}
form_parameter_2 = {
"paramType": "form",
"name": "file_name",
"type": "File"
}
self.response["apis"][0]["operations"][0]["method"] = "POST"
self.response["apis"][0]["operations"][0]["parameters"] = [
form_parameter_1, form_parameter_2]
self.register_urls()
httpretty.register_uri(
httpretty.POST, "http://localhost/test_http?", body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
with open("test-data/1.2/simple/simple.json", "rb") as f:
resource.testHTTP(param_id=42, file_name=f).result()
content_type = httpretty.last_request().headers['content-type']
self.assertTrue(content_type.startswith('multipart/form-data'))
self.assertTrue("42" in httpretty.last_request().body)
# instead of asserting the contents, just assert filename is there
self.assertTrue("simple.json" in httpretty.last_request().body)
def test_alllow_null_as_response_if_allow_null_is_given(self):
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(None))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP().result(allow_null=True)
def test_alllow_null_as_response_if_allow_null_is_given(self):
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http",
body=json.dumps(None))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP().result(allow_null=True)
def test_correct_route_with_basePath_as_slash(self):
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?query=foo",
body='[]')
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual([], resp)
def test_none_value_response_if_response_not_OK(self):
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?test_param=foo",
status=500)
resource = SwaggerClient(u'http://localhost/api-docs').api_test
self.assertRaises(HTTPError,
resource.testHTTP(test_param="foo").result)
def test_none_value_response_if_response_not_OK(self):
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
status=500)
resource = SwaggerClient(u'http://localhost/api-docs').api_test
self.assertRaises(HTTPError,
resource.testHTTP(test_param="foo").result)
def test_correct_route_with_basePath_as_slash(self):
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?query=foo",
body='[]')
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual([], resp)
class WsClient(SharedExtension, ProviderCollector):
client = None
app_name = None
def __init__(self, app_name=None, **kwargs):
if app_name:
self.app_name = app_name
super(WsClient, self).__init__(**kwargs)
def setup(self):
if not self.app_name:
self.app_name = self.container.config.get('ASTERISK_ARI_APP')
self.http_uri = self.container.config['ASTERISK_HTTP_URI']
self.ari_url = urljoin(self.http_uri, 'ari/api-docs/resources.json')
self.ari_user = self.container.config['ASTERISK_ARI_USER']
self.ari_pass = self.container.config['ASTERISK_ARI_PASS']
# No sense in starting before setup is done
while True:
try:
self.setup_client()
break
except Exception as e:
logger.error('ARI WS setup error: %s', e)
eventlet.sleep(1)
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 start(self):
self.container.spawn_managed_thread(self.run)
def stop(self):
if self.client:
logger.info('Closing ARI client...')
self.client.close()
super(WsClient, self).stop()
def run(self):
while True:
try:
ws = self.client.events.eventWebsocket(app=self.app_name)
for msg_str in iter(lambda: ws.recv(), None):
msg_json = json.loads(msg_str)
self.handle_event(msg_json)
except Exception as e:
error = e.message if hasattr(e, 'message') else str(e)
logger.error('ARI connection error (%s), reconnect...', error)
eventlet.sleep(1)
continue
def handle_event(self, msg):
for provider in self._providers:
provider.handle_event(msg)
def test_api_base_path_if_passed_is_always_used_as_base_path(self):
httpretty.register_uri(httpretty.GET, "http://foo/test_http?", body='')
self.response["basePath"] = "http://localhost"
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs',
api_base_path='http://foo').api_test
resource.testHTTP(test_param="foo").result()
self.assertEqual(["foo"],
httpretty.last_request().querystring['test_param'])
def test_success_on_returning_anything_for_type_void(self):
# default operation type is void
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?test_param=foo",
body='{"some_foo": "bar"}')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual({"some_foo": "bar"}, resp)
def test_success_on_passing_default_value_if_param_not_passed(self):
self.parameter['defaultValue'] = 'testString'
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?", body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP().result()
self.assertEqual(['testString'],
httpretty.last_request().querystring['test_param'])
def test_success_on_returning_anything_for_type_void(self):
# default operation type is void
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
body='{"some_foo": "bar"}')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual({"some_foo": "bar"}, resp)
def test_alllow_null_in_response_body_if_allow_null_is_given(self):
self.register_urls()
self.sample_model["schools"].append(None)
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http",
body=json.dumps(self.sample_model))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP().result(allow_null=True)
self.assertTrue(isinstance(resp, resource.models.User))
def test_alllow_null_in_response_body_if_allow_null_is_given(self):
self.register_urls()
self.sample_model["schools"].append(None)
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP().result(allow_null=True)
self.assertTrue(isinstance(resp, resource.models.User))
def test_success_on_date_type(self):
self.response["apis"][0]["operations"][0]["type"] = "string"
self.response["apis"][0]["operations"][0]["format"] = "date"
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
body='"2014-06-10"')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual(resp, datetime.date(2014, 6, 10))
def test_error_on_incorrect_array_type_returned(self):
self.response["apis"][0]["operations"][0]["type"] = "array"
self.response["apis"][0]["operations"][0]["items"] = {"type": "string"}
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?test_param=foo",
body="123.32")
resource = SwaggerClient(u'http://localhost/api-docs').api_test
future = resource.testHTTP(test_param="foo")
self.assertRaises(TypeError, future)
def test_api_base_path_if_passed_is_always_used_as_base_path(self):
httpretty.register_uri(
httpretty.GET, "http://foo/test_http?", body='')
self.response["basePath"] = "http://localhost"
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs',
api_base_path='http://foo').api_test
resource.testHTTP(test_param="foo").result()
self.assertEqual(["foo"],
httpretty.last_request().querystring['test_param'])
def test_append_base_path_if_base_path_isnt_absolute(self):
self.response["basePath"] = "/append"
httpretty.register_uri(
httpretty.GET, "http://localhost/append/test_http?",
body='[]')
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP(test_param="foo").result()
self.assertEqual(["foo"],
httpretty.last_request().querystring['test_param'])
def test_append_base_path_if_base_path_isnt_absolute(self):
self.response["basePath"] = "/append"
httpretty.register_uri(httpretty.GET,
"http://localhost/append/test_http?",
body='[]')
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP(test_param="foo").result()
self.assertEqual(["foo"],
httpretty.last_request().querystring['test_param'])
def test_success_on_returning_raw_response_if_given_in_parameter(self):
self.response["apis"][0]["operations"][0]["type"] = "array"
self.response["apis"][0]["operations"][0]["items"] = {"type": "string"}
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?",
body='{"some_foo": "bar"}')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result(raw_response=True)
self.assertEqual({"some_foo": "bar"}, resp)
def test_error_on_incorrect_array_type_returned(self):
self.response["apis"][0]["operations"][0]["type"] = "array"
self.response["apis"][0]["operations"][0]["items"] = {"type": "string"}
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
body="123.32")
resource = SwaggerClient(u'http://localhost/api-docs').api_test
future = resource.testHTTP(test_param="foo")
self.assertRaises(TypeError, future)
def test_success_on_passing_default_value_if_param_not_passed(self):
self.parameter['defaultValue'] = 'testString'
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP().result()
self.assertEqual(['testString'],
httpretty.last_request().querystring['test_param'])
def test_headers_sendable_with_api_doc_request(self):
self.register_urls()
SwaggerClient.from_url(
u'http://localhost/api-docs',
api_doc_request_headers={'foot': 'bart'},
)
self.assertEqual(
'bart',
httpretty.last_request().headers.get('foot'),
)
def test_success_on_returning_raw_response_if_given_in_parameter(self):
self.response["apis"][0]["operations"][0]["type"] = "array"
self.response["apis"][0]["operations"][0]["items"] = {
"type": "string"}
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?",
body='{"some_foo": "bar"}')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result(raw_response=True)
self.assertEqual({"some_foo": "bar"}, resp)
def test_success_on_complex_operation_response_type(self):
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP().result()
User = resource.models.User
School = resource.models.School
self.assertTrue(isinstance(resp, User))
[self.assertTrue(isinstance(x, School)) for x in resp.schools]
self.assertEqual(User(id=42, schools=[School(
name="School1"), School(name="School2")]), resp)
def test_success_on_correct_array_type_returned_by_operation(self):
self.response["apis"][0]["operations"][0]["type"] = "array"
self.response["apis"][0]["operations"][0]["items"] = {
"type": "string",
"format": "date-time"
}
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?test_param=foo",
body='["2014-06-10T23:49:54.728+0000"]')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual(
resp, [datetime(2014, 6, 10, 23, 49, 54, 728000, tzinfo=tzutc())])
def test_success_on_correct_array_type_returned_by_operation(self):
self.response["apis"][0]["operations"][0]["type"] = "array"
self.response["apis"][0]["operations"][0]["items"] = {
"type": "string",
"format": "date-time"
}
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
body='["2014-06-10T23:49:54.728+0000"]')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual(resp, [datetime(
2014, 6, 10, 23, 49, 54, 728000, tzinfo=tzutc())])
def test_success_on_complex_operation_response_type(self):
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http",
body=json.dumps(self.sample_model))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP().result()
User = resource.models.User
School = resource.models.School
self.assertTrue(isinstance(resp, User))
[self.assertTrue(isinstance(x, School)) for x in resp.schools]
self.assertEqual(
User(id=42,
schools=[School(name="School1"),
School(name="School2")]), resp)
def test_success_if_ref_but_no_type_in_property(self):
self.response["models"]["User"]["properties"]["school"] = {
"$ref": "School"
}
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
self.assertTrue('school' in resource.models.User().__dict__)
def test_headers_present_when_loading_resource_through_Asynchronous(self):
self.response['apis'] = []
self.register_urls()
async_http_client = AsynchronousHttpClient(headers={'foo': 'bar'})
SwaggerClient(u'http://localhost/api-docs',
http_client=async_http_client)
self.assertEqual('bar', httpretty.last_request().headers['foo'])
def test_error_on_incorrect_primitive_types_returned(self):
types = {
'string': '42',
'integer': '3.4',
'number': '42',
'boolean': '"NOT_BOOL"'
}
for type_ in types:
self.response["apis"][0]["operations"][0]["type"] = type_
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
body=types[type_])
resource = SwaggerClient(u'http://localhost/api-docs').api_test
future = resource.testHTTP(test_param="foo")
self.assertRaises(TypeError, future)
def test_raise_with_wrapper(self):
class MyException(Exception):
pass
self.uut = SwaggerClient(self.resource_listing, raise_with=MyException)
httpretty.register_uri(
httpretty.GET, "http://swagger.py/swagger-test/pet", status=500)
self.assertRaises(MyException, self.uut.pet.listPets().result)
def test_error_on_incorrect_primitive_types_returned(self):
types = {
'string': '42',
'integer': '3.4',
'number': '42',
'boolean': '"NOT_BOOL"'
}
for type_ in types:
self.response["apis"][0]["operations"][0]["type"] = type_
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?test_param=foo",
body=types[type_])
resource = SwaggerClient(u'http://localhost/api-docs').api_test
future = resource.testHTTP(test_param="foo")
self.assertRaises(TypeError, future)
def test_error_on_wrong_type_instead_of_complex_type(self):
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body='"NOT_COMPLEX_TYPE"')
self.assertRaises(TypeError, SwaggerClient.from_url(
u'http://localhost/api-docs').api_test.testHTTP().result)
def test_success_on_correct_primitive_types_returned_by_operation(self):
types = {
'void': '[]',
'string': '"test"',
'integer': '42',
'number': '3.4',
'boolean': 'true'
}
for type_ in types:
self.response["apis"][0]["operations"][0]["type"] = type_
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http?test_param=foo",
body=types[type_])
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual(json.loads(types[type_]), resp)
def test_success_with_api_call(self):
self.register_urls()
httpretty.register_uri(
httpretty.GET,
"http://localhost/api-docs/api",
body='{"swaggerVersion": "1.2", "basePath": "/", "apis":[]}')
self.client = SwaggerClient.from_url(u'http://localhost/api-docs')
self.assertNotEqual(None, self.client)
def test_error_if_response_body_has_null_and_allow_null_not_given(self):
self.register_urls()
self.sample_model["schools"].append(None)
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
resource = SwaggerClient.from_url(u'http://localhost/api-docs').api_test
self.assertRaises(TypeError, resource.testHTTP().result)
def test_success_on_correct_primitive_types_returned_by_operation(self):
types = {
'void': '[]',
'string': '"test"',
'integer': '42',
'number': '3.4',
'boolean': 'true'
}
for type_ in types:
self.response["apis"][0]["operations"][0]["type"] = type_
self.register_urls()
httpretty.register_uri(httpretty.GET,
"http://localhost/test_http?test_param=foo",
body=types[type_])
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual(json.loads(types[type_]), resp)
def test_removal_of_none_attributes_from_param_body_model(self):
query_parameter = {
"paramType": "body",
"name": "body",
"type": "User",
}
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter]
self.response["models"]["User"]["properties"]["school"] = {
"$ref": "School"}
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
user = resource.models.User(id=42)
future = resource.testHTTP(body=user)
# Removed the 'school': None - key, value pair from dict
self.assertEqual(json.dumps({'id': 42, 'schools': []}),
future._http_client.request_params['data'])
def test_success_model_in_param_body_converts_to_dict(self):
query_parameter = {
"paramType": "body",
"name": "body",
"type": "User",
}
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter]
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
School = resource.models.School
# Also test all None items are removed from array list
user = resource.models.User(id=42, schools=[School(name='s1'), None])
future = resource.testHTTP(body=user)
self.assertEqual(json.dumps({'id': 42,
'schools': [{'name': 's1'}]}),
future._http_client.request_params['data'])
def test_success_on_passing_datetime_in_param(self):
query_parameter = {
"paramType": "query",
"name": "test_param",
"type": "string",
"format": "date-time"
}
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter]
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http", body='')
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
some_date = datetime(2014, 6, 10, 23, 49, 54, 728000, tzinfo=tzutc())
resource.testHTTP(test_param=some_date).result()
self.assertEqual(['2014-06-10 23:49:54.728000 00:00'],
httpretty.last_request().querystring['test_param'])
def test_success_on_get_with_path_and_query_params(self):
query_parameter = self.parameter
path_parameter = {
"paramType": "path",
"name": "param_id",
"type": "string"
}
self.response["apis"][0]["path"] = "/params/{param_id}/test_http"
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter, path_parameter]
self.register_urls()
httpretty.register_uri(
httpretty.GET,
"http://localhost/params/42/test_http?test_param=foo",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo", param_id="42").result()
self.assertEqual(None, resp)
def test_content_type_as_json_if_complex_type_in_body(self):
query_parameter = {
"paramType": "body",
"name": "body",
"type": "School",
}
school = {"name": "temp"}
self.response["apis"][0]["operations"][0]["type"] = "School"
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter]
self.register_urls()
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(school))
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP(body=school).result()
self.assertEqual("application/json", httpretty.last_request().headers[
'content-type'])
def test_success_on_post_with_array_in_body_params(self):
body_parameter = {
"paramType": "body",
"name": "body",
"type": "array",
"items": {
"type": "string"
}
}
operations = self.response["apis"][0]["operations"]
operations[0]["parameters"] = [body_parameter]
operations[0]["method"] = "POST"
self.register_urls()
httpretty.register_uri(httpretty.POST, "http://localhost/test_http",
body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(body=["a", "b", "c"]).result()
self.assertEqual(["a", "b", "c"],
json.loads(httpretty.last_request().body))
self.assertEqual(None, resp)
def test_success_on_post_with_form_params(self):
form_parameter_1 = {
"paramType": "form",
"name": "param_id",
"type": "integer"
}
form_parameter_2 = {
"paramType": "form",
"name": "param_name",
"type": "string"
}
self.response["apis"][0]["operations"][0]["method"] = "POST"
self.response["apis"][0]["operations"][0]["parameters"] = [
form_parameter_1, form_parameter_2]
self.register_urls()
httpretty.register_uri(
httpretty.POST, "http://localhost/test_http?", body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resource.testHTTP(param_id=42, param_name='str').result()
self.assertEqual('application/x-www-form-urlencoded',
httpretty.last_request().headers['content-type'])
self.assertEqual({'param_name': ['str'], 'param_id': ['42']},
urlparse.parse_qs(httpretty.last_request().body))
def test_success_on_get_with_array_in_path_and_query_params(self):
query_parameter = {
"paramType": "query",
"name": "test_params",
"type": "string"}
path_parameter = {
"paramType": "path",
"name": "param_ids",
"type": "array",
"items": {
"type": "integer"}}
self.response["apis"][0]["path"] = "/params/{param_ids}/test_http"
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter, path_parameter]
self.register_urls()
httpretty.register_uri(
httpretty.GET,
"http://localhost/params/40,41,42/test_http?", body='')
resource = SwaggerClient(u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_params=["foo", "bar"],
param_ids=[40, 41, 42]).result()
self.assertEqual(["foo", "bar"],
httpretty.last_request().querystring['test_params'])
self.assertEqual(None, resp)
def test_no_error_on_not_passing_non_required_param_in_query(self):
self.register_urls()
resource = SwaggerClient(u'http://localhost/api-docs').api_test
# No error should be raised on not passing test_param (not required)
resource.testHTTP()
def on_resources_finished(result):
resource_file = 'file://{}/resources.json'.format(self._temp_dir)
self._swagger_client = SwaggerClient(resource_file)
print self._swagger_client
shutil.rmtree(self._temp_dir)
print "NIFTY"
class AsyncSwaggerClient(object):
def __init__(self, base_url):
self._swagger_client = None
self._base_url = base_url
self._temp_dir = tempfile.mkdtemp()
os.mkdir(os.path.join(self._temp_dir, 'api-docs'))
def load_resources(self, http_client):
"""Load the resources for this Swagger client
This routine will load the resources located at base_url. It does this
in the following way:
(1) Retrieve resources.json, saving it to a temporary file
(2) For each API in resources.json, retrieve the API and save it to a
temporary file.
(3) If all succeed, pass the resource files to the underlying SwaggerPy
client
Args:
http_client: The twisted HTTP client to use to get the resources
Returns:
A twisted.internet.defer.Deferred that is called on success or failure
"""
def write_resource_file(json_body):
"""Writes a Swagger resource out to disk
Args:
json_body: The JSON representation of the resource
"""
if 'basePath' in json_body:
json_body['basePath'] = 'file:///{0}'.format(self._temp_dir)
if 'resourcePath' in json_body:
api_file = str(json_body['resourcePath'])
api_file = api_file.replace('{format}', 'json')
api_file.strip('/')
full_path = '{}/{}'.format(self._temp_dir, api_file)
else:
full_path = '{}/{}'.format(self._temp_dir, 'resources.json')
with open(full_path, 'w') as resource_file:
resource_file.write(json.dumps(json_body))
def create_http_failure(url, response):
"""Create a twisted.python.failure.Failure from a bad HTTP response
Args:
url: The url that failed
response: The twisted.web.client.Response object
Returns:
A twisted.python.failure.Failure representing the failure
"""
msg = 'While requesting {0}: {1} - {2}'.format(url,
response.code,
response.phrase)
fail = Failure(Exception(msg))
return fail
url = urlparse.urljoin(self._base_url, "ari/api-docs/resources.json")
resource_finished = Deferred()
def on_error(failure):
"""Generic deferred error callback
This ensures that our top most deferred gets called if any nested
deferred errors out
Args:
failure: The twisted.python.failure.Failure object
Returns:
failure
"""
shutil.rmtree(self._temp_dir)
resource_finished.errback(failure)
return failure
def on_resource_finished(response):
"""Success callback for when resources.json is parsed
Args:
response: The twisted.web.client.Response for the HTTP request
Returns:
response if the request was successful
A twisted.python.failure.Failure object if the request failed
"""
if response.code / 100 != 2:
fail = self._create_http_failure(url, response)
resource_finished.errback(fail)
return fail
finished_deferred = Deferred()
def on_resource_body_read(resource_json_body):
"""Success callback for reading the body of resources.json
Args:
resource_json_body: The JSON body of resources.json
Returns:
A twisted.internet.defer.Deferred that is fired when all API
resources are processed on success
A twisted.python.failure.Failure on error
"""
write_resource_file(resource_json_body)
def on_api_finished(response, url):
"""Success callback when an API response is received
Args:
response: The twisted.web.client.Response for the HTTP
request
url: The url for this API request
Returns:
A twisted.internet.defer.Deferred that is fired when the API
body is processed
A twisted.python.failure.Failure on error
"""
if response.code / 100 != 2:
return self._create_http_failure(url, response)
api_finished_deferred = Deferred()
def on_api_body_read(api_json_body):
"""Success callback for reading the body of an API
Args:
api_json_body: The JSON body for the API
Returns:
api_json_body
"""
write_resource_file(api_json_body)
return api_json_body
api_finished_deferred.addCallbacks(on_api_body_read,
on_error)
response.deliverBody(JSONBodyReceiver(api_finished_deferred))
return api_finished_deferred
api_deferreds = []
for api in resource_json_body.get('apis'):
path = api.get('path').replace('{format}', 'json')
api_url = urlparse.urljoin(self._base_url + '/', 'ari')
api_url = urlparse.urljoin(api_url + '/', path.strip('/'))
try:
api_deferred = http_client.request('GET', api_url)
api_deferred.addCallback(on_api_finished, api_url)
api_deferred.addErrback(on_error)
api_deferreds.append(api_deferred)
except Exception as e:
fail = Failure(e)
resource_finished.errback(fail)
return fail
def apis_processed(results):
"""Callback called when all API resources are processed
Args:
results: The list of (success, result) tuples returned from
the API request callbacks
Returns:
results on success
twisted.python.failure.Failure on error
"""
if any([result for result in results if not result[0]]):
msg = "Failed to process all API resources"
fail = Failure(Exception(msg))
finished_deferred.errback(fail)
return fail
resource_finished.callback(None)
return results
apis_finished = DeferredList(api_deferreds)
apis_finished.addCallback(apis_processed)
return apis_finished
finished_deferred.addCallbacks(on_resource_body_read, on_error)
response.deliverBody(JSONBodyReceiver(finished_deferred))
return finished_deferred
http_client.request('GET', url).addCallbacks(on_resource_finished,
on_error)
def on_resources_finished(result):
resource_file = 'file://{}/resources.json'.format(self._temp_dir)
self._swagger_client = SwaggerClient(resource_file)
print self._swagger_client
shutil.rmtree(self._temp_dir)
print "NIFTY"
resource_finished.addCallback(on_resources_finished)
return resource_finished
def __repr__(self):
return self._swagger_client.__repr__()
def __getattr__(self, item):
"""Promote resource objects to be client fields.
:param item: Name of the attribute to get.
:return: Resource object.
"""
return self._swagger_client.__getattr__(item)
def close(self):
"""Close the SwaggerClient, and underlying resources.
"""
self._swagger_client.close()
def get_resource(self, name):
"""Gets a Swagger resource by name.
:param name: Name of the resource to get
:rtype: Resource
:return: Resource, or None if not found.
"""
return self._swagger_client.resources.get(name)
