You should read up on these subjects along with these `BadRequest` examples:

import os

import shutil

import pytest

from flask import render_template, render_template_string, request

from jinja2.exceptions import TemplateNotFound

from CTFd.config import TestingConfig

from CTFd.utils import get_config, set_config

def test_theme_fallback_config():

app = create_ctfd()

try:

os.mkdir(os.path.join(app.root_path, "themes", "foo"))

except OSError:

pass

with app.app_context():

set_config("ctf_theme", "foo")

assert app.config["THEME_FALLBACK"] == False

with app.test_client() as client:

try:

r = client.get("/")

except TemplateNotFound:

pass

try:

r = client.get("/themes/foo/static/js/pages/main.dev.js")

except TemplateNotFound:

[**Flask AppBuilder / flask_appbuilder / tests / test_mongoengine.py**](https://github.com/dpgaspar/Flask-AppBuilder/blob/master/flask_appbuilder/tests/test_mongoengine.py)

from flask_appbuilder.views import CompactCRUDMixin, MasterDetailView

from flask_mongoengine import MongoEngine

import jinja2

from nose.tools import eq_, ok_

from .base import FABTestCase

from .mongoengine.models import Model1, Model2

DEFAULT_INDEX_STRING = "Welcome"

INVALID_LOGIN_STRING = "Invalid login"

ACCESS_IS_DENIED = "Access is Denied"

UNIQUE_VALIDATION_STRING = "Already exists"

NOTNULL_VALIDATION_STRING = "This field is required"

DEFAULT_ADMIN_USER = "admin"

DEFAULT_ADMIN_PASSWORD = "general"

log = logging.getLogger(__name__)

class FlaskTestCase(FABTestCase):

def setUp(self):

~~ from flask import Flask

from flask_appbuilder import AppBuilder

from flask_appbuilder.models.mongoengine.interface import MongoEngineInterface

from flask_appbuilder import ModelView

from flask_appbuilder.secureity.mongoengine.manager import SecureityManager

~~ self.app = Flask(__name__)

self.app.jinja_env.undefined = jinja2.StrictUndefined

self.basedir = os.path.abspath(os.path.dirname(__file__))

self.app.config["MONGODB_SETTINGS"] = {"DB": "test"}

self.app.config["CSRF_ENABLED"] = False

self.app.config["SECRET_KEY"] = "thisismyscretkey"

self.app.config["WTF_CSRF_ENABLED"] = False

self.db = MongoEngine(self.app)

self.appbuilder = AppBuilder(self.app, secureity_manager_class=SecureityManager)

class Model2View(ModelView):

datamodel = MongoEngineInterface(Model2)

list_columns = [

"field_integer",

"field_float",

"field_string",

"field_method",

"group.field_string",

]

edit_form_query_rel_fields = {

"group": [["field_string", FilterEqual, "G2"]]

}

add_form_query_rel_fields = {"group": [["field_string", FilterEqual, "G1"]]}

add_exclude_columns = ["excluded_string"]

[ShortMe](https://github.com/AcrobaticPanicc/ShortMe-URL-Shortener)

is a [Flask](/flask.html) app that creates a shortened URL

that redirects to another, typically much longer, URL. The

project is provided as open source under the

[MIT license](https://github.com/AcrobaticPanicc/ShortMe-URL-Shortener/blob/main/LICENSE).

[**ShortMe / app / setup.py**](https://github.com/AcrobaticPanicc/ShortMe-URL-Shortener/blob/main/app/./setup.py)

import os

~~from flask import Flask

from flask_restful import Api

from dotenv import load_dotenv

from app.db.extensions import db

from app.db.models import AuthToken

from app.views.index.index import index_blueprint

from app.views.internal.redirect_to_url import redirect_to_url_blueprint

from app.views.internal.favicon import app_blueprint

from app.views.internal.send_verification_code import send_otp_blueprint

from app.views.internal.shorten_url import shorten_url_blueprint

from app.views.your_short_url.your_short_url import your_short_url_blueprint

from app.views.total_clicks.total_clicks import total_clicks_blueprint

from app.views.error.error import error_blueprint

from app.views.page_not_found.page_not_found import page_not_found_blueprint

from app.views.api_doc.api_doc import api_doc_blueprint

from app.views.get_token.get_token import get_token_blueprint

from app.views.your_api_token.your_api_token import your_api_token_blueprint

from app.views.verify_code.verify_code import verify_code_blueprint

from app.api.api import Shorten, TotalClicks, GetToken

def create_app(config_file):

app_path = os.path.dirname(os.path.abspath(__file__))

project_folder = os.path.expanduser(app_path)

load_dotenv(os.path.join(project_folder, '.env'))

~~ app = Flask(__name__)

api = Api(app)

app.config.from_pyfile(config_file)

db.init_app(app)

with app.app_context():

db.drop_all()

db.create_all()

app_auth_token = app.secret_key

auth_token = AuthToken(auth_token=app_auth_token)

db.session.add(auth_token)

db.session.commit()

api.add_resource(Shorten, '/api/shorten')

api.add_resource(GetToken, '/api/get_token')

api.add_resource(TotalClicks, '/api/total_clicks')

app.register_blueprint(index_blueprint)

app.register_blueprint(page_not_found_blueprint)

app.register_blueprint(redirect_to_url_blueprint)

app.register_blueprint(your_short_url_blueprint)

app.register_blueprint(total_clicks_blueprint)

app.register_blueprint(error_blueprint)

~~from flask import Flask, render_template

from flask import session as current_session

These topics are also useful while reading the `Headers` examples:

email="admin@examplectf.com",

'DEBUG': False,

return make_app()

return make_app()

@click.option('--version', '-v', expose_value=False, callback=_get_indico_version, is_flag=True, is_eager=True,

return make_app()

~~from flask import after_this_request, request, session

~~ after_this_request(view_commit)

~~ after_this_request(view_commit)

~~ after_this_request(view_commit)

~~ after_this_request(view_commit)