Beispiel #1
1
def test_gravatar_url():
    """Test that the gravatar url is generated correctly"""
    app = Flask(__name__)

    with app.test_request_context("/"):
        app.debug = True
        url = gravatar_url("test@test.com")
        eq_(url, "http://www.gravatar.com/avatar/" "b642b4217b34b1e8d3bd915fc65c4452?d=mm")

        url = gravatar_url("test@test.com", 200)
        eq_(url, "http://www.gravatar.com/avatar/" "b642b4217b34b1e8d3bd915fc65c4452?s=200&d=mm")

        app.debug = False

        url = gravatar_url("test@test.com")
        eq_(url, "http://www.gravatar.com/avatar/" "b642b4217b34b1e8d3bd915fc65c4452?d=mm")

        app.config["SITE_URL"] = "http://www.site.com"

        url = gravatar_url("test@test.com")
        eq_(
            url,
            "http://www.gravatar.com/avatar/"
            "b642b4217b34b1e8d3bd915fc65c4452"
            "?d=http%3A%2F%2Fwww.site.com%2Fstatic%2Fimg%2Fdefault-avatar.png",
        )
Beispiel #2
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    app.register_blueprint(main_blueprint)
    Misaka(app, tables=True, wrap=True)
    cache.init_app(app)
    return app 
def create_app(database):
    global app
    
    # create our little application :)
    app = Flask(__name__)
    app.config.from_object(config)
    app.secret_key = config.SECRET_KEY

    # db import
    from libs.db import init_connection

    # db setup
    if database: init_connection(database)

    # presenters
    from presenters.home import home

    # register modules
    app.register_blueprint(home)

    # template filters
    @app.template_filter('test_format')
    def test_format(input):
        return input[::-1]

    return app
Beispiel #4
0
    def setUp(self):
        self.engine = Engine("op1", "op2")
        self.engine.op1.setup(in_name="in", out_name="middle", required=False)
        self.engine.op2.setup(in_name="middle", out_name="out")

        self.engine.op1.set(OptProductEx())
        foisdouze = OptProductEx("foisdouze")
        foisdouze.force_option_value("factor", 12)
        self.engine.op2.set(foisdouze, OptProductEx())

        egn_view = EngineView(self.engine, name="my_egn")
        egn_view.add_input("in", Numeric(vtype=int, min=-5, max=5))
        egn_view.add_input("middle", Numeric(vtype=int))
        print(self.engine.needed_inputs())
        egn_view.add_output("in")
        egn_view.add_output("middle")
        egn_view.add_output("out")

        api = ReliureAPI()
        api.register_view(egn_view)

        app = Flask(__name__)
        app.config['TESTING'] = True
        app.register_blueprint(api, url_prefix="/api")
        self.app = app.test_client()
Beispiel #5
0
def create_app(name='davesite', configuration='Default'):
    """
    Overview: Factory method that is responsible for the following.  Returns the configured Flask app object.
        
            * Reading the configuration.  The configuration is kept in config.py
                
            * Registering the blueprints.  Any blueprints to be added to the application are be added here.     
            
            * Logging: DaveSite uses the built-in python logging module to provide console and file logging.
                       All errors are logged to the console while only warnings and above are logged to the file.
    
    Parameters:
        name:                  package that davesite currently resides under.  
        configuration:         string that points to one of the classes in config.py
        
    Returns: A properly configured Flask application
    """
    app = Flask(name)
    initialize_logging()

    try:
        app.config.from_object('davesite.app.config.{config}'.format(config=configuration))
        initialize_blueprints(app)
    except Exception:
        app.logger.exception("Error while starting app:")
        sys.exit(-1)

    add_file_logging(app.config.get('ERROR_LOG_FILE', 'error.log'), logging.WARN)

    app.wsgi_app = URLPrefixMiddleware(app.wsgi_app, app.config.get('SCRIPT_NAME', '/'))
    return app
Beispiel #6
0
def lte(app: Flask):
    for blueprint in app.blueprints.values():
        blueprint.jinja_loader = jinja2.ChoiceLoader([
            jinja2.FileSystemLoader(os.path.join(get_root_path('flask_admin_lte'), 'templates/lte')),
            blueprint.jinja_loader,
        ])
    app.register_blueprint(Blueprint('admin_lte', __name__, static_folder='static', static_url_path='/static/lte'))
