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_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.from_url(u'http://localhost/api-docs').api_test
self.assertRaises(TypeError, resource.testHTTP().result)
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.from_url(
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_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.from_url(
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_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.from_url(u'http://localhost/api-docs').api_test
resource.testHTTP().result(allow_null=True)
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.from_url(
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_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_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.from_url(
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(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.from_url(
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_if_ref_but_no_type_in_property(self):
self.response["models"]["User"]["properties"]["school"] = {
"$ref": "School"}
self.register_urls()
resource = SwaggerClient.from_url(u'http://localhost/api-docs').api_test
self.assertTrue(
'school' in
resource.testHTTP._models['User']().__dict__)
def test_error_on_missing_type_inside_nested_complex_type_1(self):
self.register_urls()
self.sample_model["schools"][0] = {} # Omit 'name'
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
self.assertRaises(AssertionError, SwaggerClient.from_url(
u'http://localhost/api-docs').api_test.testHTTP().result)
def test_error_on_wrong_type_inside_complex_type(self):
self.register_urls()
self.sample_model["id"] = "Not Integer"
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
self.assertRaises(TypeError, SwaggerClient.from_url(
u'http://localhost/api-docs').api_test.testHTTP().result)
def test_error_on_missing_required_type_instead_of_complex_type(self):
self.register_urls()
self.sample_model.pop("id")
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
self.assertRaises(AssertionError, SwaggerClient.from_url(
u'http://localhost/api-docs').api_test.testHTTP().result)
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_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.from_url(u'http://localhost/api-docs').api_test
resp = resource.testHTTP().result(allow_null=True)
self.assertTrue(isinstance(resp, resource.testHTTP._models['User']))
def test_success_on_extra_field_in_complex_type(self):
self.register_urls()
self.sample_model["extra"] = 42
httpretty.register_uri(
httpretty.GET, "http://localhost/test_http",
body=json.dumps(self.sample_model))
result = SwaggerClient.from_url(
u'http://localhost/api-docs').api_test.testHTTP().result()
self.assertEqual(result._raw["extra"], 42)
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.from_url(
u'http://localhost/api-docs').api_test
self.assertRaises(HTTPError,
resource.testHTTP(test_param="foo").result)
def test_types_of_model_attributes(self):
self.register_urls()
resource = SwaggerClient.from_url(u'http://localhost/api-docs').api_test
models = resource.testHTTP._models
user = models['User']()
school = models['School']()
self.assertTrue(isinstance(user.id, long))
self.assertTrue(isinstance(user.schools, list))
self.assertTrue(isinstance(school.name, str))
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.from_url(
u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual([], resp)
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.from_url(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_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.from_url(
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.from_url(
u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual({"some_foo": "bar"}, resp)
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.from_url(
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.from_url(
u'http://localhost/api-docs').api_test
future = resource.testHTTP(test_param="foo")
self.assertRaises(TypeError, future)
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.from_url(
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_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.from_url(
u'http://localhost/api-docs').api_test
resp = resource.testHTTP(test_param="foo").result()
self.assertEqual(resp, datetime.date(2014, 6, 10))
def test_remove_null_values_when_convert_to_flat_dict(self):
self.register_urls()
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
models = resource.testHTTP._models
User = models['User']
School = models['School']
user = User(schools=[School(name='a'), None])
self.assertEqual(None, user.schools[1])
self.assertEqual([{'name': 'a'}], user._flat_dict()['schools'])
def test_setattrs_on_client_and_model(self):
self.register_urls()
resource = SwaggerClient.from_url(u'http://localhost/api-docs').api_test
models = resource.testHTTP._models
self.assertEqual(set(models), set(['User', 'School']))
self.assertEqual(['id'], models['User']._required)
self.assertEqual({
'schools': 'array:School',
'id': 'integer:int64'
}, models['User']._swagger_types)
self.assertEqual(['name'], models['School']._required)
self.assertEqual({'name': 'string'}, models['School']._swagger_types)
def test_error_on_get_with_wrong_type_in_query(self):
query_parameter = {
"paramType": "query",
"name": "test_param",
"type": "integer"
}
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter]
self.register_urls()
resource = SwaggerClient.from_url(
u'http://localhost/api-docs').api_test
self.assertRaises(TypeError, resource.testHTTP,
test_param="NOT_INTEGER")
def test_error_on_get_with_array_type_in_query(self):
query_parameter = {
"paramType": "query",
"name": "test_param",
"type": "array",
"items": {"type": "string"}
}
self.response["apis"][0]["operations"][0]["parameters"] = [
query_parameter]
self.register_urls()
resource = SwaggerClient.from_url(
u'http://localhost/api-docs').api_test
self.assertRaises(TypeError, resource.testHTTP, test_param=["A", "B"])
