def test_sio_string3_zato(self):
gen = Generator(get_service_store_services(String3), simple_io_config)
info = gen.get_info(rand_string())
req = get_services_from_info('name', '_test.string3', info)
sio = req.simple_io['zato']
sio_iopt = self._sort_sio(sio.input_optional)
sio_oreq = self._sort_sio(sio.output_required)
sio_oopt = self._sort_sio(sio.output_optional)
self.assertEquals(sio.spec_name, 'zato')
self.assertEquals(sio.request_elem, None)
self.assertEquals(sio.response_elem, None)
self.assertListEqual(sio_iopt, [
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'a2a')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'b2b')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'c2c')]
])
self.assertListEqual(sio_oreq, [
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'aa')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'bb')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'cc')]
])
self.assertListEqual(sio_oopt, [
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'aaa')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'bbb')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'ccc')]
])
self.assertListEqual(sio.input_required, [])
def handle(self):
cluster_id = self.request.input.get('cluster_id')
include = aslist(self.request.input.include, ',')
exclude = aslist(self.request.input.exclude, ',')
include = [elem for elem in include if elem]
exclude = [elem for elem in exclude if elem]
if not self.request.input.get('return_internal'):
if 'zato.*' not in exclude:
exclude.append('zato.*')
if cluster_id and cluster_id != self.server.cluster_id:
raise ValueError('Input cluster ID `%s` different than ours `%s`',
cluster_id, self.server.cluster_id)
# Default to Sphinx output unless explicitly overridden
if isinstance(self.request.input.needs_sphinx, bool):
needs_sphinx = self.request.input.needs_sphinx
else:
needs_sphinx = True
data = Generator(self.server.service_store.services,
self.server.sio_config, include, exclude,
self.request.input.query).get_info()
if needs_sphinx:
out = self.invoke(GetSphinx.get_name(), {'data': data})
else:
out = data
self.response.payload = dumps(out)
def test_sio_string1_open_api_v2(self):
gen = Generator(get_service_store_services(String), simple_io_config)
info = gen.get_info(rand_string())
req = get_services_from_info('name', '_test.string', info)
sio = req.simple_io[APISPEC.OPEN_API_V2]
sio_ireq = self._sort_sio(sio.input_required)
sio_oreq = self._sort_sio(sio.output_required)
self.assertEquals(sio.spec_name, APISPEC.OPEN_API_V2)
self.assertEquals(sio.request_elem, None)
self.assertEquals(sio.response_elem, None)
self.assertListEqual(sio_ireq, [
[('subtype', None), ('is_required', True), ('type', 'string'), ('name', 'a')],
[('subtype', None), ('is_required', True), ('type', 'string'), ('name', 'b')],
[('subtype', None), ('is_required', True), ('type', 'string'), ('name', 'c')]
])
self.assertListEqual(sio_oreq, [
[('subtype', None), ('is_required', True), ('type', 'string'), ('name', 'aa')],
[('subtype', None), ('is_required', True), ('type', 'string'), ('name', 'bb')],
[('subtype', None), ('is_required', True), ('type', 'string'), ('name', 'cc')]
])
self.assertListEqual(sio.input_optional, [])
self.assertListEqual(sio.output_optional, [])
def test_request_response_open_api_v2(self):
gen = Generator(get_service_store_services(RequestResponse), simple_io_config)
info = gen.get_info(rand_string())
req = get_services_from_info('name', '_test.request-response', info)
sio = req.simple_io[APISPEC.OPEN_API_V2]
self.assertEquals(sio.spec_name, APISPEC.OPEN_API_V2)
self.assertEquals(sio.request_elem, 'my_request_elem')
self.assertEquals(sio.response_elem, 'my_response_elem')
def handle(self):
cluster_id = self.request.input.get('cluster_id')
if cluster_id and cluster_id != self.server.cluster_id:
raise ValueError('Input cluster ID `%s` different than ours `%s`',
cluster_id, self.server.cluster_id)
self.response.payload = dumps(
Generator(self.server.service_store.services,
self.request.input.query).get_info())
def test_name(self):
gen = Generator(get_service_store_services(Name, Name2, Name3), simple_io_config)
info = gen.get_info(rand_string())
name1 = get_services_from_info('name', '_test.name', info)
name2 = get_services_from_info('name', '_test.name2', info)
name3 = get_services_from_info('name', '_test.name3', info)
self.assertEquals(name1.name, '_test.name')
self.assertEquals(name2.name, '_test.name2')
self.assertEquals(name3.name, '_test.name3')
def test_sio_bool_zato(self):
gen = Generator(get_service_store_services(BoolInt), simple_io_config)
info = gen.get_info(rand_string())
req = get_services_from_info('name', '_test.bool-int', info)
sio = req.simple_io['zato']
sio_ireq = self._sort_sio(sio.input_required)
sio_iopt = self._sort_sio(sio.input_optional)
sio_oreq = self._sort_sio(sio.output_required)
sio_oopt = self._sort_sio(sio.output_optional)
self.assertEquals(sio.spec_name, 'zato')
self.assertEquals(sio.request_elem, None)
self.assertEquals(sio.response_elem, None)
self.assertEquals(sio_ireq[0], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'a_count')])
self.assertEquals(sio_ireq[1], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'a_id')])
self.assertEquals(sio_ireq[2], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'a_size')])
self.assertEquals(sio_ireq[3], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'a_timeout')])
self.assertEquals(sio_ireq[4], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'id')])
self.assertEquals(sio_ireq[5], [('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'is_a')])
self.assertEquals(sio_ireq[6], [('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'needs_a')])
self.assertEquals(sio_ireq[7], [('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'should_a')])
self.assertEquals(sio_iopt[0], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'b_count')])
self.assertEquals(sio_iopt[1], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'b_id')])
self.assertEquals(sio_iopt[2], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'b_size')])
self.assertEquals(sio_iopt[3], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'b_timeout')])
self.assertEquals(sio_iopt[4], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'id')])
self.assertEquals(sio_iopt[5], [('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'is_b')])
self.assertEquals(sio_iopt[6], [('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'needs_b')])
self.assertEquals(sio_iopt[7], [('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'should_b')])
self.assertEquals(sio_oreq[0], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'c_count')])
self.assertEquals(sio_oreq[1], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'c_id')])
self.assertEquals(sio_oreq[2], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'c_size')])
self.assertEquals(sio_oreq[3], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'c_timeout')])
self.assertEquals(sio_oreq[4], [('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'id')])
self.assertEquals(sio_oreq[5], [('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'is_c')])
self.assertEquals(sio_oreq[6], [('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'needs_c')])
self.assertEquals(sio_oreq[7], [('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'should_c')])
self.assertEquals(sio_oopt[0], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'd_count')])
self.assertEquals(sio_oopt[1], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'd_id')])
self.assertEquals(sio_oopt[2], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'd_size')])
self.assertEquals(sio_oopt[3], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'd_timeout')])
self.assertEquals(sio_oopt[4], [('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'id')])
self.assertEquals(sio_oopt[5], [('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'is_d')])
self.assertEquals(sio_oopt[6], [('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'needs_d')])
self.assertEquals(sio_oopt[7], [('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'should_d')])
def handle(self):
cluster_id = self.request.input.get('cluster_id')
if self.request.input.get('return_internal'):
ignore_prefix = ''
else:
ignore_prefix = 'zato'
if cluster_id and cluster_id != self.server.cluster_id:
raise ValueError('Input cluster ID `%s` different than ours `%s`',
cluster_id, self.server.cluster_id)
info = Generator(
self.server.service_store.services, self.server.sio_config,
self.request.input.query).get_info(ignore_prefix=ignore_prefix)
self.response.payload = dumps(info)
def test_invokes_list(self):
gen = Generator(get_service_store_services(InvokesList, InvokesList2, InvokesList3), simple_io_config)
info = gen.get_info(rand_string())
invokes_list1 = get_services_from_info('name', '_test.invokes-list', info)
invokes_list2 = get_services_from_info('name', '_test.invokes-list2', info)
invokes_list3 = get_services_from_info('name', '_test.invokes-list3', info)
self.assertEquals(invokes_list1.name, '_test.invokes-list')
self.assertListEqual(invokes_list1.invokes, ['_test.invokes-list2', '_test.invokes-list3'])
self.assertListEqual(invokes_list1.invoked_by, [])
self.assertEquals(invokes_list2.name, '_test.invokes-list2')
self.assertListEqual(invokes_list2.invokes, ['_test.invokes-list3'])
self.assertListEqual(invokes_list2.invoked_by, ['_test.invokes-list', '_test.invokes-list3'])
self.assertEquals(invokes_list3.name, '_test.invokes-list3')
self.assertListEqual(invokes_list3.invokes, ['_test.invokes-list2'])
self.assertListEqual(invokes_list3.invoked_by, ['_test.invokes-list', '_test.invokes-list2'])
def test_invokes_string(self):
gen = Generator(get_service_store_services(InvokesString, InvokesString2, InvokesString3), simple_io_config)
info = gen.get_info(rand_string())
invokes_string1 = get_services_from_info('name', '_test.invokes-string', info)
invokes_string2 = get_services_from_info('name', '_test.invokes-string2', info)
invokes_string3 = get_services_from_info('name', '_test.invokes-string3', info)
self.assertEquals(invokes_string1.name, '_test.invokes-string')
self.assertListEqual(invokes_string1.invokes, ['_test.invokes-string2'])
self.assertListEqual(invokes_string1.invoked_by, [])
self.assertEquals(invokes_string2.name, '_test.invokes-string2')
self.assertListEqual(invokes_string2.invokes, ['_test.invokes-string3'])
self.assertListEqual(invokes_string2.invoked_by, ['_test.invokes-string', '_test.invokes-string3'])
self.assertEquals(invokes_string3.name, '_test.invokes-string3')
self.assertListEqual(invokes_string3.invokes, ['_test.invokes-string2'])
self.assertListEqual(invokes_string3.invoked_by, ['_test.invokes-string2'])
def handle(self):
cluster_id = self.request.input.get('cluster_id')
include = aslist(self.request.input.include, ',')
exclude = aslist(self.request.input.exclude, ',')
if self.request.input.get('return_internal'):
if 'zato.*' not in exclude:
exclude.append('zato.*')
if cluster_id and cluster_id != self.server.cluster_id:
raise ValueError('Input cluster ID `%s` different than ours `%s`',
cluster_id, self.server.cluster_id)
data = Generator(self.server.service_store.services,
self.server.sio_config, include, exclude,
self.request.input.query).get_info()
out = self.invoke(GetSphinx.get_name(), {'data': data})
self.response.payload = dumps(out)
def test_docstring(self):
gen = Generator(get_service_store_services(Docstring, Docstring2, Docstring3), simple_io_config)
info = gen.get_info(rand_string())
docstring1 = get_services_from_info('name', '_test.docstring', info)
docstring2 = get_services_from_info('name', '_test.docstring2', info)
docstring3 = get_services_from_info('name', '_test.docstring3', info)
self.assertEquals(docstring1.name, '_test.docstring')
self.assertEquals(docstring1.docs.summary, 'Docstring Summary')
self.assertEquals(docstring1.docs.description, 'Docstring Summary')
self.assertEquals(docstring1.docs.full, 'Docstring Summary')
self.assertEquals(docstring2.name, '_test.docstring2')
self.assertEquals(docstring2.docs.summary, 'Docstring2 Summary')
self.assertEquals(docstring2.docs.description, 'Docstring2 Description')
self.assertEquals(docstring2.docs.full, 'Docstring2 Summary.\n\nDocstring2 Description')
self.assertEquals(docstring3.name, '_test.docstring3')
self.assertEquals(docstring3.docs.summary, 'Docstring3 Summary')
self.assertEquals(docstring3.docs.description, 'Docstring3 Description\n\nDocstring3 Description2')
self.assertEquals(docstring3.docs.full, 'Docstring3 Summary.\n\nDocstring3 Description\n\nDocstring3 Description2')
def test_namespace(self):
gen = Generator(get_service_store_services(
Namespace1, Namespace2, Namespace3, Namespace11, Namespace22, Namespace33, NoNamespace), simple_io_config)
info = gen.get_info(rand_string())
sns1 = get_services_from_info('name', '_test.namespace1', info)
sns2 = get_services_from_info('name', '_test.namespace2', info)
sns3 = get_services_from_info('name', '_test.namespace3', info)
sns11 = get_services_from_info('name', '_test.namespace11', info)
sns22 = get_services_from_info('name', '_test.namespace22', info)
sns33 = get_services_from_info('name', '_test.namespace33', info)
snons = get_services_from_info('name', '_test.no-namespace', info)
namespaces = bunchify(info['namespaces'])
myns = namespaces['myns']
my_other_ns = namespaces['my-other-ns']
my_other_ns_abc = namespaces['my-other-ns-abc']
self.assertEquals(myns.name, 'myns')
self.assertEquals(myns.docs, """This is my namespace.\nAs with regular docstrings it can contain multi-line documentation.\n\n* Documentation will be parsed as Markdown\n* Bullet lists *and* other non-obtrusive markup can be used\n""")
self.assertEquals(myns.docs_md, """<p>This is my namespace.\nAs with regular docstrings it can contain multi-line documentation.</p>\n<ul>\n<li>Documentation will be parsed as Markdown</li>\n<li>Bullet lists <em>and</em> other non-obtrusive markup can be used</li>\n</ul>""")
self.assertEquals(my_other_ns.name, 'my-other-ns')
self.assertEquals(my_other_ns.docs, '')
self.assertEquals(my_other_ns.docs_md, '')
self.assertEquals(my_other_ns_abc.name, 'my-other-ns-abc')
self.assertEquals(my_other_ns_abc.docs, '')
self.assertEquals(my_other_ns_abc.docs_md, '')
self.assertEquals(sns1.namespace_name, 'myns')
self.assertEquals(sns2.namespace_name, 'my-other-ns')
self.assertEquals(sns3.namespace_name, 'myns')
self.assertEquals(sns11.namespace_name, 'myns')
self.assertEquals(sns22.namespace_name, 'myns')
self.assertEquals(sns33.namespace_name, 'my-other-ns-abc')
self.assertEquals(snons.namespace_name, APISPEC.NAMESPACE_NULL)
def test_generate_open_api(self):
MyClass = deepcopy(MyService)
CySimpleIO.attach_sio(self.get_server_config(), MyClass)
service_store_services = {
'my.impl.name': {
'name': service_name,
'service_class': MyClass,
}
}
include = ['*']
exclude = []
query = ''
tags = 'public'
generator = Generator(service_store_services, sio_config, include, exclude, query, tags, needs_sio_desc=False)
info = generator.get_info()
info = bunchify(info)
channel_data = [{
'service_name': service_name,
'transport': URL_TYPE.PLAIN_HTTP,
'url_path': '/test/{phone_number}',
'match_target_compiled': _MatchTestCompiled()
}]
needs_api_invoke = True
needs_rest_channels = True
api_invoke_path = APISPEC.GENERIC_INVOKE_PATH
open_api_generator = OpenAPIGenerator(info, channel_data, needs_api_invoke, needs_rest_channels, api_invoke_path)
result = open_api_generator.generate()
result = yaml_load(result, FullLoader)
result = bunchify(result)
result_components = result.components # type: Bunch
result_info = result.info # type: Bunch
result_openapi = result.openapi # type: Bunch
result_paths = result.paths # type: Bunch
result_servers = result.servers # type: Bunch
localhost = result_servers[0]
self.assertEqual(localhost.url, 'http://localhost:11223')
self.assertEqual(result_info.title, 'API spec')
self.assertEqual(result_info.version, '1.0')
self.assertEqual(result_openapi, '3.0.2')
self.assertEqual(len(result_components.schemas), 2)
request_my_service_properties = result_components.schemas.request_my_service.properties
request_my_service_required = result_components.schemas.request_my_service.required
request_my_service_title = result_components.schemas.request_my_service.title
request_my_service_type = result_components.schemas.request_my_service.type
response_my_service_required = result_components.schemas.response_my_service.required
response_my_service_title = result_components.schemas.response_my_service.title
response_my_service_type = result_components.schemas.response_my_service.type
self.assertEqual(request_my_service_title, 'Request object for my.service')
self.assertEqual(response_my_service_title, 'Response object for my.service')
self.assertEqual(request_my_service_type, 'object')
self.assertEqual(response_my_service_type, 'object')
self.assertListEqual(sorted(request_my_service_required), ['input_req_customer_id', 'input_req_user_id'])
self.assertListEqual(sorted(response_my_service_required), ['output_req_address_id', 'output_req_address_name'])
self.assertEqual(request_my_service_properties.input_req_user_id.type, 'integer')
self.assertEqual(request_my_service_properties.input_req_user_id.format, 'int32')
self.assertEqual(request_my_service_properties.input_req_user_id.description,
'This is the first line.\nHere is another.\nAnd here are some more lines.')
self.assertEqual(request_my_service_properties.input_req_customer_id.type, 'integer')
self.assertEqual(request_my_service_properties.input_req_customer_id.format, 'int32')
self.assertEqual(request_my_service_properties.input_req_customer_id.description, '')
self.assertEqual(request_my_service_properties.input_opt_user_name.type, 'string')
self.assertEqual(request_my_service_properties.input_opt_user_name.format, 'string')
self.assertEqual(request_my_service_properties.input_opt_user_name.description, 'b111')
self.assertEqual(request_my_service_properties.input_opt_customer_name.type, 'string')
self.assertEqual(request_my_service_properties.input_opt_customer_name.format, 'string')
self.assertEqual(request_my_service_properties.input_opt_customer_name.description, '')
self.assertEqual(len(result_paths), 2)
for url_path in ['/test/{phone_number}', '/zato/api/invoke/my.service']:
my_service_path = result_paths[url_path] # type: Bunch
post = my_service_path.post
self.assertListEqual(post.consumes, ['application/json'])
self.assertEqual(post.operationId, 'post_{}'.format(fs_safe_name(url_path)))
self.assertTrue(post.requestBody.required)
self.assertEqual(
post.requestBody.content['application/json'].schema['$ref'], '#/components/schemas/request_my_service')
self.assertEqual(
post.responses['200'].content['application/json'].schema['$ref'], '#/components/schemas/response_my_service')
def test_force_type_zato(self):
gen = Generator(get_service_store_services(ForceTypeService), simple_io_config)
info = gen.get_info(rand_string())
req = get_services_from_info('name', '_test.force-type', info)
sio = req.simple_io['zato']
sio_ireq = self._sort_sio(sio.input_required)
sio_iopt = self._sort_sio(sio.input_optional)
sio_oreq = self._sort_sio(sio.output_required)
sio_oopt = self._sort_sio(sio.output_optional)
self.assertEquals(sio.spec_name, 'zato')
self.assertEquals(sio.request_elem, None)
self.assertEquals(sio.response_elem, None)
self.assertListEqual(sio_ireq, [
[('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'b')],
[('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'c')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'd')],
[('subtype', 'dict'), ('is_required', True), ('type', 'dict'), ('name', 'e')],
[('subtype', 'float'), ('is_required', True), ('type', 'number'), ('name', 'f')],
[('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'g')],
[('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'h')],
[('subtype', 'list'), ('is_required', True), ('type', 'list'), ('name', 'i')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'is_a')],
[('subtype', 'list-of-dicts'), ('is_required', True), ('type', 'list'), ('name', 'j')],
[('subtype', 'opaque'), ('is_required', True), ('type', 'opaque'), ('name', 'k')],
[('subtype', 'opaque'), ('is_required', True), ('type', 'opaque'), ('name', 'l')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'm')],
[('subtype', 'date-time-utc'), ('is_required', True), ('type', 'string'), ('name', 'n')]
])
self.assertListEqual(sio_iopt, [
[('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'bb')],
[('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'cc')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'dd')],
[('subtype', 'dict'), ('is_required', False), ('type', 'dict'), ('name', 'ee')],
[('subtype', 'float'), ('is_required', False), ('type', 'number'), ('name', 'ff')],
[('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'gg')],
[('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'hh')],
[('subtype', 'list'), ('is_required', False), ('type', 'list'), ('name', 'ii')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'is_aa')],
[('subtype', 'list-of-dicts'), ('is_required', False), ('type', 'list'), ('name', 'jj')],
[('subtype', 'opaque'), ('is_required', False), ('type', 'opaque'), ('name', 'kk')],
[('subtype', 'opaque'), ('is_required', False), ('type', 'opaque'), ('name', 'll')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'mm')],
[('subtype', 'date-time-utc'), ('is_required', False), ('type', 'string'), ('name', 'nn')]
])
self.assertListEqual(sio_oreq, [
[('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'bbb')],
[('subtype', 'boolean'), ('is_required', True), ('type', 'boolean'), ('name', 'ccc')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'ddd')],
[('subtype', 'dict'), ('is_required', True), ('type', 'dict'), ('name', 'eee')],
[('subtype', 'float'), ('is_required', True), ('type', 'number'), ('name', 'fff')],
[('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'ggg')],
[('subtype', 'integer'), ('is_required', True), ('type', 'integer'), ('name', 'hhh')],
[('subtype', 'list'), ('is_required', True), ('type', 'list'), ('name', 'iii')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'is_aaa')],
[('subtype', 'list-of-dicts'), ('is_required', True), ('type', 'list'), ('name', 'jjj')],
[('subtype', 'opaque'), ('is_required', True), ('type', 'opaque'), ('name', 'kkk')],
[('subtype', 'opaque'), ('is_required', True), ('type', 'opaque'), ('name', 'lll')],
[('subtype', 'string'), ('is_required', True), ('type', 'string'), ('name', 'mmm')],
[('subtype', 'date-time-utc'), ('is_required', True), ('type', 'string'), ('name', 'nnn')]
])
self.assertListEqual(sio_oopt, [
[('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'bbbb')],
[('subtype', 'boolean'), ('is_required', False), ('type', 'boolean'), ('name', 'cccc')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'dddd')],
[('subtype', 'dict'), ('is_required', False), ('type', 'dict'), ('name', 'eeee')],
[('subtype', 'float'), ('is_required', False), ('type', 'number'), ('name', 'ffff')],
[('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'gggg')],
[('subtype', 'integer'), ('is_required', False), ('type', 'integer'), ('name', 'hhhh')],
[('subtype', 'list'), ('is_required', False), ('type', 'list'), ('name', 'iiii')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'is_aaaa')],
[('subtype', 'list-of-dicts'), ('is_required', False), ('type', 'list'), ('name', 'jjjj')],
[('subtype', 'opaque'), ('is_required', False), ('type', 'opaque'), ('name', 'kkkk')],
[('subtype', 'opaque'), ('is_required', False), ('type', 'opaque'), ('name', 'llll')],
[('subtype', 'string'), ('is_required', False), ('type', 'string'), ('name', 'mmmm')],
[('subtype', 'date-time-utc'), ('is_required', False), ('type', 'string'), ('name', 'nnnn')]
])
def test_generator_get_info(self):
MyClass = deepcopy(MyService)
CySimpleIO.attach_sio(self.get_server_config(), MyClass)
service_store_services = {
'my.impl.name': {
'name': 'my.name',
'service_class': MyClass,
}
}
include = ['*']
exclude = []
query = ''
tags = 'public'
generator = Generator(service_store_services, sio_config, include, exclude, query, tags, needs_sio_desc=False)
info = generator.get_info()
info = bunchify(info)
services = info.services # type: Bunch
self.assertEqual(len(services), 1)
service = services[0] # type: Bunch
service_keys = sorted(service)
self.assertListEqual(service_keys, ['docs', 'invoked_by', 'invokes', 'name', 'namespace_name', 'simple_io'])
service_docs = service.docs # type: Bunch
service_invoked_by = service.invoked_by
service_invokes = service.invokes
service_namespace_name = service.namespace_name
service_simple_io = service.simple_io
self.assertEqual(service_docs.description, 'It has a docstring.')
self.assertEqual(service_docs.description_html, 'It has a docstring.')
self.assertEqual(service_docs.full, 'This is my service.\n\nIt has a docstring.\n')
self.assertEqual(service_docs.full_html, 'This is my service.</p>\n<p>It has a docstring.')
self.assertEqual(service_docs.summary, 'This is my service.')
self.assertEqual(service_docs.summary_html, 'This is my service.')
self.assertListEqual(service_invoked_by, [])
self.assertListEqual(service_invokes, ['abc.def', 'qwe.rty'])
self.assertEqual(service_namespace_name, '')
sio_openapi_v3 = service_simple_io.openapi_v3 # type: Bunch
sio_soap_12 = service_simple_io.soap_12 # type: Bunch
sio_zato = service_simple_io.zato # type: Bunch
self.assertEqual(len(sio_openapi_v3.input_required), 2)
# OpenAPI
sio_openapi_v3_input_required_0 = sio_openapi_v3.input_required[0] # type: Bunch
sio_openapi_v3_input_required_1 = sio_openapi_v3.input_required[1] # type: Bunch
self.assertEqual(sio_openapi_v3_input_required_0.name, 'input_req_customer_id')
self.assertEqual(sio_openapi_v3_input_required_0.description, '')
self.assertEqual(sio_openapi_v3_input_required_0.type, 'integer')
self.assertEqual(sio_openapi_v3_input_required_0.subtype, 'int32')
self.assertEqual(sio_openapi_v3_input_required_1.name, 'input_req_user_id')
self.assertEqual(sio_openapi_v3_input_required_1.description,
'This is the first line.\nHere is another.\nAnd here are some more lines.')
self.assertEqual(sio_openapi_v3_input_required_1.type, 'integer')
self.assertEqual(sio_openapi_v3_input_required_1.subtype, 'int32')
# SOAP 1.2
sio_soap_12_input_required_0 = sio_soap_12.input_required[0] # type: Bunch
sio_soap_12_input_required_1 = sio_soap_12.input_required[1] # type: Bunch
self.assertEqual(sio_soap_12_input_required_0.name, 'input_req_customer_id')
self.assertEqual(sio_soap_12_input_required_0.description, '')
self.assertEqual(sio_soap_12_input_required_0.type, 'integer')
self.assertEqual(sio_soap_12_input_required_0.subtype, 'xsd:integer')
self.assertEqual(sio_soap_12_input_required_1.name, 'input_req_user_id')
self.assertEqual(sio_soap_12_input_required_1.description,
'This is the first line.\nHere is another.\nAnd here are some more lines.')
self.assertEqual(sio_soap_12_input_required_1.type, 'integer')
self.assertEqual(sio_soap_12_input_required_1.subtype, 'xsd:integer')
# Zato
sio_zato_input_required_0 = sio_zato.input_required[0] # type: Bunch
sio_zato_input_required_1 = sio_zato.input_required[1] # type: Bunch
self.assertEqual(sio_zato_input_required_0.name, 'input_req_customer_id')
self.assertEqual(sio_zato_input_required_0.description, '')
self.assertEqual(sio_zato_input_required_0.type, 'integer')
self.assertEqual(sio_zato_input_required_0.subtype, 'integer')
self.assertEqual(sio_zato_input_required_1.name, 'input_req_user_id')
self.assertEqual(sio_zato_input_required_1.description,
'This is the first line.\nHere is another.\nAnd here are some more lines.')
self.assertEqual(sio_zato_input_required_1.type, 'integer')
self.assertEqual(sio_zato_input_required_1.subtype, 'integer')
