def test_mock_resolver():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'examples': {
'application/json': {
'foo': 'bar'
}
}
}
}
operation = Operation(method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_mock_resolver_no_examples():
resolver = MockResolver(mock_all=True)
responses = {
'418': {}
}
operation = Operation(method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 418
assert response == 'No example response was defined.'
def test_mock_resolver_no_example_nested_in_list_openapi():
resolver = MockResolver(mock_all=True)
responses = {
'202': {
'content': {
'application/json': {
'schema': {
'type': 'array',
'items': {
'type': 'string',
}
}
}
}
}
}
operation = OpenAPIOperation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={'responses': responses},
app_security=[],
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 202
assert response == 'No example response was defined.'
def test_mock_resolver():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'content': {
'application/json': {
'examples': {
"super_cool_example": {
'foo': 'bar'
}
}
}
}
}
}
operation = OpenAPIOperation(
api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_security=[],
resolver=resolver
)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_mock_resolver_example_nested_in_object():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'schema': {
'type': 'object',
'properties': {
'foo': {
'type': 'string',
'example': 'bar'
}
},
}
}
}
operation = Swagger2Operation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={'responses': responses},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_mock_resolver_no_examples():
resolver = MockResolver(mock_all=True)
responses = {
'418': {}
}
operation = Operation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 418
assert response == 'No example response was defined.'
def test_mock_resolver():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'content': {
'application/json': {
'examples': {
"super_cool_example": {
'foo': 'bar'
}
}
}
}
}
}
operation = OpenAPIOperation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={'responses': responses},
app_security=[],
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_mock_resolver_numeric():
resolver = MockResolver(mock_all=True)
responses = {
'200': {
'examples': {
'application/json': {
'foo': 'bar'
}
}
}
}
operation = Swagger2Operation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_api_service(service):
"""
Creates a mocked interface for each specified swagger spec and creates
a server to ensure swagger validates fully.
If invalid specs are detected the spec will raise `InvalidSpecification`.
Further enhancement of this test is to make actual requests to the Apps
generated.
"""
port = 8081
name = service.rsplit("/", 3)[2]
resolver = MockResolver(mock_all="all")
api_extra_args = {"resolver": resolver}
options = {"serve_spec": False, "swagger_ui": False}
app = connexion.FlaskApp(name, options=options)
app.add_api(
service,
resolver_error=True,
validate_responses=True,
strict_validation=True,
**api_extra_args
)
client = app.app.test_client()
def test_mock_resolver_notimplemented():
resolver = MockResolver(mock_all=False)
responses = {'418': {}}
# do not mock the existent functions
operation = OpenAPIOperation(
api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={'operationId': 'fakeapi.hello.get'},
app_security=[],
resolver=resolver)
assert operation.operation_id == 'fakeapi.hello.get'
# mock only the nonexistent ones
operation = OpenAPIOperation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'operationId':
'fakeapi.hello.nonexistent_function',
'responses': responses
},
app_security=[],
resolver=resolver)
# check if it is using the mock function
assert operation._resolution.function() == (
'No example response was defined.', 418)
def test_mock_resolver_inline_schema_example():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'content': {
'application/json': {
'schema': {
'type': 'object',
'properties': {
'foo': {
'schema': {
'type': 'string'
}
}
}
},
'example': {
'foo': 'bar'
}
}
}
}
}
operation = OpenAPIOperation(
api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_security=[],
resolver=resolver
)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def run(spec_file, base_module_path, port, host, wsgi_server, stub, mock,
hide_spec, hide_console_ui, console_ui_url, console_ui_from,
auth_all_paths, validate_responses, strict_validation, debug, verbose,
base_path):
"""
Runs a server compliant with a OpenAPI/Swagger 2.0 Specification file.
Arguments:
- SPEC_FILE: specification file that describes the server endpoints.
- BASE_MODULE_PATH (optional): filesystem path where the API endpoints handlers are going to be imported from.
"""
logging_level = logging.WARN
if verbose > 0:
logging_level = logging.INFO
if debug or verbose > 1:
logging_level = logging.DEBUG
debug = True
logging.basicConfig(level=logging_level)
spec_file_full_path = path.abspath(spec_file)
py_module_path = base_module_path or path.dirname(spec_file_full_path)
sys.path.insert(1, path.abspath(py_module_path))
logger.debug('Added {} to system path.'.format(py_module_path))
resolver_error = None
if stub:
resolver_error = 501
api_extra_args = {}
if mock:
resolver = MockResolver(mock_all=mock == 'all')
api_extra_args['resolver'] = resolver
app = connexion.App(__name__,
swagger_json=not hide_spec,
swagger_ui=not hide_console_ui,
swagger_path=console_ui_from or None,
swagger_url=console_ui_url or None,
auth_all_paths=auth_all_paths,
debug=debug)
app.add_api(spec_file_full_path,
base_path=base_path,
resolver_error=resolver_error,
validate_responses=validate_responses,
strict_validation=strict_validation,
**api_extra_args)
app.run(port=port, host=host, server=wsgi_server, debug=debug)
def test_api_service(self):
"""
Creates a mocked interface for each specified swagger spec and runs a server with a forked process to ensure swagger validates fully.
:return:
"""
port = 8088
for swagger in self.service_swaggers:
swagger = os.path.join(self.prefix, swagger)
pid = os.fork()
if not pid:
name = swagger.split('/')[2]
print(('Starting server for: {} at: {}'.format(name, swagger)))
resolver = MockResolver(mock_all='all')
api_extra_args ={'resolver': resolver}
app = connexion.FlaskApp(name,
swagger_json=False,
swagger_ui=False)
app.add_api(swagger + '/swagger.yaml',
resolver_error=True,
validate_responses=True,
strict_validation=True,
**api_extra_args)
app.run(port=port)
else:
try:
print('Wait for pinging server')
# Let the api initialize
time.sleep(2)
try:
t = urllib.request.urlopen('http://localhost:{}/'.format(port))
t.close()
except Exception as e:
print(('Fetch error: {}'.format(e)))
print('Killing child pid')
os.kill(pid, signal.SIGKILL)
print('Killed')
time.sleep(1)
except (KeyboardInterrupt, Exception) as e:
os.kill(pid, signal.SIGKILL)
raise
port +=1
def test_mock_resolver_no_examples():
resolver = MockResolver(mock_all=True)
responses = {
'418': {}
}
operation = OpenAPIOperation(
api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_security=[],
resolver=resolver
)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 418
assert response == 'No example response was defined.'
def test_mock_resolver_inline_schema_example():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'content': {
'application/json': {
'schema': {
'type': 'object',
'properties': {
'foo': {
'schema': {
'type': 'string'
}
}
}
},
'example': {
'foo': 'bar'
}
}
}
}
}
operation = OpenAPIOperation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={'responses': responses},
app_security=[],
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_mock_resolver_ref_schema_example():
resolver = MockResolver(mock_all=True)
responses = {
'default': {
'schema': {
'$ref': '#/definitions/Schema'
}
}
}
operation = Operation(api=None,
method='GET',
path='endpoint',
path_parameters=[],
operation={
'responses': responses
},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={
'Schema': {
'example': {
'foo': 'bar'
}
}
},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'mock-1'
response, status_code = resolver.mock_operation(operation)
assert status_code == 200
assert response == {'foo': 'bar'}
def test_mock_resolver_notimplemented():
resolver = MockResolver(mock_all=False)
operation = Operation(method='GET',
path='endpoint',
path_parameters=[],
operation={'operationId': 'fakeapi.hello.get'},
app_produces=['application/json'],
app_consumes=['application/json'],
app_security=[],
security_definitions={},
definitions={},
parameter_definitions={},
resolver=resolver)
assert operation.operation_id == 'fakeapi.hello.get'
def get_modcontracts(user, token_info, limit, type, from_, to_, juridic_type):
for modtype in type:
return json4test['contracts_20DHS']['contract_data'][:limit]
def get_f1_measures(user, token_info, limit, from_, to_, tariff):
return json4test['f1_contracts']['contract_data'][:limit]
def get_f1_measures_by_contract_id(user, token_info, contractId):
return json4test['f1_contract_id']['contract_data']
if __name__ == '__main__':
api_extra_args = {}
resolver = MockResolver(mock_all=False)
api_extra_args['resolver'] = resolver
app = connexion.FlaskApp(
__name__,
specification_dir=os.path.join(BASE_DIR, 'docs/'),
debug=True,
)
app.add_api('infoenergia-api.yaml',
validate_responses=True,
**api_extra_args)
app.run(host='localhost', port=8090)
def run(spec_file,
base_module_path,
port,
host,
wsgi_server,
server,
stub,
mock,
hide_spec,
hide_console_ui,
console_ui_url,
console_ui_from,
auth_all_paths,
validate_responses,
strict_validation,
debug,
verbose,
base_path,
app_framework):
"""
Runs a server compliant with a OpenAPI/Swagger 2.0 Specification file.
Arguments:
- SPEC_FILE: specification file that describes the server endpoints.
- BASE_MODULE_PATH (optional): filesystem path where the API endpoints handlers are going to be imported from.
"""
if wsgi_server and server:
raise click.BadParameter(
"these options are mutually exclusive",
param_hint="'wsgi-server' and 'server'"
)
elif wsgi_server:
server = wsgi_server
if server is None:
server = DEFAULT_SERVERS[app_framework]
if app_framework not in AVAILABLE_SERVERS[server]:
message = "Invalid server '{}' for app-framework '{}'".format(
server, app_framework
)
raise click.UsageError(message)
if app_framework == AIOHTTP_APP:
try:
import aiohttp # NOQA
except Exception:
fatal_error('aiohttp library is not installed')
logging_level = logging.WARN
if verbose > 0:
logging_level = logging.INFO
if debug or verbose > 1:
logging_level = logging.DEBUG
debug = True
logging.basicConfig(level=logging_level)
spec_file_full_path = path.abspath(spec_file)
py_module_path = base_module_path or path.dirname(spec_file_full_path)
sys.path.insert(1, path.abspath(py_module_path))
logger.debug('Added {} to system path.'.format(py_module_path))
resolver_error = None
if stub:
resolver_error = 501
api_extra_args = {}
if mock:
resolver = MockResolver(mock_all=mock == 'all')
api_extra_args['resolver'] = resolver
app_cls = connexion.utils.get_function_from_name(
AVAILABLE_APPS[app_framework]
)
options = {
"serve_spec": not hide_spec,
"swagger_path": console_ui_from or None,
"swagger_ui": not hide_console_ui,
"swagger_url": console_ui_url or None
}
app = app_cls(__name__,
debug=debug,
auth_all_paths=auth_all_paths,
options=options)
app.add_api(spec_file_full_path,
base_path=base_path,
resolver_error=resolver_error,
validate_responses=validate_responses,
strict_validation=strict_validation,
**api_extra_args)
app.run(port=port,
host=host,
server=server,
debug=debug)
def test_api_service():
"""
Creates a mocked interface for each specified swagger spec and runs a server with a forked process to ensure swagger validates fully.
:return:
"""
port = 8081
for swagger in service_swaggers:
pid = os.fork()
if not pid:
name = swagger.rsplit('/', 3)[2]
logger.info(
('Starting server for: {} at: {}'.format(name, swagger)))
resolver = MockResolver(mock_all='all')
api_extra_args = {'resolver': resolver}
app = connexion.FlaskApp(name,
swagger_json=False,
swagger_ui=False)
app.add_api(swagger,
resolver_error=True,
validate_responses=True,
strict_validation=True,
**api_extra_args)
app.run(port=port)
else:
try:
logger.info('Wait for pinging server of pid: {}'.format(pid))
# Let the api initialize
retries = 3
killed = False
for i in range(retries):
time.sleep(2)
proc_id, status = os.waitpid(pid, os.WNOHANG)
logger.info('Child pid: {}. Status = {}'.format(
pid, status))
if proc_id == 0 and status == 0:
try:
logger.info('Killing pid {}'.format(pid))
os.kill(pid, signal.SIGTERM)
killed = True
except ProcessLookupError:
logger.info(
'Process {} not found, skipping kill'.format(
pid))
finally:
break
elif status != 0 and killed:
logger.info('Confirmed child pid killed')
break
else:
pytest.fail(
'Mock service for {} failed to start properly'.
format(swagger))
break
except ProcessLookupError:
logger.info('Process {} not found. Exiting cleanly')
except (KeyboardInterrupt, Exception):
raise
finally:
try:
os.kill(pid, signal.SIGKILL)
except ProcessLookupError:
# This is expected
pass
except:
logger.exception("Failed to kill child process")
