def test_query_params_are_accesible(self):
app = Flask(__name__)
def multiplier(request, value):
return {"result": value * int(request.args.get("multiplier", 1))}
api_v1 = Api(version="v1")
multiplier_endpoint = ApiEndpoint(http_method="GET", endpoint="/multiply/<int:value>/", handler=multiplier)
api_v1.register_endpoint(multiplier_endpoint)
app.register_blueprint(api_v1)
app.config["TESTING"] = True
self.app = app.test_client()
resp = self.app.get("/v1/multiply/3/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"result": 3})
resp = self.app.get("/v1/multiply/3/?multiplier=5", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"result": 15})
def create_app(self):
"""Create the app."""
from flask_iiif import IIIF
from flask_restful import Api
from flask_iiif.cache.simple import ImageSimpleCache
app = Flask(__name__)
app.config["DEBUG"] = True
app.config["TESTING"] = True
app.config["SERVER_NAME"] = "shield.worker.node.1"
app.config["SITE_URL"] = "http://shield.worker.node.1"
app.config["IIIF_CACHE_HANDLER"] = ImageSimpleCache()
app.logger.disabled = True
api = Api(app=app)
iiif = IIIF(app=app)
iiif.uuid_to_image_opener_handler(self.create_image)
def api_decorator_test(*args, **kwargs):
if "decorator" in kwargs.get("uuid"):
abort(403)
iiif.api_decorator_handler(api_decorator_test)
iiif.init_restful(api)
return app
def setUp(self):
app = Flask(__name__)
app.config["TESTING"] = True
@app.route(CONSUMES_JSON_ONLY)
@consumes(JSON)
def consumes_json_only():
return CONSUMES_JSON_ONLY
@app.route(CONSUMES_JSON_AND_HTML)
@consumes(JSON, HTML)
def consumes_json_and_html():
return CONSUMES_JSON_AND_HTML
@app.route(PRODUCES_JSON_ONLY)
@produces(JSON)
def produces_json_only():
return PRODUCES_JSON_ONLY
@app.route(PRODUCES_JSON_AND_HTML)
@produces(JSON, HTML)
def produces_json_and_html():
return PRODUCES_JSON_AND_HTML
self.app = app
self.client = app.test_client()
def test_version_accesible_from_handler(self):
app = Flask(__name__)
def get_task(request):
return {"version": request.api.version}
api_201409 = Api(version="v1")
api_201507 = Api(version="v2")
task_endpoint = ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_task)
api_201409.register_endpoint(task_endpoint)
api_201507.register_endpoint(task_endpoint)
app.register_blueprint(api_201409)
app.register_blueprint(api_201507)
app.config["TESTING"] = True
self.app = app.test_client()
resp = self.app.get("/v1/task/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"version": "v1"})
resp = self.app.get("/v2/task/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"version": "v2"})
def app(request):
from flask import Flask
app = Flask(__name__)
app.config["TESTING"] = True
app.config["SEGMENTIO_SEND"] = False
app.config["SEGMENTIO_WRITE_KEY"] = "testing"
return app
def create_app(self):
app = Flask(
__name__,
template_folder="../../app/static/templates"
)
app.config["TESTING"] = True
app.register_blueprint(main)
return app
def _get_test_client(self, api):
@api.dispatcher.add_method
def dummy():
return ""
app = Flask(__name__)
app.config["TESTING"] = True
app.register_blueprint(api.as_blueprint())
return app.test_client()
def app(request):
from flask import Flask
app = Flask(__name__)
app.config["TESTING"] = True
app.config["FLYWHEEL_DATABASE_HOST"] = "localhost"
app.config["FLYWHEEL_DATABASE_PORT"] = 8000
app.config["FLYWHEEL_SECURE"] = False
return app
def create_app(self):
app = Flask(config.APP_NAME)
app = create_app(app)
app.config["TESTING"] = True
if app.config.get('TEST_DB_URI') is None:
raise TestCaseDBException("No TEST_DB_URI specified in config.py!")
app.config['SQLALCHEMY_DATABASE_URI'] = app.config.get('TEST_DB_URI')
self.migration = Migration(app)
return app
def setup_method(self, test_method):
#self.db_fd, flaskr.app.config['DATABASE'] = tempfile.mkstemp()
#flaskr.app.config['TESTING'] = True
app = Flask(__name__)
app.config["DEBUG"] = True
app.config["TESTING"] = True
app.register_blueprint(module_one)
self.app = app.test_client()
#flaskr.init_db()
self.api_payload = {
"user_name": "Alice",
"greeting": "Howdy",
}
def setUp(self):
"""Creates the Flask application and the APIManager."""
super(FlaskTestBase, self).setUp()
# create the Flask application
app = Flask(__name__)
app.config["DEBUG"] = True
app.config["TESTING"] = True
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///%s" % DB["filename"]
self.flaskapp = app
# create the test client
self.app = app.test_client()
def create_test_app():
"""
Create the Slack-lmgtfy application.
@param instance_path the instance path of the web application. See Flask doc for more info
@return the Slack-lmgtfy flask application
"""
app = Flask("slack_lmgtfy")
app.config["TESTING"] = True
app.config.from_object("slack_lmgtfy.default_config")
from slack_lmgtfy.views import bp
app.register_blueprint(bp)
return app
def app_context():
app = Flask(__name__)
app.config["SECRET_KEY"] = "deterministic"
app.config["TESTING"] = True
app.config["PROPAGATE_EXCEPTIONS"] = True
app.config["DEBUG"] = True
@app.route("/")
def index():
return u"The index"
@app.route("/login")
def login():
id = int(request.args["id"])
force = "force" in request.args
remember = "remember" in request.args
if login_user(USERS[id], force=force, remember=remember):
if "permanent" in request.args:
session.permanent = True
return u"Logged in"
else:
return u"Go away, creeper"
class Protected(LoginRequiredMixin, MethodView):
def get(self):
return u"Welcome, %s" % current_user.name
app.add_url_rule("/protected", view_func=Protected.as_view("protected"))
@app.route("/sensitive-action")
@fresh_login_required
def sensitive_action():
return u"Be careful, %s" % current_user.name
@app.route("/logout")
@login_required
def logout():
logout_user()
return u"Logged out"
@app.route("/reauth")
@login_required
def reauth():
confirm_login()
return u"Login confirmed"
with app.test_request_context():
yield app
def app():
app_ = Flask("testapp")
app_.config["DEBUG"] = True
app_.config["TESTING"] = True
@app_.route("/posts/<post_id>/comments/")
def posts_comments(post_id):
return "Comments for post {}".format(post_id)
@app_.route("/authors/<int:author_id>")
def author_detail(author_id):
return "Detail for author {}".format(author_id)
ctx = app_.test_request_context()
ctx.push()
yield app_
ctx.pop()
def setUp(self):
app = Flask(__name__)
self.tasks = [{"id": 1, "task": "Do the laundry"}, {"id": 2, "task": "Do the dishes"}]
def get_tasks(request):
return self.tasks
def post_task(request):
data = request.json
self.tasks.append({"task": data["task"]})
return {}, 201
def put_task(request, task_id):
task = get_task_by_id(self.tasks, task_id)
data = request.json
task["task"] = data["task"]
task["id"] = data["id"]
return {}, 204
def patch_task(request, task_id):
task = get_task_by_id(self.tasks, task_id)
data = request.json
task["task"] = data["task"]
return {}, 204
def delete_task(request, task_id):
index = get_task_index_by_id(self.tasks, task_id)
task = self.tasks.pop(index)
return task
api_201409 = Api(version="v1")
api_201409.register_endpoint(ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_tasks))
api_201409.register_endpoint(ApiEndpoint(http_method="POST", endpoint="/task/", handler=post_task))
api_201409.register_endpoint(ApiEndpoint(http_method="PUT", endpoint="/task/<int:task_id>/", handler=put_task))
api_201409.register_endpoint(
ApiEndpoint(http_method="PATCH", endpoint="/task/<int:task_id>/", handler=patch_task)
)
api_201409.register_endpoint(
ApiEndpoint(http_method="DELETE", endpoint="/task/<int:task_id>/", handler=delete_task)
)
app.register_blueprint(api_201409)
app.config["TESTING"] = True
self.app = app.test_client()
def test_versions_with_different_endpoints_different_url(self):
app = Flask(__name__)
get_tasks = mock.MagicMock(return_value={"id": 1, "task": "Do dishes"})
get_tasks.__name__ = "get_tasks"
get_users = mock.MagicMock(return_value={"id": 2, "username": "johndoe"})
get_users.__name__ = "get_users"
api_201409 = Api(version="v1")
api_201507 = Api(version="v2")
api_201409.register_endpoint(ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_tasks))
api_201507.register_endpoint(ApiEndpoint(http_method="GET", endpoint="/users/", handler=get_users))
app.register_blueprint(api_201409)
app.register_blueprint(api_201507)
app.config["TESTING"] = True
self.app = app.test_client()
resp = self.app.get("/v1/users/", content_type="application/json")
self.assertEqual(resp.status_code, 404)
resp = self.app.get("/v1/task/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"id": 1, "task": "Do dishes"})
self.assertEqual(get_tasks.call_count, 1)
self.assertEqual(get_users.call_count, 0)
resp = self.app.get("/v2/task/", content_type="application/json")
self.assertEqual(resp.status_code, 404)
resp = self.app.get("/v2/users/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"id": 2, "username": "johndoe"})
self.assertEqual(get_tasks.call_count, 1)
self.assertEqual(get_users.call_count, 1)
def app_context():
app = Flask(__name__)
app.config["SECRET_KEY"] = "deterministic"
app.config["TESTING"] = True
app.config["PROPAGATE_EXCEPTIONS"] = True
app.config["DEBUG"] = True
@app.route("/")
def index():
return u"The index"
@app.route("/login")
def login():
id = int(request.args["id"])
force = "force" in request.args
remember = "remember" in request.args
if login_user(USERS[id], force=force, remember=remember):
if "permanent" in request.args:
session.permanent = True
return u"Logged in"
else:
return u"Go away, creeper"
@app.route("/protected")
@login_required
def protected():
return u"Welcome, %s" % current_user.name
@app.route("/logout")
@login_required
def logout():
logout_user()
return u"Logged out"
@app.route("/reauth")
@login_required
def reauth():
confirm_login()
return u"Login confirmed"
with app.test_request_context():
yield app
def setUp(self):
app = Flask(__name__)
def success_handler(request):
if request.method == "GET":
return {}, 200
elif request.method == "POST":
return {}, 201
def conflict_handler(request):
return {"task": "Conflicted Task"}, 409
api_201409 = Api(version="v1")
api_201409.register_endpoint(ApiEndpoint(http_method=["GET", "POST"], endpoint="/", handler=success_handler))
api_201409.register_endpoint(ApiEndpoint(http_method="GET", endpoint="/conflict", handler=conflict_handler))
app.register_blueprint(api_201409)
app.config["TESTING"] = True
self.app = app.test_client()
def test_api_without_a_version_and_with_name(self):
app = Flask(__name__)
get_tasks = mock.MagicMock(return_value={"id": 1, "task": "Do dishes"})
get_tasks.__name__ = "get_tasks"
api_v1 = Api(name="Test-API")
api_v1.register_endpoint(ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_tasks))
app.register_blueprint(api_v1)
app.config["TESTING"] = True
self.app = app.test_client()
resp = self.app.get("/task/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data.decode(resp.charset))
self.assertEqual(data, {"id": 1, "task": "Do dishes"})
self.assertEqual(get_tasks.call_count, 1)
def generate_context(config):
"""Creates the Flask app context and initializes any extensions such as Celery, Redis, SQLAlchemy, etc.
Positional arguments:
config -- partial Flask config dict from generate_config().
Returns:
The Flask app instance.
"""
flask_app = Flask(__name__)
flask_app.config.update(config)
flask_app.config["TESTING"] = True
flask_app.config["CELERY_ACCEPT_CONTENT"] = ["pickle"]
if "SQLALCHEMY_DATABASE_URI" in flask_app.config:
db = SQLAlchemy(flask_app)
db.engine.execute("DROP TABLE IF EXISTS celery_tasksetmeta;")
elif "REDIS_URL" in flask_app.config:
redis = Redis(flask_app)
redis.flushdb()
Celery(flask_app)
return flask_app
def test_versions_with_same_endpoints(self):
app = Flask(__name__)
def get_task(request):
return self.tasks
api_201409 = Api(version="v1")
api_201507 = Api(version="v2")
task_endpoint = ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_task)
api_201409.register_endpoint(task_endpoint)
api_201507.register_endpoint(task_endpoint)
app.register_blueprint(api_201409)
app.register_blueprint(api_201507)
app.config["TESTING"] = True
self.app = app.test_client()
resp = self.app.get("/v1/task/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
resp = self.app.get("/v2/task/", content_type="application/json")
self.assertEqual(resp.status_code, 200)
def setUp(self):
app = Flask(__name__)
self.tasks = [{"id": 1, "task": "Do the laundry"}, {"id": 2, "task": "Do the dishes"}]
def get_tasks(request):
return self.tasks, 200, {"Access-Control-Allow-Origin": "*"}
def post_task(request):
data = request.json
self.tasks.append({"task": data["task"]})
return {}, 201, {"X-Special-Header": "XXX", "Access-Control-Allow-Origin": "*"}
api_201409 = Api(version="v1")
task_endpoint = ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_tasks)
api_201409.register_endpoint(task_endpoint)
task_endpoint = ApiEndpoint(http_method="POST", endpoint="/task/", handler=post_task)
api_201409.register_endpoint(task_endpoint)
app.register_blueprint(api_201409)
app.config["TESTING"] = True
self.app = app.test_client()
def setUp(self):
app = Flask(__name__)
tasks = [{"id": 1, "task": "Do the laundry"}, {"id": 2, "task": "Do the dishes"}]
def get_task(request):
return tasks
def post_task(request):
data = request.json
tasks.append({"task": data["task"]})
return {}, 201
api_201409 = Api(version="v1")
task_endpoint = ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_task)
api_201409.register_endpoint(task_endpoint)
task_endpoint = ApiEndpoint(http_method="POST", endpoint="/task/", handler=post_task)
api_201409.register_endpoint(task_endpoint)
app.register_blueprint(api_201409)
app.config["TESTING"] = True
self.app = app.test_client()
def setUp(self):
app = Flask(__name__)
self.tasks = [
{"id": 1, "task": "Do the laundry"},
{"id": 2, "task": "Do the dishes"},
{"id": 3, "task": "Take the dog out"},
]
def get_tasks(request):
return self.tasks
def get_task(request, task_id):
return get_task_by_id(self.tasks, task_id)
api_201409 = Api(version="v1")
all_task_endpoint = ApiEndpoint(http_method="GET", endpoint="/task/", handler=get_tasks)
task_endpoint = ApiEndpoint(http_method="GET", endpoint="/task/<int:task_id>/", handler=get_task)
api_201409.register_endpoint(task_endpoint)
api_201409.register_endpoint(all_task_endpoint)
app.register_blueprint(api_201409)
app.config["TESTING"] = True
self.app = app.test_client()
def setUp(self):
app = Flask(__name__)
app.config["DEBUG"] = True
app.config["TESTING"] = True
app.logger.disabled = True
self.app = app
from flask import Flask, render_template, send_from_directory, jsonify, redirect, url_for, request, abort
from flask.ext.sqlalchemy import SQLAlchemy
import uuid
import random, string
from dungeon import dungeon
from cards import cards
# Initilization
APPLICATION_CONFIG = os.environ.get("BLUE_MONGOOSE_SETTINGS")
BASE_URL = "https://blue-mongoose.herokuapp.com/"
app = Flask(__name__)
app.config["DEBUG"] = False
app.config["TESTING"] = False
if APPLICATION_CONFIG == "production":
print("Starting in production mode")
app.config["DATABASE_URI"] = os.environ["DATABASE_URL"]
GITHUB_CLIENT_ID = os.environ["GITHUB_CLIENT_ID"]
GITHUB_CLIENT_SECRET = os.environ["GITHUB_CLIENT_SECRET"]
else:
BASE_URL = "http://localhost:5000/"
app.config["DATABASE_URI"] = os.environ["BLUE_MONGOOSE_DATABASE_URL"]
GITHUB_CLIENT_ID = os.environ["BLUE_MONGOOSE_GITHUB_CLIENT_ID"]
GITHUB_CLIENT_SECRET = os.environ["BLUE_MONGOOSE_GITHUB_CLIENT_SECRET"]
if APPLICATION_CONFIG == "testing":
app.config["TESTING"] = True
from pprint import pprint
class TestedNamedView(NamedMethodView):
@namedmethod("editor")
def get(self):
return "editor get"
@namedmethod("editor", "post")
def editor_post(self):
return "editor post"
def post(self):
return "raw post"
test = Flask(__name__)
test.config["TESTING"] = True
test.config["DEBUG"] = True
test.config["SERVER_NAME"] = "localhost:5000"
test.add_url_rule("/test", view_func=TestedNamedView.as_view("test"))
class TestNamedMethodView(unittest.TestCase):
def setUp(self):
self.client = test.test_client()
def test_405(self):
self.assertTrue(self.client.get("/test").status_code == 405)
def test_named_get(self):
self.assertTrue(
"".join(self.client.get("/test", headers=[("X-View-Name", "editor")]).response) == "editor get"
def create_app(_run_mode=None):
# Create Flask app
global app
template_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')
app = Flask("application", template_folder=template_dir)
# Load kill switches
# app.config["APP_KILL_CACHE"] = os.environ.get("APP_KILL_CACHE", False)
# Load default configuration
app.config.from_object("application.default_config")
# Dev run mode
if _run_mode == "dev":
app.config["DEBUG"] = True
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" # Replace with local DB
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False # Otherwise this gets annoying real fast
DebugToolbarExtension(app)
# Test run mode
elif _run_mode == "test":
app.config["DEBUG"] = True
app.config["TESTING"] = True
app.config["WTF_CSRF_ENABLED"] = False # Or CSRF checks will fail
# app.config["APP_KILL_CACHE"] = True
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
# Production run mode
elif _run_mode == "production":
# Get additional configuration based on run environment
run_environment = os.environ.get("APP_RUN_ENV", "local")
if run_environment == "heroku":
# Get configuration data from Heroku environment variables
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URL")
elif run_environment == "vagrant":
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" # Replace with local DB
set_up_logging(app)
# Unrecognized run mode
else:
logging.error("Did not recognize run mode '%s'" % _run_mode)
return None, None
# Initialize the database
global db
import application.models
db.init_app(app)
# Initialize other Flask extensions
# Import the views, to apply the decorators which use the global app object.
import application.views
# Register blueprints
# from application.widget import widget_blueprint
# app.register_blueprint(widget_blueprint)
# Set up Jinja 2 filters
set_up_jinja_filters(app)
return app, db
from werkzeug.datastructures import Headers
import unittest
from base64 import b64encode
class MyAuthenticator(Authenticator):
def authenticate(self, auth_data):
if auth_data.username == "admin" and auth_data.password == "admin":
return {"username": auth_data.username, "password": auth_data.password}
return None
authenticator = MyAuthenticator(basic_auth_getter)
app = Flask(__name__)
app.config["TESTING"] = True
def send_401(message):
"""Sends a 401 response that enables basic auth"""
return Response(message, 401, {"WWW-Authenticate": 'Basic realm="Login Required"'})
@app.errorhandler(AuthDataDecodingException)
def bad_auth_data_callback(ex):
return send_401("Missing credentials")
@app.errorhandler(NotAuthenticatedException)
def not_authenticated_callback(ex):
return send_401("User not recognized")
def create_app(self):
app = Flask(__name__)
app.config["TESTING"] = True
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://"
return app