async def test_aiohttp_output_stream__ok__nominal_case(self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class AsyncGenerator: def __init__(self): self._iterator = iter([{"name": "Hello, bob"}, {"name": "Hello, franck"}]) async def __aiter__(self): return self async def __anext__(self): return next(self._iterator) class OuputStreamItemSchema(marshmallow.Schema): name = marshmallow.fields.String() @hapic.output_stream(OuputStreamItemSchema()) async def hello(request): return AsyncGenerator() app = web.Application(debug=True) app.router.add_get("/", hello) hapic.set_context( AiohttpContext(app, default_error_builder=MarshmallowDefaultErrorBuilder()) ) client = await aiohttp_client(app) resp = await client.get("/") assert resp.status == 200 line = await resp.content.readline() assert b'{"name": "Hello, bob"}\n' == line line = await resp.content.readline() assert b'{"name": "Hello, franck"}\n' == line
def test_func__schema_with_many__ok__with_exclude(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MySchema(marshmallow.Schema): first_name = marshmallow.fields.String(required=True) last_name = marshmallow.fields.String(required=False) @hapic.with_api_doc() @hapic.output_body(MySchema(many=True, exclude=("last_name", ))) def my_controller(hapic_data=None): pass app.route("/", method="GET", callback=my_controller) doc = hapic.generate_doc() assert { "MySchema_without_last_name": { "type": "object", "properties": { "first_name": { "type": "string" } }, "required": ["first_name"], } } == doc["definitions"]
async def test_unit__output_error__err__hook_called(self, aiohttp_client): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class OutputBodySchema(marshmallow.Schema): user_id = marshmallow.fields.Int(required=True) class MyContext(AiohttpContext): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.hook_called = False def output_validation_error_caught( self, hapic_data: HapicData, process_exception: ProcessException) -> None: self.hook_called = True @hapic.with_api_doc() @hapic.output_body(OutputBodySchema()) async def user(request): return {} app = web.Application(debug=True) context = MyContext(app) hapic.set_context(context) app.router.add_get("/user", user) client = await aiohttp_client(app) assert not context.hook_called await client.get("/user") assert context.hook_called
def test_unit__decoration__ok__method(self): hapic = Hapic() class MyControllers(object): @hapic.with_api_doc() def controller_a(self): pass my_controllers = MyControllers() class_method_token = getattr( MyControllers.controller_a, DECORATION_ATTRIBUTE_NAME, None, ) assert class_method_token instance_method_token = getattr( my_controllers.controller_a, DECORATION_ATTRIBUTE_NAME, None, ) assert instance_method_token assert hapic.controllers assert 1 == len(hapic.controllers) reference = hapic.controllers[0].reference assert class_method_token == reference.token assert instance_method_token == reference.token assert MyControllers.controller_a == reference.wrapper assert MyControllers.controller_a != reference.wrapped assert my_controllers.controller_a != reference.wrapper assert my_controllers.controller_a != reference.wrapped
def test_func__catch_one_exception__ok__pyramid(self): from pyramid.config import Configurator configurator = Configurator(autocommit=True) context = PyramidContext( configurator, default_error_builder=MarshmallowDefaultErrorBuilder()) hapic = Hapic(processor_class=MarshmallowProcessor) hapic.set_context(context) def my_view(context, request): raise ZeroDivisionError("An exception message") configurator.add_route("my_view", "/my-view", request_method="GET") configurator.add_view(my_view, route_name="my_view", renderer="json") # FIXME - G.M - 17-05-2018 - Verify if: # - other view that work/raise an other exception do not go # into this code for handle this exceptions. # - response come clearly from there, not from web framework: # Check not only http code, but also body. # see issue #158 (https://github.com/algoo/hapic/issues/158) context.handle_exception(ZeroDivisionError, http_code=400) app = configurator.make_wsgi_app() test_app = TestApp(app) response = test_app.get("/my-view", status="*") assert 400 == response.status_code
async def test_unit__handle_exception_with_default_error_builder__ok__serpyco( self, test_client): from hapic.error.serpyco import SerpycoDefaultErrorBuilder from hapic.processor.serpyco import SerpycoProcessor app = AgnosticApp() hapic = Hapic() hapic.set_processor_class(SerpycoProcessor) hapic.set_context( AgnosticContext( app, default_error_builder=SerpycoDefaultErrorBuilder())) @hapic.with_api_doc() @hapic.handle_exception(ZeroDivisionError, http_code=400) def my_view(): 1 / 0 response = my_view() json_ = json.loads(response.body) assert { "code": None, "details": { "error_detail": {} }, "message": "division by zero", } == json_
async def test_aiohttp_output_stream__error__interrupt_py37( self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class OuputStreamItemSchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) from .py37.stream import get_func_with_output_stream_and_error hello = get_func_with_output_stream_and_error(hapic, OuputStreamItemSchema, ignore_on_error=False) app = web.Application(debug=True) app.router.add_get("/", hello) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) client = await aiohttp_client(app) resp = await client.get("/") assert resp.status == 200 line = await resp.content.readline() assert b'{"name": "Hello, bob"}\n' == line line = await resp.content.readline() assert b"" == line
async def test_aiohttp_input_body__error__incorrect_input_body( self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class InputBodySchema(marshmallow.Schema): i = marshmallow.fields.Integer() @hapic.input_body(InputBodySchema()) async def hello(request, hapic_data: HapicData): i = hapic_data.body.get("i") return web.Response(text="integer, {}".format(i)) app = web.Application(debug=True) app.router.add_post("/", hello) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) client = await aiohttp_client(app) resp = await client.post("/", data={"i": "bob"}) # NOTE: should be int assert resp.status == 400 error = await resp.json() assert "Validation error of input data" in error.get("message") assert {"i": ["Not a valid integer."]} == error.get("details")
async def test_aiohttp_output_body__error__incorrect_output_body( self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class OuputBodySchema(marshmallow.Schema): i = marshmallow.fields.Integer(required=True) @hapic.output_body(OuputBodySchema()) async def hello(request): return {"i": "bob"} # NOTE: should be integer app = web.Application(debug=True) app.router.add_get("/", hello) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) client = await aiohttp_client(app) resp = await client.get("/") assert resp.status == 500 data = await resp.text() data = await resp.json() assert "Validation error of output data" == data.get("message") assert { "i": ["Missing data for required field."] } == data.get("details")
async def test_unit__input_error__err__hook_called(self, aiohttp_client): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class InputPathSchema(marshmallow.Schema): user_id = marshmallow.fields.Int(required=True) class MyContext(AiohttpContext): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.hook_called = None def input_validation_error_caught( self, request_parameters: RequestParameters, process_exception: ProcessException) -> None: self.hook_called = request_parameters @hapic.with_api_doc() @hapic.input_path(InputPathSchema()) async def user(): pass app = web.Application(debug=True) context = MyContext(app) hapic.set_context(context) app.router.add_get("/user", user) client = await aiohttp_client(app) assert not context.hook_called await client.get("/user?foo=bar") assert context.hook_called.query_parameters.get("foo") == "bar"
async def test_unit__general_exception_handling__ok__nominal_case( self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) @hapic.with_api_doc() async def hello(request): return 1 / 0 app = web.Application(debug=True) app.router.add_get("/", hello) context = AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder()) context.handle_exception(ZeroDivisionError, 400) hapic.set_context(context) client = await aiohttp_client(app) resp = await client.get("/") json = await resp.json() assert resp.status == 400 assert { "details": { "error_detail": {} }, "message": "division by zero", "code": None, } == json
def test_func__input_files_doc__ok__one_file_and_text(self): hapic = Hapic() hapic.set_context(MyContext()) app = bottle.Bottle() class MySchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) class MyFilesSchema(marshmallow.Schema): file_abc = marshmallow.fields.Raw(required=True) @hapic.with_api_doc() @hapic.input_files(MyFilesSchema()) @hapic.input_body(MySchema()) def my_controller(hapic_data=None): assert hapic_data assert hapic_data.files app.route('/upload', method='POST', callback=my_controller) doc = hapic.generate_doc(app) assert doc assert '/upload' in doc['paths'] assert 'consume' in doc['paths']['/upload']['post'] assert 'multipart/form-data' in doc['paths']['/upload']['post'][ 'consume'] assert 'parameters' in doc['paths']['/upload']['post'] assert { 'name': 'file_abc', 'required': True, 'in': 'formData', 'type': 'file', } in doc['paths']['/upload']['post']['parameters']
async def test_aiohttp_input_path__error_wrong_input_parameter( self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class InputPathSchema(marshmallow.Schema): i = marshmallow.fields.Integer() @hapic.input_path(InputPathSchema()) async def hello(request, hapic_data: HapicData): i = hapic_data.path.get("i") return web.Response(text="integer: {}".format(str(i))) app = web.Application(debug=True) app.router.add_get("/{i}", hello) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) client = await aiohttp_client(app) resp = await client.get("/bob") # NOTE: should be integer here assert resp.status == 400 error = await resp.json() assert "Validation error of input data" in error.get("message") assert {"i": ["Not a valid integer."]} == error.get("details")
def test_func_schema_in_doc__ok__additionals_fields__file(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MySchema(marshmallow.Schema): category = marshmallow.fields.Raw(required=True, description="a description", example="00010") @hapic.with_api_doc() @hapic.input_files(MySchema()) def my_controller(): return app.route("/upload", method="POST", callback=my_controller) doc = hapic.generate_doc() assert doc assert "/upload" in doc["paths"] assert "consumes" in doc["paths"]["/upload"]["post"] assert "multipart/form-data" in doc["paths"]["/upload"]["post"][ "consumes"] assert doc.get("paths").get("/upload").get("post").get("parameters")[0] field = doc.get("paths").get("/upload").get("post").get( "parameters")[0] assert field[ "description"] == "a description\n\n*example value: 00010*" # INFO - G.M - 01-06-2018 - Field example not allowed here, # added in description instead assert "example" not in field assert field["in"] == "formData" assert field["type"] == "file" assert field["required"] is True
async def test_unit__post_file__ok__put_success(self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class InputFilesSchema(marshmallow.Schema): avatar = marshmallow.fields.Raw() @hapic.with_api_doc() @hapic.input_files(InputFilesSchema()) async def update_avatar(request: Request, hapic_data: HapicData): avatar = hapic_data.files["avatar"] assert isinstance(avatar, FileField) assert b"text content of file" == avatar.file.read() return Response(body="ok") app = web.Application(debug=True) app.router.add_put("/avatar", update_avatar) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) client = await aiohttp_client(app) resp = await client.put( "/avatar", data={"avatar": io.StringIO("text content of file")}) assert resp.status == 200
async def test_unit__post_file__ok__missing_file(self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class InputFilesSchema(marshmallow.Schema): avatar = marshmallow.fields.Raw(required=True) @hapic.with_api_doc() @hapic.input_files(InputFilesSchema()) async def update_avatar(request: Request, hapic_data: HapicData): raise AssertionError("Test should no pass here") app = web.Application(debug=True) app.router.add_put("/avatar", update_avatar) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) client = await aiohttp_client(app) resp = await client.put("/avatar") assert resp.status == 400 json_ = await resp.json() assert { "details": { "avatar": ["Missing data for required field"] }, "message": "Validation error of input data", "code": None, } == json_
def test_func__schema_in_doc__ok__many_case(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MySchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) @hapic.with_api_doc() @hapic.input_body(MySchema(many=True)) def my_controller(): return {"name": "test"} app.route("/paper", method="POST", callback=my_controller) doc = hapic.generate_doc() assert doc.get("definitions", {}).get("MySchema", {}) schema_def = doc.get("definitions", {}).get("MySchema", {}) assert schema_def.get("properties", {}).get("name", {}).get("type") assert doc.get("paths").get("/paper").get("post").get("parameters")[0] schema_ref = doc.get("paths").get("/paper").get("post").get( "parameters")[0] assert schema_ref.get("in") == "body" assert schema_ref.get("name") == "body" assert schema_ref["schema"] == { "items": { "$ref": "#/definitions/MySchema" }, "type": "array", }
def test_func__errors__http_status_as_int_description(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MyException(Exception): pass @hapic.with_api_doc() @hapic.handle_exception(MyException, http_code=400) def my_controller(hapic_data=None): assert hapic_data app.route("/upload", method="POST", callback=my_controller) doc = hapic.generate_doc() assert doc.get("paths") assert "/upload" in doc["paths"] assert "post" in doc["paths"]["/upload"] assert "responses" in doc["paths"]["/upload"]["post"] assert "400" in doc["paths"]["/upload"]["post"]["responses"] assert { "description": "400", "schema": { "$ref": "#/definitions/DefaultErrorSchema" }, } == doc["paths"]["/upload"]["post"]["responses"]["400"]
def test_func__input_files_doc__ok__one_file(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MySchema(marshmallow.Schema): file_abc = marshmallow.fields.Raw(required=True) @hapic.with_api_doc() @hapic.input_files(MySchema()) def my_controller(hapic_data=None): assert hapic_data assert hapic_data.files app.route("/upload", method="POST", callback=my_controller) doc = hapic.generate_doc() assert doc assert "/upload" in doc["paths"] assert "consumes" in doc["paths"]["/upload"]["post"] assert "multipart/form-data" in doc["paths"]["/upload"]["post"][ "consumes"] assert "parameters" in doc["paths"]["/upload"]["post"] assert { "name": "file_abc", "required": True, "in": "formData", "type": "file" } in doc["paths"]["/upload"]["post"]["parameters"]
def test_unit__input_files__ok__file_is_not_present(self): hapic = Hapic(processor_class=MarshmallowProcessor) hapic.set_context( AgnosticContext( app=None, files_parameters={ # No file here }, ) ) class MySchema(marshmallow.Schema): file_abc = marshmallow.fields.Raw(required=True) @hapic.input_files(MySchema()) def my_controller(hapic_data=None): assert hapic_data assert hapic_data.files return "OK" result = my_controller() assert HTTPStatus.BAD_REQUEST == result.status_code assert { "http_code": 400, "original_error": { "details": {"file_abc": ["Missing data for required field"]}, "message": "Validation error of input data", }, } == json.loads(result.body)
def test_unit__generate_output_stream_doc__ok__nominal_case( self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class OuputStreamItemSchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) @hapic.with_api_doc() @hapic.output_stream(OuputStreamItemSchema()) async def get_users(request, hapic_data): pass app = web.Application(debug=True) app.router.add_get("/", get_users) hapic.set_context( AiohttpContext( app, default_error_builder=MarshmallowDefaultErrorBuilder())) doc = hapic.generate_doc("aiohttp", "testing") # INFO BS 2019-04-15: Prevent keep of OrderedDict doc = json.loads(json.dumps(doc)) assert "/" in doc.get("paths") assert "get" in doc["paths"]["/"] assert "200" in doc["paths"]["/"]["get"].get("responses", {}) assert { "items": { "$ref": "#/definitions/OuputStreamItemSchema" }, "type": "array" } == doc["paths"]["/"]["get"]["responses"]["200"]["schema"]
async def test_unit__global_exception__ok__hook_called( self, aiohttp_client): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class MyContext(AiohttpContext): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.hook_called = False def global_exception_caught(self, exc: Exception, *args, **kwargs) -> None: self.hook_called = True @hapic.with_api_doc() async def divide_by_zero(request): raise ZeroDivisionError() app = web.Application(debug=True) context = MyContext(app) hapic.set_context(context) context.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST) app.router.add_get("/", divide_by_zero) client = await aiohttp_client(app) assert not context.hook_called await client.get("/") assert context.hook_called
def test_unit__generate_doc__ok__nominal_case(self, aiohttp_client, loop): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) class InputPathSchema(marshmallow.Schema): username = marshmallow.fields.String(required=True) class InputQuerySchema(marshmallow.Schema): show_deleted = marshmallow.fields.Boolean(required=False) class UserSchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) @hapic.with_api_doc() @hapic.input_path(InputPathSchema()) @hapic.input_query(InputQuerySchema()) @hapic.output_body(UserSchema()) async def get_user(request, hapic_data): pass @hapic.with_api_doc() @hapic.input_path(InputPathSchema()) @hapic.output_body(UserSchema()) async def post_user(request, hapic_data): pass app = web.Application(debug=True) app.router.add_get("/{username}", get_user) app.router.add_post("/{username}", post_user) hapic.set_context( AiohttpContext(app, default_error_builder=MarshmallowDefaultErrorBuilder()) ) doc = hapic.generate_doc("aiohttp", "testing") # INFO BS 2019-04-15: Prevent keep of OrderedDict doc = json.loads(json.dumps(doc)) assert "UserSchema" in doc.get("definitions") assert {"name": {"type": "string"}} == doc["definitions"]["UserSchema"].get("properties") assert "/{username}" in doc.get("paths") assert "get" in doc["paths"]["/{username}"] assert "post" in doc["paths"]["/{username}"] assert [ {"name": "username", "in": "path", "required": True, "type": "string"}, {"name": "show_deleted", "in": "query", "required": False, "type": "boolean"}, ] == doc["paths"]["/{username}"]["get"]["parameters"] assert { "200": {"schema": {"$ref": "#/definitions/UserSchema"}, "description": "200"} } == doc["paths"]["/{username}"]["get"]["responses"] assert [{"name": "username", "in": "path", "required": True, "type": "string"}] == doc[ "paths" ]["/{username}"]["post"]["parameters"] assert { "200": {"schema": {"$ref": "#/definitions/UserSchema"}, "description": "200"} } == doc["paths"]["/{username}"]["get"]["responses"]
def test_func__errors__multiple_same_http_status_description(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MyFirstException(Exception): pass class MySecondException(Exception): "Just a docstring" class MyThirdException(Exception): "Docstring not used" pass class MyFourthException(Exception): pass @hapic.with_api_doc() @hapic.handle_exception(MyFirstException, http_code=HTTPStatus.BAD_REQUEST) @hapic.handle_exception(MySecondException, http_code=HTTPStatus.BAD_REQUEST) @hapic.handle_exception(MyThirdException, http_code=HTTPStatus.BAD_REQUEST, description="explicit description") @hapic.handle_exception(MyFourthException, http_code=400) def my_controller(hapic_data=None): assert hapic_data app.route("/upload", method="POST", callback=my_controller) doc = hapic.generate_doc() assert doc.get("paths") assert "/upload" in doc["paths"] assert "post" in doc["paths"]["/upload"] assert "responses" in doc["paths"]["/upload"]["post"] assert "400" in doc["paths"]["/upload"]["post"]["responses"] assert "description" assert doc["paths"]["/upload"]["post"]["responses"]["400"][ "description"] descriptions = doc["paths"]["/upload"]["post"]["responses"]["400"][ "description"].split("\n\n") assert "BAD_REQUEST: Bad request syntax or unsupported method" in descriptions assert "explicit description" in descriptions assert "400" in descriptions assert "Just a docstring" in descriptions assert "Docstring not used" not in descriptions assert doc["paths"]["/upload"]["post"]["responses"]["400"]["schema"] assert { "$ref": "#/definitions/DefaultErrorSchema" } == doc["paths"]["/upload"]["post"]["responses"]["400"]["schema"]
async def test_unit__handle_exception__ok__nominal_case(self, aiohttp_client): hapic = Hapic(async_=True, processor_class=MarshmallowProcessor) @hapic.with_api_doc() @hapic.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST) async def divide_by_zero(request): raise ZeroDivisionError() app = web.Application(debug=True) hapic.set_context(AiohttpContext(app)) app.router.add_get("/", divide_by_zero) client = await aiohttp_client(app) response = await client.get("/") assert 400 == response.status
def test_unit__input_files__ok__file_is_present(self): hapic = Hapic(processor_class=MarshmallowProcessor) hapic.set_context(AgnosticContext(app=None, files_parameters={"file_abc": "10101010101"})) class MySchema(marshmallow.Schema): file_abc = marshmallow.fields.Raw(required=True) @hapic.input_files(MySchema()) def my_controller(hapic_data=None): assert hapic_data assert hapic_data.files return "OK" result = my_controller() assert "OK" == result
def test_func_schema_in_doc__ok__additionals_fields__forms__string(self): hapic = Hapic(processor_class=MarshmallowProcessor) app = AgnosticApp() hapic.set_context(AgnosticContext(app=app)) class MySchema(marshmallow.Schema): category = marshmallow.fields.String( required=True, description="a description", example="00010", format="binary", enum=["01000", "11111"], maxLength=5, minLength=5, # Theses none string specific parameters should disappear # in query/path maximum=400, # exclusiveMaximun=False, # minimum=0, # exclusiveMinimum=True, # multipleOf=1, ) @hapic.with_api_doc() @hapic.input_forms(MySchema()) def my_controller(): return app.route("/paper", method="POST", callback=my_controller) doc = hapic.generate_doc() assert "multipart/form-data" in doc["paths"]["/paper"]["post"][ "consumes"] assert doc.get("paths").get("/paper").get("post").get("parameters")[0] field = doc.get("paths").get("/paper").get("post").get("parameters")[0] assert field[ "description"] == "a description\n\n*example value: 00010*" # INFO - G.M - 01-06-2018 - Field example not allowed here, # added in description instead assert "example" not in field assert field["format"] == "binary" assert field["in"] == "formData" assert field["type"] == "string" assert field["maxLength"] == 5 assert field["minLength"] == 5 assert field["required"] is True assert field["enum"] == ["01000", "11111"] assert "maximum" not in field
def get_bottle_context(): h = Hapic(processor_class=MarshmallowProcessor) bottle_app = Bottle() h.reset_context() h.set_context(BottleContext(bottle_app, default_error_builder=MarshmallowDefaultErrorBuilder())) class MySchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) @h.with_api_doc() @h.input_body(MySchema()) def my_controller(): return {"name": "test"} bottle_app.route("/test", method="POST", callback=my_controller) return {"hapic": h, "app": bottle_app}
def get_flask_context(): h = Hapic(processor_class=MarshmallowProcessor) flask_app = Flask(__name__) h.reset_context() h.set_context(FlaskContext(flask_app, default_error_builder=MarshmallowDefaultErrorBuilder())) class MySchema(marshmallow.Schema): name = marshmallow.fields.String(required=True) @h.with_api_doc() @h.input_body(MySchema()) def my_controller(): return {"name": "test"} flask_app.add_url_rule("/test", view_func=my_controller, methods=["POST"]) return {"hapic": h, "app": flask_app}
def test_unit__decoration__ok__simple_function(self): hapic = Hapic() @hapic.with_api_doc() def controller_a(): pass token = getattr(controller_a, DECORATION_ATTRIBUTE_NAME, None) assert token assert hapic.controllers assert 1 == len(hapic.controllers) reference = hapic.controllers[0].reference assert token == reference.token assert controller_a == reference.wrapper assert controller_a != reference.wrapped