Beispiel #7
0
    def setUp(self):
        app = Flask(__name__)
        Funnel(app)

        app.config['CSS_BUNDLES'] = {
            'css-bundle': (
                'css/test.css',
                'less/test.less',
                'scss/test.scss',
                'stylus/test.styl',
            ),
        }

        app.config['JS_BUNDLES'] = {
            'js-bundle': (
                'js/test1.js',
                'js/test2.js',
                'coffee/test.coffee',
            ),
        }

        @app.route('/')
        def index():
            return render_template_string(
                "{{ css('css-bundle') }} {{ js('js-bundle') }}")

        self.app = app
        self.client = app.test_client()
def create_app(app=None, config_file=None):

    if not app:
        app = Flask(__name__, template_folder="views")

    # Config files
    app.config.from_pyfile("config/base.py")
    if config_file:
    	app.config.from_pyfile("config/{}.py".format(config_file))

    # Extensions
    Foundation(app)
    admin = Admin(app, name='Bolsa de Trabajo', template_mode='bootstrap3')

    """
    CONTROLADORES 
    """
    # Blueprints
    app.register_blueprint(frontend)    

    # Admin Views
    admin.add_view(AdminSkillView(Skill, db.session))
    admin.add_view(AdminStudentView(Student, db.session))
    admin.add_view(AdminCompanyView(Company, db.session))

    return app
Beispiel #9
0
def create_app():
    setup_config(sys.argv[1], 'dnsdb-updater', conf_dir=os.path.dirname(os.path.dirname(__file__)))
    log.error('This host belong to host group %s' % CONF.host_group)

    app = Flask(__name__)
    app.config['SECRET_KEY'] = CONF.etc.secret_key

    from dns_updater.utils.updater_util import check_necessary_options
    check_necessary_options()

    @app.route("/healthcheck.html", methods=['GET'])
    def health_check():
        try:
            return render_template('healthcheck.html')
        except TemplateNotFound:
            abort(404)

    @app.context_processor
    def default_context_processor():
        result = {'config': {'BASE_URL': CONF.web.base_url}}
        return result

    from dns_updater import api
    app.register_blueprint(api.bp, url_prefix='/api')

    return app
Beispiel #10
0
    def test_whitelisting(self):

        app = Flask(__name__)
        limiter = Limiter(app, global_limits=["1/minute"], headers_enabled=True)

        @app.route("/")
        def t():
            return "test"

        @limiter.request_filter
        def w():
            if request.headers.get("internal", None) == "true":
                return True
            return False

        with hiro.Timeline().freeze() as timeline:
            with app.test_client() as cli:
                self.assertEqual(cli.get("/").status_code, 200)
                self.assertEqual(cli.get("/").status_code, 429)
                timeline.forward(60)
                self.assertEqual(cli.get("/").status_code, 200)

                for i in range(0,10):
                    self.assertEqual(
                        cli.get("/", headers = {"internal": "true"}).status_code,
                        200
                    )
Beispiel #11
0
    def test_custom_headers_from_config(self):
        app = Flask(__name__)
        app.config.setdefault(C.HEADER_LIMIT, "X-Limit")
        app.config.setdefault(C.HEADER_REMAINING, "X-Remaining")
        app.config.setdefault(C.HEADER_RESET, "X-Reset")
        limiter = Limiter(app, global_limits=["10/minute"], headers_enabled=True)
        @app.route("/t1")
        @limiter.limit("2/second; 10 per minute; 20/hour")
        def t():
            return "test"

        with hiro.Timeline().freeze() as timeline:
            with app.test_client() as cli:
                for i in range(11):
                    resp = cli.get("/t1")
                    timeline.forward(1)

                self.assertEqual(
                    resp.headers.get('X-Limit'),
                    '10'
                )
                self.assertEqual(
                    resp.headers.get('X-Remaining'),
                    '0'
                )
                self.assertEqual(
                    resp.headers.get('X-Reset'),
                    str(int(time.time() + 49))
                )
