def test_parameter(self):
""" Parameter -> Parameter
"""
# body
o = self.app.root.paths['/api/pet/{petId}'].patch
p = [p for p in o.parameters if getattr(p, 'in') == 'body'][0]
self.assertEqual(getattr(p, 'in'), 'body')
self.assertEqual(p.required, True)
self.assertEqual(getattr(p.schema, '$ref'), _pf('/definitions/pet!##!Pet'))
# form
o = self.app.root.paths['/api/pet/uploadImage'].post
p = [p for p in o.parameters if getattr(p, 'in') == 'formData' and p.type == 'string'][0]
self.assertEqual(p.name, 'additionalMetadata')
self.assertEqual(p.required, False)
# file
o = self.app.root.paths['/api/pet/uploadImage'].post
p = [p for p in o.parameters if getattr(p, 'in') == 'formData' and p.type == 'file'][0]
self.assertEqual(p.name, 'file')
self.assertEqual(p.required, False)
# non-body can't have $ref
try:
App._create_(get_test_data_folder(
version='1.2',
which='upgrade_parameter'
))
except errs.SchemaError as e:
self.failUnlessEqual(e.args, ("Can't have $ref in non-body Parameters",))
else:
self.fail('SchemaError not raised')
def test_dict_getter_v2_0(self):
""" make sure 'DictGetter' works the same as 'LocalGetter'
for Swagger 2.0
"""
#
# loading via DictGetter
#
path = get_test_data_folder(
version='2.0',
which='wordnik'
)
origin_app = App.create(path)
with open(os.path.join(path, 'swagger.json'), 'r') as f:
spec = json.loads(f.read())
getter = DictGetter([path], {
os.path.join(path, 'swagger.json'): spec
})
app = App.load(path, resolver=Resolver(default_getter=getter))
app.prepare()
# make sure it produce the same App in default way
self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump())), [])
#
# loading via wrong path, should be ok when all internal $ref are not absoluted
#
getter = DictGetter([''], {
'': spec
})
app = App.load('', resolver=Resolver(default_getter=getter))
app.prepare()
# make sure it produce the same App in default way
self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump(), exclude=['$ref'])), [])
#
# faking http path
#
getter = DictGetter(['https://petstore.com'], {
'https://petstore.com': spec
})
app = App.load('https://petstore.com', resolver=Resolver(default_getter=getter))
app.prepare()
# make sure it produce the same App in default way
self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump(), exclude=['$ref'])), [])
def test_load(self):
""" make sure the result of yaml and json are identical """
app_json = App.load(get_test_data_folder(
version='2.0',
which='wordnik'
))
app_yaml = App.load(get_test_data_folder(
version='2.0',
which='yaml',
)
)
s = Scanner(app_yaml)
s.scan(route=[YamlFixer()], root=app_yaml.raw, leaves=[Operation])
self.assertEqual((True, ''), app_json.raw.compare(app_yaml.raw))
def test_v2_0(self):
""" convert from 2.0 to 2.0 """
path = get_test_data_folder(version='2.0', which='wordnik')
app = App.create(path)
# load swagger.json into dict
origin = None
with open(os.path.join(path, 'swagger.json')) as r:
origin = json.loads(r.read())
# diff for empty list or dict is allowed
d = app.dump()
self.assertEqual(
sorted(_diff_(origin, d, exclude=['$ref'])),
sorted([('paths/~1pet~1{petId}/get/security/0/api_key', "list",
"NoneType"),
('paths/~1store~1inventory/get/parameters', None, None),
('paths/~1store~1inventory/get/security/0/api_key', "list",
"NoneType"),
('paths/~1user~1logout/get/parameters', None, None)]))
# try to load the dumped dict back, to see if anything wrong
tmp = {'_tmp_': {}}
with SwaggerContext(tmp, '_tmp_') as ctx:
ctx.parse(d)
def __init__(self,
creds=elicit_creds.ElicitCreds(),
api_url=PRODUCTION_URL,
send_opt=dict(verify=True)):
print("Initialize Elicit client library for %s options:" % api_url)
print(send_opt)
if ((not send_opt['verify']) and api_url.startswith("https")):
print('WARNING: not checking SSL')
dont_check_ssl()
self.api_url = api_url
self.swagger_url = self.api_url + '/apidocs/v1/swagger.json'
self.app = App._create_(self.swagger_url)
self.auth = Security(self.app)
self.creds = creds
# init swagger client
self.client = Client(
self.auth, send_opt=send_opt
) # HACK to work around self-signed SSL certs used in development
if (self.app.root.host != self.api_url):
print(
'WARNING: API URL from swagger doesn\'t match this configuration: [%s] vs [%s]'
% (self.api_url, self.app.root.host))
def test_path_item_prepare_with_cycle(self):
app = App.load(
get_test_data_folder(version='2.0',
which=os.path.join('circular', 'path_item')))
# should raise nothing
app.prepare()
def runAction(self, action, **kwargs):
if "config_override" in kwargs:
self.overwriteConfig(kwargs['config_override'])
del (kwargs['config_override'])
factory = Primitive()
factory.register('string', 'int-or-string', self._encode_intOrString)
app = App.load(url=self.swagger, prim=factory)
app.prepare()
client = Client(config=self.config, send_opt=({'verify': False}))
opt = dict(url_netloc=self.config['kubernetes_api_url'][8:])
op = app.op[action]
# bit of a hack - pyswagger can't handle */* currently
if op.consumes[0] == u'*/*':
op.consumes[0] = u'application/json'
a = op(**kwargs)
resp = client.request(a, opt=opt)
return resp
def test_float_dump(self):
""" failed to dump an object with float property
refer to issue: https://github.com/mission-liao/pyswagger/issues/92
"""
app = App.create(get_test_data_folder(version='2.0', which=os.path.join('schema', 'floatDump')))
app.dump() # should not raise exception
def test_path_item(self):
folder = get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'path_item')
)
def _pf(s):
return six.moves.urllib.parse.urlunparse((
'file',
'',
folder,
'',
'',
s))
app = App.create(folder)
s = Scanner(app)
c = CycleDetector()
s.scan(root=app.raw, route=[c])
self.assertEqual(sorted(c.cycles['path_item']), sorted([[
_pf('/paths/~1p1'),
_pf('/paths/~1p2'),
_pf('/paths/~1p3'),
_pf('/paths/~1p4'),
_pf('/paths/~1p1')
]]))
def test_random_name_v2_0(self):
"""
"""
path = get_test_data_folder(version='2.0', which='random_file_name')
path = os.path.join(path, 'test_random.json')
# should not raise ValueError
app = App.create(path)
def test_schema(self):
folder = get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'schema')
)
def _pf(s):
return six.moves.urllib.parse.urlunparse((
'file',
'',
folder,
'',
'',
s))
app = App.load(folder)
app.prepare(strict=False)
s = Scanner(app)
c = CycleDetector()
s.scan(root=app.raw, route=[c])
self.maxDiff = None
self.assertEqual(sorted(c.cycles['schema']), sorted([
[_pf('/definitions/s10'), _pf('/definitions/s11'), _pf('/definitions/s9'), _pf('/definitions/s10')],
[_pf('/definitions/s5'), _pf('/definitions/s5')],
[_pf('/definitions/s1'), _pf('/definitions/s2'), _pf('/definitions/s3'), _pf('/definitions/s4'), _pf('/definitions/s1')],
[_pf('/definitions/s12'), _pf('/definitions/s13'), _pf('/definitions/s12')],
[_pf('/definitions/s6'), _pf('/definitions/s7'), _pf('/definitions/s6')],
[_pf('/definitions/s14'), _pf('/definitions/s15'), _pf('/definitions/s14')]
]))
def _load_swagger_resource(self, endpoint_name: str):
"""
Get Swagger spec of specified service and create an app instance to
be able to validate requests/responses and perform request.
:param endpoint_name: name of the service endpoint that data will be retrieved
:return PySwagger.App: an app instance
"""
# load Swagger resource file
logic_module = self._get_logic_module(endpoint_name)
schema_url = utils.get_swagger_url_by_logic_module(logic_module)
if schema_url not in self._data:
# load swagger json as a raw App and prepare it
try:
app = App.load(schema_url)
except URLError:
raise URLError(f'Make sure that {schema_url} is accessible.')
if app.raw.basePath == '/':
getattr(app, 'raw').update_field('basePath', '')
app.prepare()
self._data[schema_url] = app
return self._data[schema_url]
def test_uploadImages(self):
""" test for uploading multiple files """
global received_files
app = App._create_(
get_test_data_folder(version='2.0',
which=os.path.join('io', 'files')))
resp = yield self.client.request(app.op['upload_images'](images=[
dict(data=six.BytesIO(six.b('test image 1')), filename='_1.k'),
dict(data=six.BytesIO(six.b('test image 2')), filename='_2.k'),
dict(data=six.BytesIO(six.b('test image 3')), filename='_3.k'),
]),
opt=dict(url_netloc='localhost:' +
str(self.get_http_port())))
self.assertEqual(
received_files[0], {
'body': six.b('test image 1'),
'content_type': 'application/unknown',
'filename': u'_1.k'
})
self.assertEqual(
received_files[1], {
'body': six.b('test image 2'),
'content_type': 'application/unknown',
'filename': u'_2.k'
})
self.assertEqual(
received_files[2], {
'body': six.b('test image 3'),
'content_type': 'application/unknown',
'filename': u'_3.k'
})
def test_authorization(self):
"""
"""
app = App.create(get_test_data_folder(
version='1.2', which='simple_auth')
)
expect = {
'type':'apiKey',
'in':'query',
'name':'simpleQK'
}
self.assertEqual(_diff_(
expect,
app.resolve('#/securityDefinitions/simple_key').dump()
), [])
expect = {
'type':'apiKey',
'in':'header',
'name':'simpleHK'
}
self.assertEqual(_diff_(
expect,
app.resolve('#/securityDefinitions/simple_key2').dump()
), [])
expect = {
'type':'basic',
}
self.assertEqual(_diff_(
expect,
app.resolve('#/securityDefinitions/simple_basic').dump()
), [])
def test_schema(self):
folder = utils.normalize_url(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'schema')
))
def _pf(s):
return folder + '#' + s
app = App.load(folder)
app.prepare(strict=False)
s = Scanner(app)
c = CycleDetector()
s.scan(root=app.raw, route=[c])
self.maxDiff = None
self.assertEqual(sorted(c.cycles['schema']), sorted([
[_pf('/definitions/s10'), _pf('/definitions/s11'), _pf('/definitions/s9'), _pf('/definitions/s10')],
[_pf('/definitions/s5'), _pf('/definitions/s5')],
[_pf('/definitions/s1'), _pf('/definitions/s2'), _pf('/definitions/s3'), _pf('/definitions/s4'), _pf('/definitions/s1')],
[_pf('/definitions/s12'), _pf('/definitions/s13'), _pf('/definitions/s12')],
[_pf('/definitions/s6'), _pf('/definitions/s7'), _pf('/definitions/s6')],
[_pf('/definitions/s14'), _pf('/definitions/s15'), _pf('/definitions/s14')]
]))
def setUpClass(kls):
factory = Primitive()
def decode_int(obj, val, ctx):
# minus 1
return int(val) - 1
def decode_str(obj, val, ctx):
# remove the last char
return str(val)[:-1]
def str_no_validate(obj, val, ctx):
# same as the one used in pyswagger, but no validation
return str(val)
factory.register('encoded_integer', None, decode_int)
factory.register('string', 'special_encoded', decode_str)
factory.register('string', None, str_no_validate, _2nd_pass=None)
kls.app = App.load(get_test_data_folder(
version='2.0',
which=os.path.join('schema', 'extension'),
),
prim=factory)
kls.app.prepare()
def test_dict_getter_v2_0(self):
""" make sure 'DictGetter' works the same as 'LocalGetter'
for Swagger 2.0
"""
#
# loading via DictGetter
#
path = get_test_data_folder(version='2.0', which='wordnik')
origin_app = App.create(path)
with open(os.path.join(path, 'swagger.json'), 'r') as f:
spec = json.loads(f.read())
getter = DictGetter([path], {os.path.join(path, 'swagger.json'): spec})
app = App.load(path, resolver=Resolver(default_getter=getter))
app.prepare()
# make sure it produce the same App in default way
self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump())), [])
#
# loading via wrong path, should be ok when all internal $ref are not absoluted
#
getter = DictGetter([''], {'': spec})
app = App.load('', resolver=Resolver(default_getter=getter))
app.prepare()
# make sure it produce the same App in default way
self.assertEqual(
sorted(_diff_(app.dump(), origin_app.dump(), exclude=['$ref'])),
[])
#
# faking http path
#
getter = DictGetter(['https://petstore.com'],
{'https://petstore.com': spec})
app = App.load('https://petstore.com',
resolver=Resolver(default_getter=getter))
app.prepare()
# make sure it produce the same App in default way
self.assertEqual(
sorted(_diff_(app.dump(), origin_app.dump(), exclude=['$ref'])),
[])
def test_path_item_prepare_with_cycle(self):
app = App.load(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'path_item')
))
# should raise nothing
app.prepare()
def setUpClass(kls):
kls.app = App.load(get_test_data_folder(version='1.2',
which='wordnik'),
sep=':')
kls.app.prepare()
with open('./test.json', 'w') as r:
r.write(json.dumps(kls.app.dump(), indent=3))
def setUpClass(kls):
kls.app = App.load(get_test_data_folder(
version='1.2', which='wordnik'), sep=':'
)
kls.app.prepare()
with open('./test.json', 'w') as r:
r.write(json.dumps(kls.app.dump(), indent=3))
def setUpClass(kls):
kls.app = App.load(get_test_data_folder(
version='2.0',
which='bitbucket'
))
# bypass cyclic testing
kls.app.prepare(strict=False)
def test_relative_schema(self):
""" test case for issue#53,
relative file, which root is a Schema Object
"""
app = App.load(url='file:///relative/internal.yaml',
url_load_hook=_gen_hook(
get_test_data_folder(version='2.0', which='ex')))
app.prepare()
def init(self):
self.server = self["server"]
self.port = self["port"]
self.api = self["api"]
openapi_spec = 'http://{}:{}/{}/swagger.json'.format(
self.server, str(self.port), self.api)
self.app = App._create_(openapi_spec)
self.client = Client()
StratusClient.init(self)
def test_relative_schema(self):
""" test case for issue#53,
relative file, which root is a Schema Object
"""
app = App.load(
url='file:///relative/internal.yaml',
url_load_hook=_gen_hook(get_test_data_folder(version='2.0', which='ex'))
)
app.prepare()
def app():
_codec = MimeCodec()
_codec.register('application/json', JsonCodec())
# TODO: how to load .yaml?
app = App.load('http://petstore.swagger.io/v2/swagger.json',
mime_codec=_codec)
app.prepare(strict=True)
return app
def test_deref(self):
app = App.create(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'schema'),
),
strict=False)
s = app.resolve('#/definitions/s1')
self.assertRaises(errs.CycleDetectionError, utils.deref, s)
def __get_or_create_app(self, url, cache_key):
""" Get the app from cache or generate a new one if required
Because app object doesn't have etag/expiry, we have to make
a head() call before, to have these informations first... """
headers = {"Accept": "application/json"}
app_url = '%s?datasource=%s' % (url, self.datasource)
cached = self.cache.get(cache_key, (None, None, 0))
if cached is None or len(cached) != 3:
self.cache.invalidate(cache_key)
cached_app, cached_headers, cached_expiry = (cached, None, 0)
else:
cached_app, cached_headers, cached_expiry = cached
if cached_app is not None and cached_headers is not None:
# we didn't set custom expire, use header expiry
expires = cached_headers.get('expires', None)
cache_timeout = -1
if self.expire is None and expires is not None:
cache_timeout = get_cache_time_left(cached_headers['expires'])
if cache_timeout >= 0:
return cached_app
# we set custom expire, check this instead
else:
if self.expire == 0 or cached_expiry >= time.time():
return cached_app
# if we have etags, add the header to use them
etag = cached_headers.get('etag', None)
if etag is not None:
headers['If-None-Match'] = etag
# if nothing makes us use the cache, invalidate it
if ((expires is None or cache_timeout < 0
or cached_expiry < time.time()) and etag is None):
self.cache.invalidate(cache_key)
# set timeout value in case we have to cache it later
timeout = 0
if self.expire is not None and self.expire > 0:
timeout = time.time() + self.expire
# we are here, we know we have to make a head call...
res = requests.head(app_url, headers=headers)
if res.status_code == 304 and cached_app is not None:
self.cache.set(cache_key, (cached_app, res.headers, timeout))
return cached_app
# ok, cache is not accurate, make the full stuff
app = App.create(app_url)
if self.caching:
self.cache.set(cache_key, (app, res.headers, timeout))
return app
def test_local_path_with_custome_getter(self):
""" make sure path would be assigned when
passing a getter class
"""
cls = UrlGetter
path = get_test_data_folder(version='2.0', which='random_file_name')
path = os.path.join(path, 'test_random.json')
# should not raise errors
app = App.load(path, getter=cls)
def __get_or_create_app(self, app_url, cache_key):
""" Get the app from cache or generate a new one if required """
app = self.cache.get(cache_key, None)
if app is None:
app = App.create(app_url)
if self.caching:
self.cache.set(cache_key, app, self.expire)
return app
def test_random_name_v1_2(self):
"""
"""
path = get_test_data_folder(
version='1.2',
which='random_file_name'
)
path = os.path.join(path, 'test_random.json')
# should not raise ValueError
app = App.create(path)
def test_primfactory(self):
app = App.create(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'schema'),
),
strict=False
)
s = app.resolve('#/definitions/s1')
self.assertRaises(errs.CycleDetectionError, app.prim_factory.produce, s, {})
def test_empty_operation_id(self):
""" when operationId is empty, should not raise SchemaError """
try:
app = App.create(
get_test_data_folder(version="2.0",
which=os.path.join("schema", "emptyOp")))
except errs.SchemaError:
self.fail(
"SchemaError is raised when 'operationId' is empty and 'tags' is not"
)
def __init__(self, url, *auths):
app = App._create_(url)
auth = Security(app)
for t, cred in auths:
auth.update_with(t, cred)
client = Client(auth)
self.app, self.client = app, client
self.client._Client__s.hooks['response'] = logHttp
def setUp(self):
folder = get_test_data_folder(version='1.2', )
def _hook(url):
# a demo of hooking a remote url to local path
p = six.moves.urllib.parse.urlparse(url)
return utils.normalize_url(os.path.join(folder, p.path[1:]))
self.app = App.load('http://petstore.io/wordnik', url_load_hook=_hook)
self.app.prepare()
def test_deref(self):
app = App.create(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'schema'),
),
strict=False
)
s = app.resolve('#/definitions/s1')
self.assertRaises(errs.CycleDetectionError, utils.deref, s)
def test_primfactory(self):
app = App.create(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'schema'),
),
strict=False
)
s = app.resolve('#/definitions/s1')
self.assertRaises(errs.CycleDetectionError, app.prim_factory.produce, s, {})
def test_read_only_and_required(self):
""" a property is both read-only and required """
app = App.load(get_test_data_folder(
version='2.0',
which=os.path.join('validate', 'req_and_readonly')
))
errs = app.validate(strict=False)
self.maxDiff = None
self.assertEqual(sorted(errs), sorted([
((u'#/definitions/ReadOnly', 'Schema'), 'ReadOnly property in required list: protected')
]))
def test_no_host_basePath(self):
""" test case for swagger.json without
'host' and 'basePath' defined
"""
path = get_test_data_folder(
version='2.0',
which=os.path.join('patch', 'no_host_schemes')
)
fu = utils.normalize_url(path) # file uri version of path
# load swagger.json from a file path
app = App.create(path)
req, _ = app.s('t1').get()
self.assertEqual(req.url, '//localhost/t1')
self.assertEqual(req.schemes, ['file'])
req.prepare(scheme='file', handle_files=False)
self.assertEqual(req.url, 'file://localhost/t1')
# load swagger.json from a file uri
self.assertNotEqual(six.moves.urllib.parse.urlparse(fu).scheme, '')
app = App.create(fu)
req, _ = app.s('t1').get()
self.assertEqual(req.url, '//localhost/t1')
self.assertEqual(req.schemes, ['file'])
req.prepare(scheme='file', handle_files=False)
self.assertEqual(req.url, 'file://localhost/t1')
# load swagger.json from a remote uri
def _hook(url):
# no matter what url, return the path of local swagger.json
return fu
url = 'test.com/api/v1'
app = App.load('https://'+url, url_load_hook=_hook)
app.prepare()
# try to make a Request and verify its url
req, _ = app.s('t1').get()
self.assertEqual(req.url, '//test.com/t1')
self.assertEqual(req.schemes, ['https'])
req.prepare(scheme='https', handle_files=False)
self.assertEqual(req.url, 'https://test.com/t1')
def test_read_only_and_required(self):
""" a property is both read-only and required """
app = App.load(
get_test_data_folder(version='2.0',
which=os.path.join('validate',
'req_and_readonly')))
errs = app.validate(strict=False)
self.maxDiff = None
self.assertEqual(
sorted(errs),
sorted([((u'#/definitions/ReadOnly', 'Schema'),
'ReadOnly property in required list: protected')]))
def setUp(self):
folder = get_test_data_folder(
version='1.2',
)
def _hook(url):
# a demo of hooking a remote url to local path
p = six.moves.urllib.parse.urlparse(url)
return utils.normalize_url(os.path.join(folder, p.path[1:]))
self.app = App.load('http://petstore.io/wordnik', url_load_hook=_hook)
self.app.prepare()
def test_item(self):
""" make sure to raise exception for invalid item
"""
try:
App._create_(get_test_data_folder(
version='1.2',
which=os.path.join('upgrade_items', 'with_ref')
))
except errs.SchemaError as e:
self.failUnlessEqual(e.args, ('Can\'t have $ref for Items',))
else:
self.fail('SchemaError not raised')
try:
App._create_(get_test_data_folder(
version='1.2',
which=os.path.join('upgrade_items', 'invalid_primitive')
))
except errs.SchemaError as e:
self.failUnlessEqual(e.args, ('Non primitive type is not allowed for Items',))
else:
self.fail('SchemaError not raised')
def __init__(
self,
api_key: str,
swagger_file:
str = "http://www.mingweisamuel.com/riotapi-schema/swaggerspec-2.0.yml"
):
self.api_key = api_key
self.swagger_file = swagger_file
self.app = App.create(swagger_file)
self.auth = Security(self.app)
self.auth.update_with("api_key", api_key)
self.client = Client(self.auth)
def __init__(self, schema_path, codec=None):
self._schema_path = schema_path
if codec is None:
codec = CodecFactory()
self._prim_factory = \
codec._pyswagger_factory # pylint: disable=protected-access
self._app = App.load(schema_path, prim=self._prim_factory)
self._app.prepare()
self._api = Api(self)
def test_overwrite(self):
""" overrite type/format handler used in pyswagger """
m1 = self.app.resolve('#/definitions/m1')
v = m1._prim_({"job": "man"}, self.app.prim_factory)
# should not raise
self.assertEqual(v.job, "man")
app = App.create(
get_test_data_folder(version='2.0',
which=os.path.join('schema', 'extension')))
m1 = app.resolve('#/definitions/m1')
self.assertRaises(errs.ValidationError, m1._prim_, {'job': 'man'},
app.prim_factory)
def test_local_path_with_custome_getter(self):
""" make sure path would be assigned when
passing a getter class
"""
cls = UrlGetter
path = get_test_data_folder(
version='2.0',
which='random_file_name'
)
path = os.path.join(path, 'test_random.json')
# should not raise errors
app = App.load(path, getter=cls)
def test_parameter(self):
""" Parameter -> Parameter
"""
# body
o = self.app.root.paths['/api/pet/{petId}'].patch
p = [p for p in o.parameters if getattr(p, 'in') == 'body'][0]
self.assertEqual(getattr(p, 'in'), 'body')
self.assertEqual(p.required, True)
self.assertEqual(getattr(p.schema, '$ref'),
_pf('/definitions/pet!##!Pet'))
# form
o = self.app.root.paths['/api/pet/uploadImage'].post
p = [
p for p in o.parameters
if getattr(p, 'in') == 'formData' and p.type == 'string'
][0]
self.assertEqual(p.name, 'additionalMetadata')
self.assertEqual(p.required, False)
# file
o = self.app.root.paths['/api/pet/uploadImage'].post
p = [
p for p in o.parameters
if getattr(p, 'in') == 'formData' and p.type == 'file'
][0]
self.assertEqual(p.name, 'file')
self.assertEqual(p.required, False)
# non-body can't have $ref
try:
App._create_(
get_test_data_folder(version='1.2', which='upgrade_parameter'))
except errs.SchemaError as e:
self.failUnlessEqual(e.args,
("Can't have $ref in non-body Parameters", ))
else:
self.fail('SchemaError not raised')
def test_overwrite(self):
""" overrite type/format handler used in pyswagger """
m1 = self.app.resolve('#/definitions/m1')
v = m1._prim_({
"job":"man"
}, self.app.prim_factory)
# should not raise
self.assertEqual(v.job, "man")
app = App.create(get_test_data_folder(
version='2.0',
which=os.path.join('schema', 'extension')
))
m1 = app.resolve('#/definitions/m1')
self.assertRaises(errs.ValidationError, m1._prim_, {'job':'man'}, app.prim_factory)
def test_cookie(self):
global cookie_cache
app = App.create(get_test_data_folder(
version='2.0',
which=os.path.join('io', 'cookie')
))
client = Webapp2TestClient(cookie_app, keep_cookie=True)
resp = client.request(app.op['get_cookie']())
self.assertEqual(resp.status, 200)
resp = client.request(app.op['keep_cookie']())
self.assertEqual(resp.status, 200)
self.assertEqual(cookie_cache, 'test 123')
def test_model_inheritance(self):
"""
"""
app = App.load(get_test_data_folder(
version='1.2', which='model_subtypes'
), sep=':')
app.prepare()
expect = {
'allOf': [{'$ref': u'#/definitions/user:User'}]
}
self.assertEqual(_diff_(
expect,
app.resolve('#/definitions/user:UserWithInfo').dump(),
include=['allOf']
), [])
def test_load_from_url_without_file(self):
""" try to load from a url withou swagger.json """
data = None
with open(os.path.join(get_test_data_folder(
version='2.0',
which='wordnik'), 'swagger.json')) as f:
data = f.read()
httpretty.register_uri(
httpretty.GET,
'http://10.0.0.10:8080/swaggerapi/api/v1beta2',
body=data
)
# no exception should be raised
app = App.create('http://10.0.0.10:8080/swaggerapi/api/v1beta2')
self.assertTrue(app.schemes, ['http'])
self.assertTrue(isinstance(app.root, BaseObj))
def test_uploadImages(self):
""" upload multiple files """
httpretty.register_uri(httpretty.POST, 'http://test.com/upload', status=200)
app = App._create_(get_test_data_folder(version='2.0', which=os.path.join('io', 'files')))
resp = client.request(app.op['upload_images'](images=[
dict(data=six.BytesIO(six.b('test image 1')), filename='_1.k'),
dict(data=six.BytesIO(six.b('test image 2')), filename='_2.k'),
dict(data=six.BytesIO(six.b('test image 3')), filename='_3.k')
])
)
self.assertEqual(resp.status, 200)
body = httpretty.last_request().body.decode()
self.assertTrue(body.find('_1.k') != -1)
self.assertTrue(body.find('test image 1') != -1)
self.assertTrue(body.find('_2.k') != -1)
self.assertTrue(body.find('test image 2') != -1)
self.assertTrue(body.find('_3.k') != -1)
self.assertTrue(body.find('test image 3') != -1)
def test_uploadImages(self):
""" test for uploading multiple files """
global received_files
app = App._create_(get_test_data_folder(version='2.0', which=os.path.join('io', 'files')))
resp = yield self.client.request(
app.op['upload_images'](images=[
dict(data=six.BytesIO(six.b('test image 1')), filename='_1.k'),
dict(data=six.BytesIO(six.b('test image 2')), filename='_2.k'),
dict(data=six.BytesIO(six.b('test image 3')), filename='_3.k'),
]),
opt=dict(
url_netloc='localhost:'+str(self.get_http_port())
)
)
self.assertEqual(received_files[0], {'body': six.b('test image 1'), 'content_type': 'application/unknown', 'filename': u'_1.k'})
self.assertEqual(received_files[1], {'body': six.b('test image 2'), 'content_type': 'application/unknown', 'filename': u'_2.k'})
self.assertEqual(received_files[2], {'body': six.b('test image 3'), 'content_type': 'application/unknown', 'filename': u'_3.k'})
def test_auto_schemes(self):
""" make sure we scheme of url to access
swagger.json as default scheme
"""
# load swagger.json
data = None
with open(os.path.join(get_test_data_folder(
version='2.0',
which=os.path.join('schema', 'model')
), 'swagger.json')) as f:
data = f.read()
httpretty.register_uri(
httpretty.GET,
'http://test.com/api-doc/swagger.json',
body=data
)
app = App._create_('http://test.com/api-doc/swagger.json')
self.assertEqual(app.schemes, ['http'])
def test_token_endpoint(self):
"""
"""
app = App.create(get_test_data_folder(
version='1.2', which='simple_auth')
)
expect={
'tokenUrl':'http://petstore.swagger.wordnik.com/api/oauth/token',
'type':'oauth2',
'flow':'access_code',
'scopes': {
'test:anything':'for testing purpose'
}
}
self.assertEqual(_diff_(
expect,
app.resolve('#/securityDefinitions/oauth2').dump()
), [])
def test_path_item(self):
folder = utils.normalize_url(get_test_data_folder(
version='2.0',
which=os.path.join('circular', 'path_item')
))
def _pf(s):
return folder + '#' + s
app = App.create(folder)
s = Scanner(app)
c = CycleDetector()
s.scan(root=app.raw, route=[c])
self.assertEqual(sorted(c.cycles['path_item']), sorted([[
_pf('/paths/~1p1'),
_pf('/paths/~1p2'),
_pf('/paths/~1p3'),
_pf('/paths/~1p4'),
_pf('/paths/~1p1')
]]))
def setUpClass(kls):
factory = Primitive()
def decode_int(obj, val, ctx):
# minus 1
return int(val) - 1
def decode_str(obj, val, ctx):
# remove the last char
return str(val)[:-1]
def str_no_validate(obj, val, ctx):
# same as the one used in pyswagger, but no validation
return str(val)
factory.register('encoded_integer', None, decode_int)
factory.register('string', 'special_encoded', decode_str)
factory.register('string', None, str_no_validate, _2nd_pass=None)
kls.app = App.load(get_test_data_folder(
version='2.0',
which=os.path.join('schema', 'extension'),
), prim=factory)
kls.app.prepare()
def test_v2_0(self):
""" convert from 2.0 to 2.0 """
path = get_test_data_folder(version='2.0', which='wordnik')
app = App.create(path)
# load swagger.json into dict
origin = None
with open(os.path.join(path, 'swagger.json')) as r:
origin = json.loads(r.read())
# diff for empty list or dict is allowed
d = app.dump()
self.assertEqual(sorted(_diff_(origin, d, exclude=['$ref'])), sorted([
('paths/~1pet~1{petId}/get/security/0/api_key', "list", "NoneType"),
('paths/~1store~1inventory/get/parameters', None, None),
('paths/~1store~1inventory/get/security/0/api_key', "list", "NoneType"),
('paths/~1user~1logout/get/parameters', None, None)
]))
# try to load the dumped dict back, to see if anything wrong
tmp = {'_tmp_': {}}
with SwaggerContext(tmp, '_tmp_') as ctx:
ctx.parse(d)
from __future__ import absolute_import
from tornado import web, testing
from tornado.ioloop import IOLoop
from pyswagger import App
from pyswagger.contrib.client.tornado import TornadoClient
from ...utils import create_pet_db, get_test_data_folder, pet_Mary
import json
import six
import os
sapp = App._create_(get_test_data_folder(version='1.2', which='wordnik'))
received_file = None
received_meta = None
received_headers = None
""" refer to pyswagger.tests.data.v1_2.wordnik for details """
class RESTHandler(web.RequestHandler):
""" base implementation of RequestHandler,
accept a db as init paramaeter.
"""
def initialize(self, db):
self.db = db
def prepare(self):
"""
According to FAQ of tornado, they won't handle json media-type.
"""
super(RESTHandler, self).prepare()
