def test_save_namedext(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='boat.jpg')
res = uset.save(tfs, name='photo_123.')
assert res == 'photo_123.jpg'
assert tfs.saved == '/uploads/photo_123.jpg'
def test_implicit_folder(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='boat.jpg')
res = uset.save(tfs, name='someguy/photo_123.')
assert res == 'someguy/photo_123.jpg'
assert tfs.saved == '/uploads/someguy/photo_123.jpg'
def test_save_folders(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
res = uset.save(tfs, folder='someguy')
assert res == 'someguy/foo.txt'
assert tfs.saved == '/uploads/someguy/foo.txt'
def test_save_folders(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
res = uset.save(tfs, folder='someguy')
assert res == 'someguy/foo.txt'
assert tfs.saved == '/uploads/someguy/foo.txt'
def test_save_namedext(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='boat.jpg')
res = uset.save(tfs, name='photo_123.')
assert res == 'photo_123.jpg'
assert tfs.saved == '/uploads/photo_123.jpg'
def test_save_named(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
res = uset.save(tfs, name='file_123.txt')
assert res == 'file_123.txt'
assert tfs.saved == '/uploads/file_123.txt'
def test_implicit_folder(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='boat.jpg')
res = uset.save(tfs, name='someguy/photo_123.')
assert res == 'someguy/photo_123.jpg'
assert tfs.saved == '/uploads/someguy/photo_123.jpg'
def _configuploadset(name, constraint):
uset = UploadSet(name, constraint)
uset._config = UploadConfiguration(
conf.UPLOADS_DEFAULT_DEST,
conf.UPLOADED_FILES_URL,
)
return uset
def test_conflict(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
self.extant('/uploads/foo.txt')
res = uset.save(tfs)
assert res == 'foo_1.txt'
def test_conflict(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
self.extant('/uploads/foo.txt')
res = uset.save(tfs)
assert res == 'foo_1.txt'
def test_save_named(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
res = uset.save(tfs, name='file_123.txt')
assert res == 'file_123.txt'
assert tfs.saved == '/uploads/file_123.txt'
def test_multi_conflict(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
self.extant('/uploads/foo.txt',
*('/uploads/foo_%d.txt' % n for n in range(1, 6)))
res = uset.save(tfs)
assert res == 'foo_6.txt'
def test_filenames(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
namepairs = (('foo.txt', True), ('boat.jpg', True), ('warez.exe',
False))
for name, result in namepairs:
tfs = TestingFileStorage(filename=name)
assert uset.file_allowed(tfs, name) is result
def test_conflict_without_extension(self):
# Test case for issue #7.
uset = UploadSet('files', extensions=(''))
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo')
self.extant('/uploads/foo')
res = uset.save(tfs)
assert res == 'foo_1'
def test_multi_conflict(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo.txt')
self.extant('/uploads/foo.txt',
*('/uploads/foo_%d.txt' % n for n in range(1, 6)))
res = uset.save(tfs)
assert res == 'foo_6.txt'
def test_conflict_without_extension(self):
# Test case for issue #7.
uset = UploadSet('files', extensions=(''))
uset._config = Config('/uploads')
tfs = TestingFileStorage(filename='foo')
self.extant('/uploads/foo')
res = uset.save(tfs)
assert res == 'foo_1'
def test_selfserve(self):
f, p = UploadSet('files'), UploadSet('photos')
setconfig = self.configure(f,
p,
UPLOADED_FILES_DEST='/var/files',
UPLOADED_PHOTOS_DEST='/mnt/photos')
fconf, pconf = setconfig['files'], setconfig['photos']
assert fconf == Config('/var/files', None)
assert pconf == Config('/mnt/photos', None)
def test_url_based(self):
app = Flask(__name__)
app.config.update(UPLOADED_FILES_DEST='/uploads',
UPLOADED_FILES_URL='http://localhost:5001/')
uset = UploadSet('files')
configure_uploads(app, uset)
with app.test_request_context():
url = uset.url('foo.txt')
assert url == 'http://localhost:5001/foo.txt'
assert '_uploads' not in app.modules
def test_secured_filename(self):
uset = UploadSet('files', ALL)
uset._config = Config('/uploads')
tfs1 = TestingFileStorage(filename='/etc/passwd')
tfs2 = TestingFileStorage(filename='../../myapp.wsgi')
res1 = uset.save(tfs1)
assert res1 == 'etc_passwd'
assert tfs1.saved == '/uploads/etc_passwd'
res2 = uset.save(tfs2)
assert res2 == 'myapp.wsgi'
assert tfs2.saved == '/uploads/myapp.wsgi'
def test_secured_filename(self):
uset = UploadSet('files', ALL)
uset._config = Config('/uploads')
tfs1 = TestingFileStorage(filename='/etc/passwd')
tfs2 = TestingFileStorage(filename='../../myapp.wsgi')
res1 = uset.save(tfs1)
assert res1 == 'etc_passwd'
assert tfs1.saved == '/uploads/etc_passwd'
res2 = uset.save(tfs2)
assert res2 == 'myapp.wsgi'
assert tfs2.saved == '/uploads/myapp.wsgi'
def test_filenames(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
namepairs = (
('foo.txt', True),
('boat.jpg', True),
('warez.exe', False)
)
for name, result in namepairs:
tfs = TestingFileStorage(filename=name)
assert uset.file_allowed(tfs, name) is result
def test_url_generated(self):
app = Flask(__name__)
app.config.update(
UPLOADED_FILES_DEST='/uploads'
)
uset = UploadSet('files')
configure_uploads(app, uset)
with app.test_request_context():
url = uset.url('foo.txt')
gen = url_for('_uploads.uploaded_file', setname='files',
filename='foo.txt', _external=True)
assert url == gen
def test_url_generated(self):
app = Flask(__name__)
app.config.update(UPLOADED_FILES_DEST='/uploads')
uset = UploadSet('files')
configure_uploads(app, uset)
with app.test_request_context():
url = uset.url('foo.txt')
gen = url_for('_uploads.uploaded_file',
setname='files',
filename='foo.txt',
_external=True)
assert url == gen
def test_manual(self):
f, p = UploadSet('files'), UploadSet('photos')
setconfig = self.configure(
f,
p,
UPLOADED_FILES_DEST='/var/files',
UPLOADED_FILES_URL='http://localhost:6001/',
UPLOADED_PHOTOS_DEST='/mnt/photos',
UPLOADED_PHOTOS_URL='http://localhost:6002/')
fconf, pconf = setconfig['files'], setconfig['photos']
assert fconf == Config('/var/files', 'http://localhost:6001/')
assert pconf == Config('/mnt/photos', 'http://localhost:6002/')
def test_url_based(self):
app = Flask(__name__)
app.config.update(
UPLOADED_FILES_DEST='/uploads',
UPLOADED_FILES_URL='http://localhost:5001/'
)
uset = UploadSet('files')
configure_uploads(app, uset)
with app.test_request_context():
url = uset.url('foo.txt')
assert url == 'http://localhost:5001/foo.txt'
assert '_uploads' not in app.modules
def test_defaults(self):
f, p = UploadSet('files'), UploadSet('photos')
setconfig = self.configure(
f,
p,
UPLOADS_DEFAULT_DEST='/var/uploads',
UPLOADS_DEFAULT_URL='http://localhost:6000/')
fconf, pconf = setconfig['files'], setconfig['photos']
assert fconf == Config('/var/uploads/files',
'http://localhost:6000/files/')
assert pconf == Config('/var/uploads/photos',
'http://localhost:6000/photos/')
def upload():
images = UploadSet('images', IMAGES)
logging.info(request)
if request.method == 'POST' and 'image_1' and 'image_2' in request.files:
filename_1 = images.save(app.config['UPLOAD'], request.files['image_1'])
filename_2 = images.save(app.config['UPLOAD'], request.files['image_2'])
rec = Photo(filename=filename, user=g.user.id)
rec.store()
flash("Photo saved.")
return "OK", 204
return "Failed", 404
def test_defaultdest_callable(self):
f = UploadSet('files',
default_dest=lambda app: os.path.join(
app.config['INSTANCE'], 'files'))
p = UploadSet('photos')
setconfig = self.configure(
f,
p,
INSTANCE='/home/me/webapps/thisapp',
UPLOADED_PHOTOS_DEST='/mnt/photos',
UPLOADED_PHOTOS_URL='http://localhost:6002/')
fconf, pconf = setconfig['files'], setconfig['photos']
assert fconf == Config('/home/me/webapps/thisapp/files', None)
assert pconf == Config('/mnt/photos', 'http://localhost:6002/')
def upload_photo(file_data, path, filename):
"""Uploads a photo to storage."""
photo_set = UploadSet('photos', IMAGES)
if photo_set:
# Create the thumbnail and preview
thumb = create_thumbnail(file_data.stream, THUMB_SIZE)
preview = create_thumbnail(file_data.stream, PREVIEW_SIZE)
# Save the full size picture and the thumbnail and preview
try:
photo_set.save(file_data, path, filename)
save_image(thumb, path, 'thumb_' + filename)
save_image(preview, path, 'preview_' + filename)
except Exception, ex:
raise ex
def configure_media_uploads(app=None):
"""
ABOUT
This configures the uploading and hosting of our image
files. UploadSet is pretty flexible, but we don't do
a whole lot to customize this.
"""
uploaded_photos = UploadSet('photos', IMAGES)
configure_uploads(app, uploaded_photos)
app.uploaded_photos = uploaded_photos
def test_path(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
assert uset.path('foo.txt') == '/uploads/foo.txt'
assert uset.path('someguy/foo.txt') == '/uploads/someguy/foo.txt'
assert (uset.path('foo.txt',
folder='someguy') == '/uploads/someguy/foo.txt')
assert (uset.path('foo/bar.txt',
folder='someguy') == '/uploads/someguy/foo/bar.txt')
def test_path(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
assert uset.path('foo.txt') == '/uploads/foo.txt'
assert uset.path('someguy/foo.txt') == '/uploads/someguy/foo.txt'
assert (uset.path('foo.txt', folder='someguy') ==
'/uploads/someguy/foo.txt')
assert (uset.path('foo/bar.txt', folder='someguy') ==
'/uploads/someguy/foo/bar.txt')
class Config(object):
DEBUG = False
TESTING = False
CSRF_ENABLED = True
SECRET_KEY = os.environ.get('FLASK_SECRET_KEY',
'this-really-needs-to-be-changed')
SQLALCHEMY_DATABASE_URI = os.environ.get(
'DATABASE_URL', 'postgresql:///salud_dev?client_encoding=utf8')
# Parámetro que indica si el parser de argumentos debe devolver la totalidad de los errores encontrados en una
# petición a la API (True), o sólo el primer error (False).
BUNDLE_ERRORS = True
# Directorio donde guardaremos el archivo
#UPLOAD_FOLDER = '/tmp'
#ALLOWED_IMG_EXTENSIONS = set(['png'])
UPLOADED_PHOTOS_DEST = '/tmp/imagenes'
MAX_CONT_IMG_LENGTH = 6 * 1024 * 1024
uploaded_photos = UploadSet('photos', IMAGES)
# Claves, pública y privada, de autenticación de la aplicación en Dropbox.
DROPBOX_APP_KEY = 'i7u47ht1t730nar'
DROPBOX_APP_SECRET = os.environ.get('DROPBOX_APP_SECRET', '')
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.migrate import Migrate
from flaskext.markdown import Markdown
from flaskext.uploads import UploadSet, configure_uploads, IMAGES
app = Flask(__name__)
app.config.from_object('settings')
db = SQLAlchemy(app)
# migrations
migrate = Migrate(app, db)
# markdown
md = Markdown(app, extensions=['fenced_code', 'tables'])
# images
uploaded_images = UploadSet('images', IMAGES)
configure_uploads(app, uploaded_images)
from blog import views
from user import views
from datetime import datetime
from sys import exit
from flask import Flask, render_template
from flask.ext.mongoengine import MongoEngine
from flaskext.uploads import UploadSet, configure_uploads, patch_request_class
from flask.ext.assets import Environment, Bundle
from mongoengine.connection import ConnectionError
# Configure Flask app
app = Flask(__name__)
app.config.from_object('settings')
# Configure uploads
vcf_uploads = UploadSet(name = 'vcf', extensions = tuple(app.config['UPLOAD_FORMAT_EXTENSIONS']))
configure_uploads(app, vcf_uploads)
patch_request_class(app, app.config['UPLOADED_VCF_MAX_SIZE']) # 128MB max upload size
# Attempt connection to MongoDB instance
try:
db = MongoEngine(app)
except ConnectionError, e:
print str(e)
print "----"
print "Are you sure your MongoDB instance is running?"
print "If on another server or port, look at settings.py."
exit(1)
from autozygosity import views, models, helpers, modules
# Configure Jinja2 filters
UploadConfiguration)
from flask.ext.pymongo import PyMongo
import hashlib
import subprocess
import json
import os
import zipfile
from functools import wraps
app = create_app()
UPLOAD_DEST = os.path.join(os.path.abspath(os.path.dirname(__file__)),
'static/data')
uploaded_files = UploadSet('tracks', ARCHIVES,
default_dest=lambda app: app.instance_path)
configure_uploads(app, uploaded_files)
uploaded_files._config = UploadConfiguration(UPLOAD_DEST)
configure_uploads(app, uploaded_files)
mongo = PyMongo(app)
def check_auth(username, password):
"""This function is called to check if a username /
password combination is valid.
"""
users = app.config.get('USERS')
passkey = app.config.get('SECRET')[0]
if username in users and passkey == password:
return username
app = Flask(__name__)
app.config.from_object(setting)
app.debug = True
toolbar = DebugToolbarExtension(app)
mail = Mail(app)
babel = Babel(app)
cache = Cache(app)
#db = SQLAlchemy(app)
principals = Principal(app)
login_manager = LoginManager()
login_manager.setup_app(app)
userimage = UploadSet('userimage', IMAGES)
configure_uploads(app, (userimage))
# setting
# fix issue of unicode
reload(sys)
sys.setdefaultencoding("utf-8")
# fix issue of forerign_keys problem for SQLite
#db.session.execute('PRAGMA foreign_keys=ON;')
class SQLiteForeignKeysListener(PoolListener):
def connect(self, dbapi_con, con_record):
db_cursor = dbapi_con.execute('pragma foreign_keys=ON')
class StrictSQLAlchemy(SQLAlchemy):
def test_default_selfserve(self):
f, p = UploadSet('files'), UploadSet('photos')
setconfig = self.configure(f, p, UPLOADS_DEFAULT_DEST='/var/uploads')
fconf, pconf = setconfig['files'], setconfig['photos']
assert fconf == Config('/var/uploads/files', None)
assert pconf == Config('/var/uploads/photos', None)
from flask.ext.sqlalchemy import SQLAlchemy
from flaskext.uploads import UploadSet, ALL
__all__ = ['db']
db = SQLAlchemy()
UploadSet.image_path = lambda self, dirname, filename: self.path('%s/%s' % (dirname, filename))
iscsi_images_store = UploadSet('iscsiImage', extensions=ALL,
default_dest=lambda app: app.config.get('ISCSI_IMAGES_STORE', '/dev/null')
)
iscsi_images_store.resolve_conflict = lambda target_folder, basename: basename
pxe_images_store = UploadSet('pxeImage', extensions=ALL,
default_dest=lambda app: app.config.get('PXE_IMAGES_STORE', '/dev/null')
)
pxe_images_store.resolve_conflict = lambda target_folder, basename: basename
kernels_store = UploadSet('kernel', extensions=ALL,
default_dest=lambda app: app.config.get('KERNELS_STORE', '/dev/null')
)
kernels_store.resolve_conflict = lambda target_folder, basename: basename
from image import *
import const
ROOT_PATH = os.path.dirname(__file__)
ABS_PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
DEBUG = True
SECRET_KEY = 'ZL=_K8RJ:e{+6WwdlnX~tR6a|`BoYBi>'
UPLOADS_DEFAULT_DEST = ABS_PROJECT_ROOT + "/static"
UPLOADS_DEFAULT_URL = 'http://127.0.0.1:5000/static'
app = Flask(__name__)
app.config.from_object(__name__)
app.config.from_envvar('YOUTHING_SETTINGS', silent=True)
uploads = UploadSet('uploads', IMAGES)
configure_uploads(app, uploads)
@app.route("/")
def index():
entries = Entry().query(None, 0, const.PAGE_SIZE * 2)
categories = Category().query(None, 0, const.MAX_CATEGORY_SIZE)
return render_template("index.html",
entries=entries,
categories=categories,
page=2,
cat="")
BooleanField,
file,
FileField,
Form,
PasswordField,
RadioField,
SubmitField,
TextAreaField,
TextField,
ValidationError,
validators,
)
import models
savefiles = UploadSet('savefiles', ('user', 'zip'))
class RegistrationForm(Form):
username = TextField('Username', [
validators.Required(),
validators.Length(
min=3, max=30, message='Username must be %(min)d - %(max)d chars'),
validators.Regexp(
'^[A-Za-z0-9\-_]+$',
message=
'Username may only contain letters, numbers, dashes and underscores'
)
])
email = TextField('Email', [
validators.Required(),
ADMIN_USERNAME = '******'
ADMIN_PASSWORD = '******'
COUCHDB_SERVER = 'http://localhost:5984/'
COUCHDB_DATABASE = 'flask-photolog'
# application
app = Flask(__name__)
app.config.from_object(__name__)
app.config.from_envvar('PHOTOLOG_SETTINGS', silent=True)
# uploads
uploaded_photos = UploadSet('photos', IMAGES)
configure_uploads(app, uploaded_photos)
# documents
manager = CouchDBManager()
def unique_id():
return hex(uuid.uuid4().time)[2:-1]
class Post(Document):
doc_type = 'post'
title = TextField()
filename = TextField()
def create_app(app_name, config_obj, with_api=True):
""" Generates and configures the main shop application. All additional """
# Launching application
app = Flask(app_name) # So the engine would recognize the root package
# Load Configuration
app.config.from_object(config_obj)
# Loading assets
assets = Environment(app)
assets.from_yaml('assets.yaml')
app.assets = assets
# Initialize Mail
app.mail = Mail(app)
# Initializing login manager
login_manager = LoginManager()
login_manager.login_view = app.config.get('LOGIN_VIEW', 'main.index')
# login_manager.login_message = 'You need to be logged in to access this page'
login_manager.session_protection = 'strong'
login_manager.setup_app(app)
app.login_manager = login_manager
# Initializing principal manager
app.principal = Principal(app)
# Initializing bcrypt password encryption
bcrypt = Bcrypt(app)
app.bcrypt = bcrypt
# Initializing Database
db = SQLAlchemy(app)
app.db = db
# Initializing Migrate
migrate = Migrate(app, db, "from fitted.models import *")
app.migrate = migrate
photos = UploadSet('photos', IMAGES)
archives = UploadSet('archives', ARCHIVES)
configure_uploads(app, (photos, archives))
patch_request_class(app,
2 * 1024 * 1024) # Patches to 2MB file uploads max.
app.photos = photos
app.archives = archives
# Integrate Elasticsearch
es_config = app.config.get("ES_CONFIG", [])
app.es = Elasticsearch(es_config)
# Integrate sms with Twilio
app.sms = TwilioRestClient(app.config.get("TWILIO_API_SID"),
app.config.get("TWILIO_API_TOKEN"))
# Redis store for session management
# The process running Flask needs write access to this directory:
# store = RedisStore(redis.StrictRedis())
# # this will replace the app's session handling
# KVSessionExtension(store, app)
# configure sentry
# if not app.config.get("DEBUG", False):
# sentry = Sentry(app)
# app.sentry = sentry
# inject celery into the app
app.celery = make_celery(app)
# injecting mongodb support
# app.mongo = PyMongo(app)
# flask s3 integration
app.s3 = FlaskS3(app)
# Facebook & Twitter Integration
app.facebook = oauth.remote_app('facebook', app_key='FACEBOOK')
oauth.init_app(app)
# Initializing the restful API
if with_api:
api = restful.Api(app, prefix='/api/v1')
app.api = api
# Initialize Logging
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler(
"/var/log/fitted/%s.log" %
app.config.get("LOGFILE_NAME", app_name),
maxBytes=500 * 1024)
file_handler.setLevel(logging.WARNING)
from logging import Formatter
file_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(file_handler)
#include an api_registry to the application
app.api_registry = [] #a simple list holding the values to be registered
return app
def test_default_extensions(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
extpairs = (('txt', True), ('jpg', True), ('exe', False))
for ext, result in extpairs:
assert uset.extension_allowed(ext) is result
# 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/>.
from flask import Flask, request, redirect, make_response
from flaskext.uploads import UploadSet, ALL, configure_uploads
from time import time
from os import listdir, path
from mimetypes import guess_type
PATH = '/home/cryptoparty'
app = Flask(__name__)
messages = UploadSet('messages', ALL, default_dest=lambda _: PATH)
configure_uploads(app, (messages, ))
@app.route('/', methods=['GET'])
def form():
return """\
<html>
<head>
<title>InsecureDrop</title>
</head>
<body>
<h1>InsecureDrop</h1>
Upload a new file:<br />
<form method="POST" enctype="multipart/form-data">
<input type="file" name="message" />
import cache
from flask import (Flask, make_response, request, jsonify, session,
render_template, redirect, url_for, send_from_directory,
flash, abort)
from flask.ext.pymongo import PyMongo
from flaskext.uploads import (UploadSet, configure_uploads, IMAGES,
DATA, DOCUMENTS, UploadConfiguration)
from logging import FileHandler
from werkzeug import secure_filename
from utilities import ObjectIdCleaner
app = Flask(__name__)
app.config.from_pyfile('conf.py')
mongo = PyMongo(app)
plugin_upload = UploadSet('plugins', ('js', 'css'),
default_dest=lambda app: app.instance_path)
plugin_upload._config = UploadConfiguration(app.config.get(
'PLUGIN_UPLOAD_FOLDER'))
files_upload = UploadSet('files', IMAGES + DOCUMENTS + DATA + ('pdf',),
default_dest=lambda app: app.instance_path)
files_upload._config = UploadConfiguration(app.config.get(
'FILE_UPLOAD_FOLDER'))
configure_uploads(app, plugin_upload)
configure_uploads(app, files_upload)
app.register_module(cache.cache, url_prefix='/cache')
bson.ObjId = bson.objectid.ObjectId # handy reference to otherwise long name
from flask import Flask
from flask.ext.mail import Mail
from flask.ext.wtf.csrf import CsrfProtect
from flaskext.uploads import UploadSet
from sponsortracker import data
app = Flask(__name__, template_folder='templates', static_folder='static')
app.config.from_object("sponsortracker.settings")
csrf = CsrfProtect(app)
mail = Mail(app)
preview_uploader = UploadSet("previews", data.ASSET_FORMATS_EXT)
def test_default_extensions(self):
uset = UploadSet('files')
uset._config = Config('/uploads')
extpairs = (('txt', True), ('jpg', True), ('exe', False))
for ext, result in extpairs:
assert uset.extension_allowed(ext) is result