Beispiel #12
0
    def test_headers_breach(self):
        app = Flask(__name__)
        limiter = Limiter(app, global_limits=["10/minute"], headers_enabled=True)

        @app.route("/t1")
        @limiter.limit("2/second; 10 per minute; 20/hour")
        def t():
            return "test"

        with hiro.Timeline().freeze() as timeline:
            with app.test_client() as cli:
                for i in range(11):
                    resp = cli.get("/t1")
                    timeline.forward(1)

                self.assertEqual(
                    resp.headers.get('X-RateLimit-Limit'),
                    '10'
                )
                self.assertEqual(
                    resp.headers.get('X-RateLimit-Remaining'),
                    '0'
                )
                self.assertEqual(
                    resp.headers.get('X-RateLimit-Reset'),
                    str(int(time.time() + 49))
                )
    def setUp(self):
        app = Flask(__name__)
        app.config['SECRET_KEY'] = 'my secret'

        digest_auth_my_realm = HTTPDigestAuth(realm='My Realm')

        @digest_auth_my_realm.get_password
        def get_digest_password_3(username):
            if username == 'susan':
                return 'hello'
            elif username == 'john':
                return 'bye'
            else:
                return None

        @app.route('/')
        def index():
            return 'index'

        @app.route('/digest-with-realm')
        @digest_auth_my_realm.login_required
        def digest_auth_my_realm_route():
            return 'digest_auth_my_realm:' + digest_auth_my_realm.username()

        self.app = app
        self.client = app.test_client()
Beispiel #14
0
    def test_url_absolute(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url("foobar", absolute=True)

        with app.test_request_context("/"):
            self.assertEquals("http://localhost/3", field.output("hey", Foo()))
Beispiel #15
0
    def test_url_invalid_object(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url("foobar")

        with app.test_request_context("/"):
            self.assertRaises(MarshallingException, lambda: field.output("hey", None))
Beispiel #16
0
def create_app(package_name, package_path, settings_override=None,
               register_security_blueprint=True):
    """Returns a :class:`Flask` application instance configured with common
    functionality for the _app_name_ platform.

    :param package_name: application package name
    :param package_path: application package path
    :param settings_override: a dictionary of settings to override
    :param register_security_blueprint: flag to specify if the Flask-Security
                                        Blueprint should be registered. Defaults
                                        to `True`.
    """
    app = Flask(package_name, instance_relative_config=True)

    app.config.from_object('_app_name_.settings')
    app.config.from_pyfile('settings.cfg', silent=True)
    app.config.from_object(settings_override)

    db.init_app(app)
    mail.init_app(app)
    security.init_app(app, SQLAlchemyUserDatastore(db, User, Role),
                      register_blueprint=register_security_blueprint)

    register_blueprints(app, package_name, package_path)

    app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app)

    return app
def make_json_app(import_name, **kwargs):
    """
    Creates a JSON-oriented Flask app.

    All error responses that you don't specifically
    manage yourself will have application/json content
    type, and will contain JSON like this (just an example):

    { "message": "405: Method Not Allowed" }

    http://flask.pocoo.org/snippets/83/
    """
    def make_json_error(ex):
        response = jsonify(message=str(ex))
        response.status_code = (ex.code
                                if isinstance(ex, HTTPException)
                                else 500)
        return response

    app = Flask(import_name, **kwargs)

    for code in default_exceptions.iterkeys():
        app.error_handler_spec[None][code] = make_json_error

    return app
Beispiel #18
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)
    # 初始化一些flask扩展库,依赖于flask的app上下文环境
    db.init_app(app)
    # 初始化bootstrap
    bootstrap.init_app(app)
    # 初始化登陆管理
    login_manager.init_app(app)
    # 初始化邮件
    mail.init_app(app)
    # 初始化moment
    moment.init_app(app)
    # 附加路由和自定义的错误页面
    app_dir = os.path.join(root_dir, 'app')
    # 逐个执行各个路由映射脚本,添加到route_list中
    for routes in os.listdir(app_dir):
        rou_path = os.path.join(app_dir, routes)
        if (not os.path.isfile(rou_path)) and routes != 'static' and routes != 'templates':
            __import__('app.' + routes)
    # 从route_list中引入蓝图
    for blueprints in route_list:
        if blueprints[1] != None:
            app.register_blueprint(blueprints[0], url_prefix = blueprints[1])
        else:
            app.register_blueprint(blueprints[0])
    #返回app实例,让外部模块继续使用
    return app
Beispiel #19
0
def create_app(_name_=None, root=root, config='DevelopmentConfig', **configs):
	"""
	App factory
	:param config: name of Config class from config.py
	"""

	# Create and set app config
	app = Flask(_name_ or __name__)
	app.config.from_object('%s.config.%s' % (root, config))
	app.config.update(**configs)

	# initialize Flask-Login with app
	login_manager.init_app(app)

	# initialize hash mechanism
	hashing.init_app(app)

	# setup blueprints
	def reload_blueprints():
		"""Loads all LIVE blueprints"""
		mod = lambda view: importlib.import_module('%s.%s.views' % (root, view))
		return [getattr(mod(view), view) for view in app.config['LIVE']]

	# Setup blueprints
	def register_blueprints(*blueprints):
		"""Registers all passed-in blueprints"""
		blueprints = list(blueprints) + reload_blueprints()
		for blueprint in blueprints:
			app.register_blueprint(blueprint)

	app.register_blueprints = register_blueprints
	app.register_blueprints()

	return app
