def _make_namespace_with_a_union():
# type: (...) -> ApiNamespace
ns = ApiNamespace('ns_with_a_union')
u1 = Union(name='Union', namespace=ns, ast_node=None, closed=True)
u1.set_attributes(
doc=None,
fields=[
UnionField(name="first", doc=None, data_type=Void(),
ast_node=None),
UnionField(name="last", doc=None, data_type=Void(), ast_node=None),
],
)
ns.add_data_type(u1)
# A more interesting case with non-void variants.
shape_union = Union(name='Shape', namespace=ns, ast_node=None, closed=True)
shape_union.set_attributes(
doc=None,
fields=[
UnionField(name="point", doc=None, data_type=Void(),
ast_node=None),
UnionField(name="circle",
doc=None,
data_type=Float64(),
ast_node=None),
],
)
ns.add_data_type(shape_union)
return ns
def test_route_with_auth_mode1(self):
# type: () -> None
route1 = ApiRoute('get_metadata', 1, None)
route1.set_attributes(None, ':route:`get_metadata:2`', Void(), Void(),
Void(), {'auth': 'app'})
route2 = ApiRoute('get_metadata', 2, None)
route2.set_attributes(None, None, Void(), Int32(), Void(),
{'auth': 'user, app'})
ns = ApiNamespace('files')
ns.add_route(route1)
ns.add_route(route2)
result = self._evaluate_namespace_with_auth_mode(ns, 'user')
expected = textwrap.dedent('''\
# ------------------------------------------
# Routes in files namespace
def files_get_metadata_v2(self):
arg = None
r = self.request(
files.get_metadata_v2,
'files',
arg,
None,
)
return r
''')
self.assertEqual(result, expected)
def _get_api(self):
# type () -> Api
api = Api(version='0.1b1')
api.route_schema = Struct(u'Route', 'stone_cfg', None)
route1 = ApiRoute('get_metadata', 1, None)
route1.set_attributes(None, ':route:`get_metadata`', Void(), Void(), Void(), {})
route2 = ApiRoute('get_metadata', 2, None)
route2.set_attributes(None, ':route:`get_metadata:2`', Void(), Int32(), Void(), {})
ns = ApiNamespace('files')
ns.add_route(route1)
ns.add_route(route2)
api.namespaces[ns.name] = ns
return api, ns
def test_route_with_version_number_conflict(self):
# type: () -> None
api, ns = self._get_api()
# Add a conflicting route
route3 = ApiRoute('get_metadata_v2', 1, None)
route3.set_attributes(None, None, Void(), Int32(), Void(), {})
ns.add_route(route3)
backend = TSDClientBackend(target_folder_path="output",
args=['files', 'files'])
with self.assertRaises(RuntimeError) as cm:
backend._generate_routes(api, 0, 0)
self.assertTrue(
str(cm.exception).startswith('There is a name conflict between'))
def test_route_with_version_number_name_conflict(self):
# type: () -> None
route1 = ApiRoute('get_metadata', 2, None)
route1.set_attributes(None, None, Void(), Int32(), Void(), {})
route2 = ApiRoute('get_metadata_v2', 1, None)
route2.set_attributes(None, None, Void(), Void(), Void(), {})
ns = ApiNamespace('files')
ns.add_route(route1)
ns.add_route(route2)
with self.assertRaises(RuntimeError) as cm:
self._evaluate_namespace(ns)
self.assertEqual(
'There is a name conflict between {!r} and {!r}'.format(
route1, route2), str(cm.exception))
def test_route_with_version_number(self):
# type: () -> None
route1 = ApiRoute('get_metadata', 1, None)
route1.set_attributes(None, ':route:`get_metadata:2`', Void(), Void(),
Void(), {})
route2 = ApiRoute('get_metadata', 2, None)
route2.set_attributes(None, None, Void(), Int32(), Void(), {})
ns = ApiNamespace('files')
ns.add_route(route1)
ns.add_route(route2)
result = self._evaluate_namespace(ns)
expected = textwrap.dedent('''\
def files_get_metadata(self):
"""
:meth:`files_get_metadata_v2`
:rtype: None
"""
arg = None
r = self.request(
files.get_metadata,
'files',
arg,
None,
)
return None
def files_get_metadata_v2(self):
arg = None
r = self.request(
files.get_metadata_v2,
'files',
arg,
None,
)
return r
''')
self.assertEqual(result, expected)
def test_route_with_version_number(self):
# type: () -> None
route1 = ApiRoute('alpha/get_metadata', 1, None)
route1.set_attributes(None, None, Void(), Void(), Void(), {})
route2 = ApiRoute('alpha/get_metadata', 2, None)
route2.set_attributes(None, None, Void(), Int32(), Void(), {})
ns = ApiNamespace('files')
ns.add_route(route1)
ns.add_route(route2)
result = self._evaluate_namespace(ns)
expected = textwrap.dedent("""\
alpha_get_metadata = bb.Route(
'alpha/get_metadata',
1,
False,
bv.Void(),
bv.Void(),
bv.Void(),
{},
)
alpha_get_metadata_v2 = bb.Route(
'alpha/get_metadata',
2,
False,
bv.Void(),
bv.Int32(),
bv.Void(),
{},
)
ROUTES = {
'alpha/get_metadata': alpha_get_metadata,
'alpha/get_metadata:2': alpha_get_metadata_v2,
}
""")
self.assertEqual(result, expected)
def test_route_argument_doc_string(self):
backend = PythonClientBackend(
target_folder_path='output',
args=['-m', 'files', '-c', 'DropboxBase', '-t', 'dropbox'])
ns = ApiNamespace('files')
self.assertEqual(backend._format_type_in_doc(ns, Int32()), 'int')
self.assertEqual(backend._format_type_in_doc(ns, Void()), 'None')
self.assertEqual(backend._format_type_in_doc(ns, List(String())),
'List[str]')
self.assertEqual(backend._format_type_in_doc(ns, Nullable(String())),
'Nullable[str]')
self.assertEqual(
backend._format_type_in_doc(ns, Map(String(), Int32())),
'Map[str, int]')
def test_union(self):
ns = ApiNamespace('files')
update_parent_rev = Struct(
'UpdateParentRev',
None,
ns,
)
update_parent_rev.set_attributes(
"Overwrite existing file if the parent rev matches.",
[
StructField('parent_rev', String(),
'The revision to be updated.', None)
],
)
update_parent_rev._add_example(
AstExample(path=None,
lineno=None,
lexpos=None,
label='default',
text=None,
fields={
'parent_rev':
AstExampleField(None, None, None, 'parent_rev',
'xyz123')
}))
# test variants with only tags, as well as those with structs.
conflict = Union(
'WriteConflictPolicy',
None,
ns,
True,
)
conflict.set_attributes(
'Policy for managing write conflicts.',
[
UnionField('reject', Void(),
'On a write conflict, reject the new file.', None),
UnionField(
'overwrite', Void(),
'On a write conflict, overwrite the existing file.', None),
UnionField(
'update_if_matching_parent_rev', update_parent_rev,
'On a write conflict, overwrite the existing file.', None),
],
)
conflict._add_example(
AstExample(path=None,
lineno=None,
lexpos=None,
label='default',
text=None,
fields={
'update_if_matching_parent_rev':
AstExampleField(
None, None, None,
'update_if_matching_parent_rev',
AstExampleRef(None, None, None, 'default'))
}))
conflict._compute_examples()
# test that only null value is returned for an example of a Void type
self.assertEqual(conflict.get_examples()['reject'].value,
{'.tag': 'reject'})
# test that dict is returned for a tagged struct variant
self.assertEqual(conflict.get_examples()['default'].value, {
'.tag': 'update_if_matching_parent_rev',
'parent_rev': 'xyz123'
})
