Python FlaskIO示例

示例#1

class TestAuthorization(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_with_token(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.authenticators(TokenAuthenticator)
        def test():
            pass

        response = self.client.get('/resource',
                                   headers={'Authorization': 'token'})
        self.assertEqual(response.status_code, 204)

    def test_missing_token(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.authenticators(TokenAuthenticator)
        def test():
            pass

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 401)

示例#2

文件： test_authentication.py 项目： srault95/flask-io

class TestAuthorization(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_with_token(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.authenticators(TokenAuthenticator)
        def test():
            pass

        response = self.client.get('/resource', headers={'Authorization': 'token'})
        self.assertEqual(response.status_code, 204)

    def test_missing_token(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.authenticators(TokenAuthenticator)
        def test():
            pass
        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 401)

示例#3

文件： test_response.py 项目： srault95/flask-io

 def setUp(self):
     self.app = Flask(__name__)
     self.io = FlaskIO()
     self.io.init_app(self.app)
     self.client = self.app.test_client()

示例#4

文件： test_response.py 项目： srault95/flask-io

class TestResponseStatus(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_unauthorized(self):
        @self.app.route('/resource', methods=['POST'])
        def test():
            return self.io.unauthorized(Error('required', 'Login required', 'header', 'Authorization'))

        response = self.client.post('/resource')
        self.assertEqual(response.status_code, 401)

    def test_none_with_envelope(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.marshal_with(UserSchema, envelope='users')
        def test():
            return None

        response = self.client.post('/resource')

        data = json.loads(response.get_data(as_text=True))

        self.assertEqual(data.get('users', 'missing'), None)

    def test_empty_list_with_envelope(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.marshal_with(UserSchema, envelope='users')
        def test():
            return []

        response = self.client.post('/resource')

        data = json.loads(response.get_data(as_text=True))

        self.assertEqual(data.get('users'), [])

    def test_no_content(self):
        @self.app.route('/resource', methods=['POST'])
        def test():
            return None

        response = self.client.post('/resource')

        self.assertEqual(response.status_code, 204)
        self.assertTrue(response.content_type.startswith('text/html'))

    def test_error(self):
        @self.app.route('/resource', methods=['POST'])
        def test():
            raise Exception('expected error in test_error')

        response = self.client.post('/resource')

        self.assertEqual(response.status_code, 500)
        self.assertTrue(response.content_type.startswith('application/json'))

        data = json.loads(response.get_data(as_text=True))

        self.assertEqual(type(data.get('errors')), list)
        self.assertEqual(len(data.get('errors')), 1)

    def test_fields_param(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.marshal_with(UserSchema, envelope='users')
        def test():
            return dict(username='******', password='******')

        response = self.client.post('/resource?fields=username')

        data = json.loads(response.get_data(as_text=True))

        users_data = data.get('users')

        self.assertEqual('foo', users_data.get('username'))
        self.assertIsNone(users_data.get('password'))

    def test_http_exception(self):
        @self.app.route('/resource', methods=['GET'])
        def test():
            abort(401)

        response = self.client.get('/resource')

        self.assertEqual(401, response.status_code)

示例#5

文件： __init__.py 项目： AlexBrady/UserTests

from flask import Flask
from flask_io import FlaskIO

from .config import Base

__version__ = '1.0.0'

app = Flask(__name__)
app.config.from_object(Base)

io = FlaskIO()
io.init_app(app)

示例#6

from flask_login import LoginManager
from flask_sqlalchemy import SQLAlchemy
from flask_webpack import Webpack
from flask_socketio import SocketIO
from flask_io import FlaskIO

from app.plugins.flask_redis import Redis
from app.plugins.flask_simplemde import SimpleMDE

db = SQLAlchemy()
login_manager = LoginManager()
redis = Redis()
webpack = Webpack()
socketio = SocketIO()
flaskio = FlaskIO()

login_manager.login_view = 'auth.login'
login_manager.login_message_category = 'warning'


def register_extensions(app):
    db.init_app(app)
    login_manager.init_app(app)
    redis.init_app(app)
    webpack.init_app(app)
    socketio.init_app(app)
    # flaskio.init_app(app)

示例#7

文件： views.py 项目： srault95/flask-io

from flask import Flask
from flask_io import FlaskIO, fields
from datetime import datetime
from example.schemas import UserSchema, PatchUserSchema, UpdateUserSchema

app = Flask(__name__)
app.config['DEBUG'] = True

io = FlaskIO()
io.init_app(app)

store = dict()


@app.route('/users', methods=['POST'])
@io.from_body('user', UserSchema)
@io.marshal_with(UserSchema)
def add_user(user):
    if store.get(user.username):
        return io.conflict('User already exists: ' + user.username)

    user.created_at = datetime.now()
    store[user.username] = user
    return user


@app.route('/users')
@io.from_query('username', fields.String())
@io.from_query('max_results', fields.Integer(missing=10))
@io.marshal_with(UserSchema)
def get_users(username, max_results):

示例#8

from flask_io import FlaskIO
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()
io = FlaskIO()

示例#9

 def setUp(self):
     self.app = Flask(__name__)
     self.io = FlaskIO()
     self.io.init_app(self.app)
     self.client = self.app.test_client()

示例#10

class TestResponseStatus(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_unauthorized(self):
        @self.app.route('/resource', methods=['POST'])
        def test():
            return self.io.unauthorized(
                Error('required', 'Login required', 'header', 'Authorization'))

        response = self.client.post('/resource')
        self.assertEqual(response.status_code, 401)

    def test_none_with_envelope(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.marshal_with(UserSchema, envelope='users')
        def test():
            return None

        response = self.client.post('/resource')

        data = json.loads(response.get_data(as_text=True))

        self.assertEqual(data.get('users', 'missing'), None)

    def test_empty_list_with_envelope(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.marshal_with(UserSchema, envelope='users')
        def test():
            return []

        response = self.client.post('/resource')

        data = json.loads(response.get_data(as_text=True))

        self.assertEqual(data.get('users'), [])

    def test_no_content(self):
        @self.app.route('/resource', methods=['POST'])
        def test():
            return None

        response = self.client.post('/resource')

        self.assertEqual(response.status_code, 204)
        self.assertTrue(response.content_type.startswith('text/html'))

    def test_error(self):
        @self.app.route('/resource', methods=['POST'])
        def test():
            raise Exception('expected error in test_error')

        response = self.client.post('/resource')

        self.assertEqual(response.status_code, 500)
        self.assertTrue(response.content_type.startswith('application/json'))

        data = json.loads(response.get_data(as_text=True))

        self.assertEqual(type(data.get('errors')), list)
        self.assertEqual(len(data.get('errors')), 1)

    def test_fields_param(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.marshal_with(UserSchema, envelope='users')
        def test():
            return dict(username='******', password='******')

        response = self.client.post('/resource?fields=username')

        data = json.loads(response.get_data(as_text=True))

        users_data = data.get('users')

        self.assertEqual('foo', users_data.get('username'))
        self.assertIsNone(users_data.get('password'))

    def test_http_exception(self):
        @self.app.route('/resource', methods=['GET'])
        def test():
            abort(401)

        response = self.client.get('/resource')

        self.assertEqual(401, response.status_code)

示例#11

文件： test_request_args.py 项目： srault95/flask-io

class TestRequestArgs(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_missing_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int())
        def test(param1):
            self.assertEqual(param1, None)
        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 204)

    def test_missing_required_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Integer(required=True))
        def test(param1):
            pass
        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 400)

    def test_empty_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int())
        def test(param1):
            self.assertEqual(param1, None)
        response = self.client.get('/resource?param1=')
        self.assertEqual(response.status_code, 204)

    def test_empty_required_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Integer(required=True))
        def test(param1):
            pass
        response = self.client.get('/resource?param1=')
        self.assertEqual(response.status_code, 400)

    def test_default_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int(missing=10))
        def test(param1):
            self.assertEqual(param1, 10)
        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 204)

    def test_invalid_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int())
        def test(param1):
            pass
        response = self.client.get('/resource?param1=a')
        self.assertEqual(response.status_code, 400)

    def test_success_validate(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Integer(validate=lambda val: 1 <= val <= 10))
        def test(param1):
            self.assertEqual(param1, 5)
        response = self.client.get('/resource?param1=5')
        self.assertEqual(response.status_code, 204)

    def test_fail_validate(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Integer(validate=lambda val: 1 <= val <= 10))
        def test(param1):
            pass
        response = self.client.get('/resource?param1=11')
        self.assertEqual(response.status_code, 400)

    def test_load_from(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param2', fields.Integer(load_from='param1'))
        def test(param2):
            self.assertEqual(param2, 10)
        response = self.client.get('/resource?param1=10')
        self.assertEqual(response.status_code, 204)

    def test_list(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.List(fields.Int()))
        def test(param1):
            self.assertEqual(param1[0], 10)
            self.assertEqual(param1[1], 20)
        response = self.client.get('/resource?param1=10&param1=20')
        self.assertEqual(response.status_code, 204)

    def test_missing_required_list(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.List(fields.Int(), required=True))
        def test(param1):
            pass
        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 400)

示例#12

class TestRequestBody(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_invalid_payload_format(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.from_body('user', UserSchema)
        def test(user):
            pass

        headers = {'content-type': 'application/json'}
        response = self.client.post('/resource', data='invalid data', headers=headers)
        self.assertEqual(response.status_code, 400)

    def test_invalid_field(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.from_body('user', UserSchema)
        def test(user):
            self.assertEqual(type(user), User)
            self.assertEqual(user.username, 'user1')
            self.assertEqual(user.password, 'pass1')

        data = UserSchema().dump(User('user1', 'p')).data

        headers = {'content-type': 'application/json'}
        response = self.client.post('/resource', data=json.dumps(data), headers=headers)
        self.assertEqual(response.status_code, 400)

    def test_valid_fields(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.from_body('user', UserSchema)
        def test(user):
            self.assertEqual(type(user), User)
            self.assertEqual(user.username, 'user1')
            self.assertEqual(user.password, 'pass1')

        data = UserSchema().dump(User('user1', 'pass1')).data

        headers = {'content-type': 'application/json'}
        response = self.client.post('/resource', data=json.dumps(data), headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_missing_payload(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.from_body('user', UserSchema)
        def test(user):
            pass

        response = self.client.post('/resource')
        self.assertEqual(response.status_code, 400)

    def test_no_content_type(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.from_body('user', UserSchema)
        def test(user):
            self.assertEqual(type(user), User)
            self.assertEqual(user.username, 'user1')
            self.assertEqual(user.password, 'pass1')

        data = UserSchema().dump(User('user1', 'pass1')).data

        response = self.client.post('/resource', data=json.dumps(data))
        self.assertEqual(response.status_code, 204)

    def test_invalid_content_type(self):
        @self.app.route('/resource', methods=['POST'])
        @self.io.from_body('user', UserSchema)
        def test(user):
            pass

        data = UserSchema().dump(User('user1', 'pass1')).data

        headers = {'content-type': 'application/data'}
        response = self.client.post('/resource', data=json.dumps(data), headers=headers)
        self.assertEqual(response.status_code, 415)

    def test_invalid_accept(self):
        @self.app.route('/resource', methods=['GET'])
        def test():
            return 'response'

        headers = {'accept': 'application/data'}
        response = self.client.get('/resource', headers=headers)
        self.assertEqual(response.status_code, 406)

    def test_accept_with_parameters(self):
        @self.app.route('/resource', methods=['GET'])
        def test():
            return 'response'

        headers = {'accept': 'application/json;indent=2'}
        response = self.client.get('/resource', headers=headers)
        self.assertEqual(response.status_code, 200)

示例#13

文件： main.py 项目： joshmorris49/Museumary

Main file where app-engine runs the website
"""

from flask import Flask, render_template, jsonify, make_response
from flask_io import FlaskIO, fields, Schema
from flask_cors import CORS
from flask_restful import marshal_with
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import desc
from os import environ
import models
from models import Artist, Work, ArtType, Venue, Medium

app = Flask(__name__)
cors = CORS(app, resources={r"/*": {"origins": "*"}})
io = FlaskIO(app)
app.config['SQLALCHEMY_DATABASE_URI'] = environ['DATABASE_URI']
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)


def get_info(page, entries_per_page, num_entries):
    """
    Fill in information for responses containing
    page number, entries_per_page, and total pages and entries
    """
    return {
        'page': page,
        'entries_per_page': entries_per_page,
        'num_pages': num_entries // entries_per_page + 1,
        'num_entries': num_entries

示例#14

class TestRequestArgs(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.client = self.app.test_client()

    def test_missing_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int())
        def test(param1):
            self.assertEqual(param1, None)

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 204)

    def test_missing_required_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Integer(required=True))
        def test(param1):
            pass

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 400)

    def test_empty_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int())
        def test(param1):
            self.assertEqual(param1, None)

        response = self.client.get('/resource?param1=')
        self.assertEqual(response.status_code, 204)

    def test_empty_required_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Integer(required=True))
        def test(param1):
            pass

        response = self.client.get('/resource?param1=')
        self.assertEqual(response.status_code, 400)

    def test_default_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int(missing=10))
        def test(param1):
            self.assertEqual(param1, 10)

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 204)

    def test_invalid_value(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.Int())
        def test(param1):
            pass

        response = self.client.get('/resource?param1=a')
        self.assertEqual(response.status_code, 400)

    def test_success_validate(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1',
                            fields.Integer(validate=lambda val: 1 <= val <= 10)
                            )
        def test(param1):
            self.assertEqual(param1, 5)

        response = self.client.get('/resource?param1=5')
        self.assertEqual(response.status_code, 204)

    def test_fail_validate(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1',
                            fields.Integer(validate=lambda val: 1 <= val <= 10)
                            )
        def test(param1):
            pass

        response = self.client.get('/resource?param1=11')
        self.assertEqual(response.status_code, 400)

    def test_load_from(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param2', fields.Integer(load_from='param1'))
        def test(param2):
            self.assertEqual(param2, 10)

        response = self.client.get('/resource?param1=10')
        self.assertEqual(response.status_code, 204)

    def test_list(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.List(fields.Int()))
        def test(param1):
            self.assertEqual(param1[0], 10)
            self.assertEqual(param1[1], 20)

        response = self.client.get('/resource?param1=10&param1=20')
        self.assertEqual(response.status_code, 204)

    def test_missing_required_list(self):
        @self.app.route('/resource', methods=['GET'])
        @self.io.from_query('param1', fields.List(fields.Int(), required=True))
        def test(param1):
            pass

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 400)

示例#15

文件： test_tracing.py 项目： tvallois/flask-io

 def setUp(self):
     self.app = Flask(__name__)
     self.io = FlaskIO()
     self.io.init_app(self.app)
     self.io.tracer.enabled = True
     self.client = self.app.test_client()

示例#16

文件： test_tracing.py 项目： tvallois/flask-io

class TestTrace(TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.io = FlaskIO()
        self.io.init_app(self.app)
        self.io.tracer.enabled = True
        self.client = self.app.test_client()

    def test_default(self):
        @self.app.route('/resource')
        def test():
            pass

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 204)

    def test_handlers(self):
        self.steps = 0

        @self.app.route('/resource')
        def test():
            pass

        @self.io.trace_inspect()
        def trace_inspect(data):
            self.steps += 1
            data['entry'] = 'value'

        @self.io.trace_emit()
        def trace_emit(data):
            self.steps += 1
            self.assertEqual(data['entry'], 'value')

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 204)
        self.assertEqual(self.steps, 2)

    def test_exception(self):
        self.error = None

        @self.app.route('/resource')
        def test():
            raise Exception('expected error in test_exception')

        @self.io.trace_inspect()
        def trace_inspect(data):
            self.error = data['error']

        response = self.client.get('/resource')
        self.assertEqual(response.status_code, 500)
        self.assertIsNotNone(self.error)

    def test_filter_endpoints(self):
        self.io.tracer.add_filter(endpoints=['test2'])
        self.steps = 0

        @self.app.route('/test1')
        def test1():
            pass

        @self.app.route('/test2')
        def test2():
            pass

        @self.io.trace_emit()
        def trace_emit(data):
            self.steps += 1

        response = self.client.get('/test1')
        self.assertEqual(response.status_code, 204)

        response = self.client.get('/test2')
        self.assertEqual(response.status_code, 204)

        self.assertEqual(self.steps, 1)

    def test_filter_methods(self):
        self.io.tracer.add_filter(['POST'])
        self.steps = 0

        @self.app.route('/get', methods=['GET'])
        def get_test():
            pass

        @self.app.route('/post', methods=['POST'])
        def post_test():
            pass

        @self.io.trace_emit()
        def trace_emit(data):
            self.steps += 1

        response = self.client.get('/get')
        self.assertEqual(response.status_code, 204)

        response = self.client.post('/post')
        self.assertEqual(response.status_code, 204)

        self.assertEqual(self.steps, 1)