Beispiel #20
0
    def test_flask(self):
        app = Flask(__name__)
        db = SQLAlchemy(app)
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'

        class Cities(db.Model):
            __tablename__ = 'users'

            id = Column(Integer, primary_key=True)
            name = Column(String)
            population = Column(Integer)

            def __init__(self, name, population):
                self.name = name
                self.population = population
                
        app.config['TESTING'] = True
        app = app.test_client()
        db.create_all()

        city = Cities("Cordoba", 1000000)
        db.session.add(city)
        city = Cities("Rafaela", 99000)
        db.session.add(city)
        db.session.commit()

        query_string = '{ "sort": { "population" : "desc" } }'
        results = elastic_query(Cities, query_string)
        assert(results[0].name == 'Cordoba')
Beispiel #21
0
def main():
    app = Flask(__name__)
    app.config.update(
        DB_CONNECTION_STRING=':memory:',
        CACHE_TYPE='simple',
        SQLALCHEMY_DATABASE_URI='sqlite://',
    )
    app.debug = True
    injector = init_app(app=app, modules=[AppModule])

    configure_views(app=app, cached=injector.get(Cache).cached)

    post_init_app(app, injector)

    client = app.test_client()

    response = client.get('/')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.post('/', data={'key': 'foo', 'value': 'bar'})
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.get('/')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.get('/hello')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.delete('/hello')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.get('/')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.get('/hello')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
    response = client.delete('/hello')
    print('%s\n%s%s' % (response.status, response.headers, response.data))
Beispiel #22
0
def create_cartographer(args):
    app = Flask(__name__)
    app.config["SECRET_KEY"] = "map the soul"

    @app.route("/")
    def hi():
        return render_template("index.html")

    @app.route("/getPoints", methods=["POST"])
    def getPoints():
        print(request.json)
        zoom = int(request.json.get("zoom", 1))
        seen = request.json.get("seen", [])
        ensure(seen).is_a_list_of(str)
        points = POI.objects(
            at__geo_within_box=(request.json["SW"], request.json["NE"]), min_zoom=zoom, name__nin=request.json["seen"]
        )

        return jsonify(
            {
                "points": [
                    {
                        "name": p.name,
                        "lat": p.at["coordinates"][1],
                        "lng": p.at["coordinates"][0],
                        "abstract": lz4.decompress(p.abstract).decode() if p.abstract else "",
                        "img": p.img,
                    }
                    for p in points
                ]
            }
        )

    return app
Beispiel #23
0
	def create_app(self):
		app = Flask(__name__)
		app.config.from_object(config['unit_test'])
		app.add_url_rule('/test', view_func=test_route)
		app.add_url_rule('/', view_func=index)
		#print "app.view_functions: {}".format(app.view_functions)
		return app
Beispiel #24
0
class RootREST:

    def __init__(self, host, run_flask, port):
        self.host = host
        self.port = port
        self.run_flask = run_flask
        self.app = Flask(__name__)
        CORS(self.app,
             resources={
                 r'/*': {
                     'origins': '*',
                     'headers': ['Content-Type']
                 }
             }
        )
        #blueprintRest = BlueprintRest()
        self.app.register_blueprint(bp, url_prefix='/blueprint')
        #self.app.register_blueprint(Blueprint('blueprint', __name__), url_prefix='/blueprint')

        # Root service.
        @self.app.route('/')
        def landing():
            return core.landing_message()

        # Run Flask.
        if self.run_flask:
            self.app.run(host=self.host, port=self.port)
def create_app(config):
    """create flaks app object"""

    # Initialize the App:
    app = Flask(__name__)
    from config import configurations
    app.config.from_object(configurations[config])
    configurations[config].init_app(app)
    app.logger.addHandler(app.config.get('LOG_HANDLER'))
    app.logger.info('App is starting!')

    db.init_app(app)

    # Register the Main Views:
    from .views import api
    app.register_blueprint(api, url_prefix='/api/v1')

    @app.after_request
    def after_request(resp):
        for q in get_debug_queries():
            if q.duration > app.config.get('DB_QUERY_TIMEOUT'):
                app.logger.warning(
                    'SLOW DB STATEMENT: {0}\n\tParameters: {1}\n\tDuration: {2}\n\tContext: {3}'.
                    format(q.statement, q.parameters, q.duration, q.context))
        return resp

    return app
