def test_blueprint_route_on_method_view(app, client):
bp = APIBlueprint('test', __name__, tag='foo')
@bp.route('/')
class Foo(MethodView):
def get(self):
return 'get'
def post(self):
return 'post'
def delete(self):
return 'delete'
def put(self):
return 'put'
def patch(self):
return 'patch'
app.register_blueprint(bp)
rv = client.get('/')
assert rv.data == b'get'
rv = client.post('/')
assert rv.data == b'post'
rv = client.delete('/')
assert rv.data == b'delete'
rv = client.put('/')
assert rv.data == b'put'
rv = client.patch('/')
assert rv.data == b'patch'
def test_skip_raw_blueprint(app, client):
raw_bp = Blueprint('raw', __name__)
api_bp = APIBlueprint('api', __name__, tag='test')
@raw_bp.route('/foo')
def foo():
pass
@raw_bp.route('/bar')
class Bar(MethodView):
def get(self):
pass
@api_bp.get('/baz')
def baz():
pass
@api_bp.route('/spam')
class Spam(MethodView):
def get(self):
pass
app.register_blueprint(raw_bp)
app.register_blueprint(api_bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags'] == [{'name': 'test'}]
assert '/foo' not in rv.json['paths']
assert '/bar' not in rv.json['paths']
assert '/baz' in rv.json['paths']
assert '/spam' in rv.json['paths']
def test_blueprint_enable_openapi_with_methodview(app, client):
auth = HTTPBasicAuth()
@app.get('/hello')
@auth_required(auth)
def hello():
pass
bp = APIBlueprint('foo', __name__, tag='test', enable_openapi=False)
auth = HTTPTokenAuth()
@bp.before_request
@auth_required(auth)
def before():
pass
@bp.route('/foo')
class Foo(MethodView):
def get(self):
pass
def post(self):
pass
app.register_blueprint(bp)
rv = client.get('/foo')
assert rv.status_code == 401
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags'] == []
assert '/hello' in rv.json['paths']
assert '/foo' not in rv.json['paths']
assert 'BearerAuth' not in rv.json['components']['securitySchemes']
def test_auto_tag_from_blueprint(app, client):
bp = APIBlueprint('foo', __name__)
app.register_blueprint(bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags']
assert {'name': 'Foo'} in rv.json['tags']
def test_skip_tag_from_blueprint(app, client):
bp = APIBlueprint('foo', __name__)
app.config['DOCS_HIDE_BLUEPRINTS'] = ['foo']
app.register_blueprint(bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags'] == []
assert {'name': 'Foo'} not in rv.json['tags']
def test_path_tags_with_blueprint_tag(app, client, tag):
bp = APIBlueprint('foo', __name__, tag=tag)
@bp.get('/')
def foo():
pass
app.register_blueprint(bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['paths']['/']['get']['tags'] == ['test']
def test_auto_tags(app, client):
bp = APIBlueprint('foo', __name__)
app.config['AUTO_TAGS'] = False
@bp.get('/')
def foo():
pass
app.register_blueprint(bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags'] == []
assert 'tags' not in rv.json['paths']['/']['get']
def test_auth_required_at_blueprint_before_request(app, client):
bp = APIBlueprint('test', __name__)
auth = HTTPTokenAuth()
@bp.before_request
@auth_required(auth)
def before():
pass
@bp.get('/foo')
def foo():
pass
@bp.get('/bar')
def bar():
pass
@bp.route('/baz')
class Baz(MethodView):
def get(self):
pass
def post(self):
pass
app.register_blueprint(bp)
rv = client.get('/foo')
assert rv.status_code == 401
rv = client.get('/bar')
assert rv.status_code == 401
rv = client.get('/baz')
assert rv.status_code == 401
rv = client.post('/baz')
assert rv.status_code == 401
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert 'BearerAuth' in rv.json['components']['securitySchemes']
assert rv.json['components']['securitySchemes']['BearerAuth'] == {
'scheme': 'Bearer',
'type': 'http'
}
assert 'BearerAuth' in rv.json['paths']['/foo']['get']['security'][0]
assert 'BearerAuth' in rv.json['paths']['/bar']['get']['security'][0]
assert 'BearerAuth' in rv.json['paths']['/baz']['get']['security'][0]
assert 'BearerAuth' in rv.json['paths']['/baz']['post']['security'][0]
def test_docs_hide_blueprints(app, client):
bp = APIBlueprint('foo', __name__, tag='test')
@bp.get('/foo')
def foo():
pass
app.config['DOCS_HIDE_BLUEPRINTS'] = ['foo']
app.register_blueprint(bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags'] == []
assert '/foo' not in rv.json['paths']
def test_dispatch_static_request(app, client):
# keyword arguments
rv = client.get('/static/hello.css') # endpoint: static
assert rv.status_code == 404
# positional arguments
@app.get('/mystatic/<int:pet_id>')
@input(FooSchema)
def mystatic(pet_id, foo): # endpoint: mystatic
return {'pet_id': pet_id, 'foo': foo}
rv = client.get('/mystatic/2', json={'id': 1, 'name': 'foo'})
assert rv.status_code == 200
assert rv.json['pet_id'] == 2
assert rv.json['foo'] == {'id': 1, 'name': 'foo'}
# positional arguments
# blueprint static route accepts both keyword/positional arguments
bp = APIBlueprint('foo', __name__, static_folder='static')
app.register_blueprint(bp, url_prefix='/foo')
rv = client.get('/foo/static/hello.css') # endpoint: foo.static
assert rv.status_code == 404
def test_tag_from_blueprint(app, client):
tag = {
'name': 'foo',
'description': 'some description for foo',
'externalDocs': {
'description': 'Find more info about foo here',
'url': 'https://docs.example.com/'
}
}
bp = APIBlueprint('test', __name__, tag=tag)
app.register_blueprint(bp)
rv = client.get('/openapi.json')
assert rv.status_code == 200
validate_spec(rv.json)
assert rv.json['tags']
assert rv.json['tags'][0]['name'] == 'foo'
assert rv.json['tags'][0]['description'] == 'some description for foo'
assert rv.json['tags'][0]['externalDocs'][
'description'] == 'Find more info about foo here'
assert rv.json['tags'][0]['externalDocs'][
'url'] == 'https://docs.example.com/'
def test_auth_required_at_app_before_request(app, client):
auth = HTTPBasicAuth()
@auth.verify_password
def verify_password(username, password):
if username == 'foo' and password == 'bar':
return {'user': '******'}
@app.before_request
@auth_required(auth)
def before():
pass
@app.get('/foo')
def foo():
pass
@app.route('/bar')
class Bar(MethodView):
def get(self):
pass
def post(self):
pass
bp = APIBlueprint('test', __name__)
@bp.get('/baz')
def baz():
pass
@bp.get('/eggs')
def eggs():
pass
app.register_blueprint(bp)
rv = client.get('/foo')
assert rv.status_code == 401
rv = client.get('/bar')
assert rv.status_code == 401
rv = client.post('/bar')
assert rv.status_code == 401
rv = client.get('/baz')
assert rv.status_code == 401
rv = client.get('/eggs')
assert rv.status_code == 401
rv = client.get('/openapi.json',
headers={'Authorization': 'Basic Zm9vOmJhcg=='})
assert rv.status_code == 200
validate_spec(rv.json)
assert 'BasicAuth' in rv.json['components']['securitySchemes']
assert rv.json['components']['securitySchemes']['BasicAuth'] == {
'scheme': 'Basic',
'type': 'http'
}
assert 'BasicAuth' in rv.json['paths']['/foo']['get']['security'][0]
assert 'BasicAuth' in rv.json['paths']['/bar']['get']['security'][0]
assert 'BasicAuth' in rv.json['paths']['/bar']['post']['security'][0]
assert 'BasicAuth' in rv.json['paths']['/baz']['get']['security'][0]
assert 'BasicAuth' in rv.json['paths']['/eggs']['get']['security'][0]
"""
Some description for my tag from module doc.
"""
from apiflask import APIFlask, APIBlueprint
app = APIFlask(__name__)
bp = APIBlueprint('foo', __name__)
@bp.get('/')
def hello():
return {'message': 'Hello World!'}
app.register_blueprint(bp)
from apiflask import APIBlueprint, abort, output, input
from apiflaskdemo.project.auth import login_required
from apiflaskdemo.project.models import db, Alumno
from apiflaskdemo.project.schemas import AlumnoSchema, AlumnoInSchema
from marshmallow.exceptions import ValidationError
abc_alumnos = APIBlueprint('abc_alumno', __name__)
@abc_alumnos.get("/")
@output(AlumnoSchema(many=True))
def vuelca_base():
return Alumno.query.all()
@abc_alumnos.get("/<int:cuenta>")
@output(AlumnoSchema)
def despliega_alumno(cuenta):
return Alumno.query.get_or_404(cuenta)
@abc_alumnos.delete("/<int:cuenta>")
@output(AlumnoSchema)
@login_required
def elimina_alumno(cuenta):
alumno = Alumno.query.get_or_404(cuenta)
db.session.delete(alumno)
db.session.commit()
return alumno
@abc_alumnos.post("/<int:cuenta>")
@output(AlumnoSchema)
@input(AlumnoInSchema)
def crea_alumno(cuenta, data):
"""
MIT License
Copyright(c) 2021 Andy Zhou
"""
from apiflask import APIBlueprint
from flask_cors import CORS
api_v3 = APIBlueprint("api_v3", __name__)
CORS(api_v3)
from . import views
from apiflaskdemo.project.models import User
from apiflask import APIBlueprint, abort, input, output
from apiflask.fields import String
from apiflaskdemo.project.auth.schemas import LoginSchema
from flask import session, g
auth_bp = APIBlueprint("auth_bp", __name__)
@auth_bp.before_app_request
def user_checkout():
user_id = session.get("user_id")
if user_id is None:
g.user = None
else:
g.user = User.query.filter_by(id=user_id).first()
@auth_bp.post("/login")
@input(LoginSchema)
def login(data):
user = User.query.filter_by(username=data["username"]).one_or_none()
if user and user.password == data["password"]:
session.clear()
session["user_id"] = user.id
return {'msg': 'logged in'}
else:
abort(403)
@auth_bp.get("/logout")
def test_blueprint_tag():
bp = APIBlueprint('test', __name__, tag='foo')
assert bp.name == 'test'
assert bp.tag == 'foo'
def test_blueprint_object():
bp = APIBlueprint('test', __name__)
assert bp.name == 'test'
assert hasattr(bp, 'tag')
assert bp.tag is None
