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_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)