def app(request):
    """Flask application fixture."""
    instance_path = tempfile.mkdtemp()
    app_ = Flask(__name__, instance_path=instance_path)
    app_.config.update(
        FILES_REST_PERMISSION_FACTORY=lambda *a, **kw: type(
            'Allow', (object, ), {'can': lambda self: True}
        )(),
        SECRET_KEY='CHANGE_ME',
        SQLALCHEMY_DATABASE_URI=os.environ.get(
            'SQLALCHEMY_DATABASE_URI', 'sqlite://'),
        SQLALCHEMY_TRACK_MODIFICATIONS=True,
        TESTING=True,
    )
    app_.register_blueprint(files_rest_blueprint)
    InvenioDB(app_)
    InvenioRecords(app_)
    InvenioFilesREST(app_)
    InvenioIndexer(app_)
    search = InvenioSearch(app_)
    search.register_mappings('records-files', 'data')

    with app_.app_context():
        yield app_

    shutil.rmtree(instance_path)
Beispiel #27
0
def script_info(request):
    """Get ScriptInfo object for testing CLI."""
    instance_path = tempfile.mkdtemp()
    app = Flask('testapp', instance_path=instance_path)
    app.config.update(
        ACCOUNTS_USE_CELERY=False,
        SECRET_KEY="CHANGE_ME",
        SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
        SQLALCHEMY_DATABASE_URI=os.environ.get(
            'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
        TESTING=True,
    )
    FlaskCLI(app)
    Babel(app)
    Mail(app)
    InvenioDB(app)
    InvenioAccounts(app)

    with app.app_context():
        if not database_exists(str(db.engine.url)):
            create_database(str(db.engine.url))
        db.drop_all()
        db.create_all()

    def teardown():
        with app.app_context():
            drop_database(str(db.engine.url))
        shutil.rmtree(instance_path)

    request.addfinalizer(teardown)
    return ScriptInfo(create_app=lambda info: app)
def test_flask_sqlalchemy():
    from flask.ext.sqlalchemy import SQLAlchemy as FlaskSQLAlchemy

    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'
    db = FlaskSQLAlchemy(app)

    class UserMixin(object):
        email = db.Column(db.Unicode(300))

        def __init__(self, login, email):
            self.login = login
            self.email = email
            self.password = 'foobar'

    class RoleMixin(object):
        description = db.Column(db.UnicodeText)

    auth = authcode.Auth(SECRET_KEY, db=db, UserMixin=UserMixin, RoleMixin=RoleMixin)
    authcode.setup_for_flask(auth, app)
    User = auth.User

    db.create_all()
    user = User(u'meh', u'text@example.com')
    db.session.add(user)
    db.session.commit()

    assert user.login == u'meh'
    assert user.email == u'text@example.com'
    assert hasattr(user, 'password')
    assert hasattr(user, 'last_sign_in')
    assert repr(user) == '<User meh>'
Beispiel #29
0
def test_menu_render():
    menu = decorators.menu
    menu.clear()
    app = Flask(__name__)
    app.testing = True

    @menu("Hello World", group_name="admin")
    class Hello(object):

        @menu("Index")
        def index(self):
            pass

        @menu("Page 2")
        def index2(self):
            pass

    @menu("Monster")
    class Monster(object):

        @menu("Home")
        def maggi(self):
            pass

    with app.test_client() as c:
        c.get("/")
        assert len(menu.render()) == 2
Beispiel #30
0
def create_app(**config):
    """Application Factory

    You can create a new He-Man application with::

        from heman.config import create_app

        app = create_app() # app can be uses as WSGI application
        app.run() # Or you can run as a simple web server
    """
    app = Flask(__name__, static_folder=None)

    if "MONGO_URI" in os.environ:
        app.config["MONGO_URI"] = os.environ["MONGO_URI"]

    app.config["LOG_LEVEL"] = "DEBUG"
    app.config["SECRET_KEY"] = "2205552d13b5431bb537732bbb051f1214414f5ab34d47"

    configure_logging(app)
    configure_sentry(app)
    configure_api(app)
    configure_mongodb(app)
    configure_login(app)

    return app