def test_app_wrong_env(monkeypatch):
# Given: not existing env set as a env variable in a system.
monkeypatch.setenv('APP_ENV', 'wrong_env')
# When: we create an instance of the app with this env.
# Then: we receive EnvironmentError.
with pytest.raises(EnvironmentError):
create_app()
def __call__(self, app, *args, **kwargs):
with create_app().app_context():
query = db.session.query(Role).all()
if not query:
db.session.add(Role(role_name="superuser"))
db.session.add(Role(role_name="user"))
db.session.commit()
print("Roles have been created.")
return Server.__call__(self, app, *args, **kwargs)
def profile(length, profile_dir):
from werkzeug.contrib.profiler import ProfilerMiddleware
from core import create_app
app = create_app()
app.wsgi_app = ProfilerMiddleware(app.wsgi_app,
restrictions=(length, ),
profile_dir=profile_dir)
app.run(debug=False)
def load_app(config_name='dev'):
import config
from core import create_app
configuration = {
'dev': config.DevelopmentConfig,
'test': config.TestingConfig
}
app = create_app(configuration.get(config_name, config.DevelopmentConfig))
return app
def setUp(self):
app = create_app(TestingConfig)
self.test_db_file = tempfile.mkstemp()[1]
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + self.test_db_file
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
with app.app_context():
db.create_all()
app.app_context().push()
self.app = app.test_client()
def setUp(self):
self.app = create_app()
self.app_context = self.app.app_context()
self.app_context.push()
self.provider = plugins.get_plugin(
StaticProviders.crossref_event_data).PROVIDER
db.create_all()
for uri_id, uri_raw in dois_all:
db.session.add(Uri(id=uri_id, raw=uri_raw))
db.session.commit()
def app(monkey_session) -> Flask:
"""A testing instance of the Flask application."""
monkey_session.setenv('APP_ENV', 'testing')
app = create_app()
# Creates in memory tables..
with app.app_context():
db.create_all()
yield app
# Drops from memory tables.
with app.app_context():
db.drop_all()
def base_setup():
"""
This function prepares and destruct the flask application and the database
before and after each test.
All lines before the yield statement will be executed before the tests
and each line after the yield statement will be called at the end of the tests
"""
app, _ = create_app(config_file="config_test.ini", test=True)
app_context = app.app_context()
app_context.push()
create_testEnv(app, db)
client = app.test_client()
yield app, app_context, db, client
db.session.remove()
db.drop_all()
app_context.pop()
def start_job(self, **kwargs):
from core import create_app, db
from core.jobs.models import JobExecute
self.app, _ = create_app(True)
self.db = db
self.app.app_context().push()
triggered = datetime.now()
current_time = triggered.strftime("%H:%M:%S")
logManager.info("Run " + self.name + " " + current_time)
je = None
if 'job_execution_id' in kwargs:
je = JobExecute.query.filter_by(
id=kwargs['job_execution_id']).first()
if je is None:
je = JobExecute()
je.workspace = self.workspace
je.triggered_by = "Cron"
je.triggered_on = triggered
je.name = self.job_key
self.db.session.add(je)
self.db.session.commit()
try:
self.run(**kwargs)
je.state = "SUCCEED"
je.results = {"hjsadhj": "jklsajdklas"}
except Exception as e:
je.state = "FAILED"
print(e)
after = datetime.now()
delta = after - triggered
je.lifetime = delta.total_seconds()
self.db.session.commit()
from core import create_app
if __name__ == "__main__":
app = create_app("config.Development")
app.run()
from core import create_app
#update those values
app = create_app(
config_name=dict(SECRET_KEY="put a complex random string here",
STEAM_KEY="<your steam api key"))
from core import create_app
from config import Config
from core.views import uber
from dotenv import load_dotenv
load_dotenv()
flask_app = create_app(Config)
flask_app.register_blueprint(uber)
if __name__ == "__main__":
flask_app.run()
def setUp(self):
app = create_app()
self.app = app
self.client = app.test_client()
# !/usr/bin/env python
import os
# class for handling a set of commands
from flask_script import Manager
from flask_migrate import (Migrate, MigrateCommand)
from core import (db, create_app, models)
app = create_app('production')
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
from celery import Celery
from flask import current_app
import settings
from core import create_app
from modules.routines.beat import FlaskBeat
def make_celery(app):
celery = Celery(
app.import_name,
)
celery.conf.update(app.config)
class ContextTask(celery.Task):
def __call__(self, *args, **kwargs):
with app.app_context():
return self.run(*args, **kwargs)
celery.Task = ContextTask
celery.Beat = celery.subclass_with_self(FlaskBeat)
return celery
app = current_app if current_app else create_app(settings)
celery_app = make_celery(app=app)
import core
import uvicorn
app = core.create_app()
if __name__ == '__main__':
uvicorn.run(
"main:app",
port=8001,
workers=2,
# ssl_version=ssl.PROTOCOL_SSLv23,
# ssl_keyfile='./core/certs/rootCA-key.pem',
# ssl_certificate='./core/certs/rootCA.pem',
)
def setUp(self):
self.app = create_app()
self.app_context = self.app.app_context()
self.app_context.push()
Foundation, either version 3 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.
"""
__authors__ = ["Marcus Drobisch"]
__contact__ = "*****@*****.**"
__credits__ = []
__license__ = "GPLv3"
from core import create_app, db
from devEnv import create_devEnv
from core.nodes import nodeManager
app, is_database_new = create_app()
print()
print(app.url_map)
with app.app_context():
if is_database_new:
create_devEnv(app, db)
if __name__ == '__main__':
app.run()
import pytz
import unittest
import logging
import datetime
from flask import url_for
from bcrypt import checkpw
from datetime import timedelta, timezone
from time import sleep
from core import create_app
from core.database import User, Task, db
logger = logging.getLogger(__name__)
app = create_app(test_config=True)
class TestBase(unittest.TestCase):
@staticmethod
def request(json_data, endpoint, method='post'):
client = app.test_client()
method_func = client.post if method == 'post' else client.get
with app.test_request_context():
url = url_for(endpoint)
response = method_func(url, json=json_data)
data = response.get_json()
return response, data
class TestRegistrationErrors(TestBase):
from core import create_app
if __name__ == "__main__":
create_app().run(debug=True)
def run(self):
import settings
app = create_app(settings)
with app.app_context():
return super(FlaskBeat, self).run()
import os
from core import create_app
from decouple import config
env = config("FLASK_ENV")
app = create_app(env)
if __name__ == "__main__":
app.run(debug=True)
from core import create_app
from config import Dev
from flask_peewee.db import Database
app = create_app(Dev)
db = Database(app)
if __name__ == '__main__':
app.run(port=8080)
# _*_coding:utf-8_*_
"""
Project: python-fullstack
Author: Byron Hai
Date: 2020/11/3
"""
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from core import create_app, db
from core.models import User, Book
app = create_app("development")
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == "__main__":
manager.run()
import os
from core import create_app
from flask.ext.script import Manager
app = create_app('dev')
manager = Manager(app)
if __name__ == "__main__":
manager.run()
import os
from core import create_app
app = create_app(os.getenv('APP_SETTINGS') or 'default')
if __name__ == '__main__':
app.run()
import os
from core import create_app
from flask.ext.script import Manager
app = create_app('dev')
manager = Manager(app)
if __name__ == "__main__":
manager.run()
class BaseTestCase(TestCase):
app = create_app(TestingConfig)
client = app.test_client()
db = db.database
ctx = app.app_context()
api_url_base = TestingConfig.API_URL_BASE
password_salt = TestingConfig.USER_PASSWORD_SALT
login_timeout = TestingConfig.USER_LOGIN_TIMEOUT
def reset_database(self):
from core.models import User, tables
from core.models.permission import (preset_for_author,
preset_for_superuser)
with self.ctx:
db.database.drop_tables(tables, safe=True)
db.database.create_tables(tables)
User.create(id='su',
permission=preset_for_superuser,
password='******',
name='超级管理员')
User.create(id='author',
permission=preset_for_author,
password='******',
name='作者')
def get_timestamp(self):
from time import time
return int(time() * 1000)
def encode_password(self, plain_password, timestamp=None):
from hashlib import sha1
raw = (plain_password + self.password_salt).encode('utf-8')
cipher = sha1(raw).hexdigest()
if timestamp is not None:
cipher = sha1((cipher + str(timestamp)).encode()).hexdigest()
return cipher
def login(self, user_id):
from flask_login import encode_cookie
with self.client.session_transaction():
self.client.set_cookie(self.app.config['SERVER_NAME'],
'remember_token', encode_cookie(user_id))
def logout(self):
with self.client.session_transaction() as session:
self.client.delete_cookie(self.app.config['SERVER_NAME'],
'remember_token')
session.pop('user_id', None)
session.pop('_fresh', None)
def login_as_su(self):
return self.login('su')
def login_as_author(self):
return self.login('author')
def get_json(self, resp):
from json import loads
return loads(resp.data.decode())
def toggle_sql_echo(self):
if logger.level == 0:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.WARNING)
def assertResponseOk(self, resp):
self.assertEqual(resp.status_code, 200)
def assertResponseRestful(self, resp):
self.assertResponseOk(resp)
self.assertEqual(resp.content_type, 'application/json')
def assertResponseRestfulAndSuccess(self, resp):
self.assertResponseRestful(resp)
self.assertIsNone(self.get_json(resp)['$errors'])
def assertJSONHasKey(self, resp_or_dict, key):
if isinstance(resp_or_dict, dict):
json = resp_or_dict
else:
json = self.get_json(resp_or_dict)
self.assertIn(key, json)
def assertResponseErrorInField(self, resp, error_field):
self.assertResponseRestful(resp)
json = self.get_json(resp)['$errors']
self.assertIsInstance(json, dict)
self.assertIn(error_field, json)
from core import create_app from config import app_config from flask_login import LoginManager flask_app = create_app(app_config) login_manager = LoginManager() login_manager.init_app(flask_app)
from core import create_app
app = create_app()
if __name__ == '__main__':
app.run(debug=True)
def _make_context():
return dict(app=create_app(),
db=db,
models=models,
User=User,
Category=Category)
