def setUp(self):
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = 'testing'
app.config['TESTING'] = True
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(app)
Todo.drop_collection()
self.Todo = Todo
@app.route('/')
def index():
return flask.jsonify(result=self.Todo.objects())
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'], text=form['text'])
todo.save()
return flask.jsonify(result=todo)
@app.route('/show/<id>/')
def show(id):
return flask.jsonify(result=self.Todo.objects.get_or_404(id=id))
self.app = app
self.db = db
def setUp(self):
super(BasicAppTestCase, self).setUp()
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(self.app)
Todo.drop_collection()
self.Todo = Todo
@self.app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@self.app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return 'added'
@self.app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.db = db
def setUp(self):
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = 'testing'
app.config['TESTING'] = True
db = MongoEngine()
self.Todo = make_todo_model(db)
db.init_app(app)
self.Todo.drop_collection()
@app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'], text=form['text'])
todo.save()
return 'added'
@app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.app = app
self.db = db
def setUp(self):
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = 'testing'
app.config['TESTING'] = True
db = MongoEngine()
self.Todo = make_todo_model(db)
db.init_app(app)
self.Todo.drop_collection()
@app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return 'added'
@app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.app = app
self.db = db
def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'testing'
self.app.config['TESTING'] = True
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(self.app)
Todo.drop_collection()
self.Todo = Todo
@self.app.route('/')
def index():
return flask.jsonify(result=self.Todo.objects())
@self.app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return flask.jsonify(result=todo)
@self.app.route('/show/<id>/')
def show(id):
return flask.jsonify(result=self.Todo.objects.get_or_404(id=id))
self.db = db
def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'testing'
self.app.config['TESTING'] = True
self.app.json_encoder = DummyEncoder
db = MongoEngine()
db.init_app(self.app)
self.db = db
def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'testing'
self.app.config['TESTING'] = True
self.app.json_encoder = DummyEncoder
db = MongoEngine()
db.init_app(self.app)
self.db = db
def test_connection_kwargs_with_false_values(self):
self.app.config['MONGODB_SETTINGS'] = {
'DB': 'testing',
'alias': 'test',
'use_greenlets': False
}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.assertFalse(db.connection.use_greenlets)
def test_connection_kwargs_with_false_values(self):
self.app.config['MONGODB_SETTINGS'] = {
'DB': 'testing',
'alias': 'test',
'use_greenlets': False
}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.assertFalse(db.connection.use_greenlets)
def setUp(self):
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = 'testing'
app.config['TESTING'] = True
app.json_encoder = DummyEncoder
db = MongoEngine()
db.init_app(app)
self.app = app
self.db = db
def test_connection_default(self):
self.app.config['MONGODB_SETTINGS'] = {}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
def test_connection_default(self):
app = flask.Flask(__name__)
app.config['MONGODB_SETTINGS'] = {}
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
def test_connection_default(self):
app = flask.Flask(__name__)
app.config['MONGODB_SETTINGS'] = {}
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
def setup():
app = Flask(__name__)
app.config['SECRET_KEY'] = '1'
app.config['CSRF_ENABLED'] = False
app.config['MONGODB_SETTINGS'] = {'DB': 'tests'}
db = MongoEngine()
db.init_app(app)
admin = Admin(app)
return app, db, admin
def setup():
app = Flask(__name__)
app.config['SECRET_KEY'] = '1'
app.config['CSRF_ENABLED'] = False
app.config['MONGODB_SETTINGS'] = {'DB': 'tests'}
db = MongoEngine()
db.init_app(app)
admin = Admin(app)
return app, db, admin
def test_connection_db_only(self):
app = flask.Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
'db': 'test'
}
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
app.config['MONGODB_DB'] = 'test'
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
def test_connection_kwargs_as_list(self):
self.app.config['MONGODB_SETTINGS'] = [{
'DB': 'testing_tz_aware',
'alias': 'tz_aware_true',
'TZ_AWARE': True
}, {
'DB': 'testing_tz_aware_off',
'alias': 'tz_aware_false',
'TZ_AWARE': False
}]
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.assertTrue(db.connection['tz_aware_true'].tz_aware)
self.assertFalse(db.connection['tz_aware_false'].tz_aware)
def test_connection_kwargs_as_list(self):
self.app.config['MONGODB_SETTINGS'] = [{
'DB': 'testing_tz_aware',
'alias': 'tz_aware_true',
'TZ_AWARE': True
}, {
'DB': 'testing_tz_aware_off',
'alias': 'tz_aware_false',
'TZ_AWARE': False
}]
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.assertTrue(db.connection['tz_aware_true'].tz_aware)
self.assertFalse(db.connection['tz_aware_false'].tz_aware)
def test_connection_kwargs(self):
app = flask.Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
'DB': 'testing_tz_aware',
'alias': 'tz_aware_true',
'TZ_AWARE': True,
}
app.config['TESTING'] = True
db = MongoEngine()
db.init_app(app)
self.assertTrue(db.connection.tz_aware)
app.config['MONGODB_SETTINGS'] = {
'DB': 'testing',
'alias': 'tz_aware_false',
}
db.init_app(app)
self.assertFalse(db.connection.tz_aware)
def test_connection_kwargs(self):
self.app.config['MONGODB_SETTINGS'] = {
'DB': 'testing_tz_aware',
'ALIAS': 'tz_aware_true',
'TZ_AWARE': True
}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.assertTrue(db.connection.tz_aware)
# PyMongo defaults to tz_aware = True so we have to explicitly turn
# it off.
self.app.config['MONGODB_SETTINGS'] = {
'DB': 'testing',
'ALIAS': 'tz_aware_false',
'TZ_AWARE': False
}
db = MongoEngine()
db.init_app(self.app)
self.assertFalse(db.connection.tz_aware)
def test_connection_kwargs(self):
self.app.config['MONGODB_SETTINGS'] = {
'DB': 'testing_tz_aware',
'ALIAS': 'tz_aware_true',
'TZ_AWARE': True
}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.assertTrue(db.connection.tz_aware)
# PyMongo defaults to tz_aware = True so we have to explicitly turn
# it off.
self.app.config['MONGODB_SETTINGS'] = {
'DB': 'testing',
'ALIAS': 'tz_aware_false',
'TZ_AWARE': False
}
db = MongoEngine()
db.init_app(self.app)
self.assertFalse(db.connection.tz_aware)
def test_connection_missing_db(self):
app = flask.Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
'alias': 'tz_aware_true',
'TZ_AWARE': True
}
app.config['TESTING'] = True
db = MongoEngine()
try:
db.init_app(app)
self.assertFalse("ValueError should've been raised")
except ValueError:
pass
app.config['MONGODB_HOST'] = 'mongodb://localhost'
app.config['TESTING'] = True
db = MongoEngine()
try:
db.init_app(app)
self.assertFalse("ValueError should've been raised")
except ValueError:
pass
def create_app():
app = Flask(__name__, static_folder='../public/', static_url_path='/public')
app.response_class = ResponseJSON
app.config.from_pyfile(config.FLASK_CONFIG_PATH)
# change debug output formatter to a pretty one-liner
format = Formatter("%(levelname)6s | %(relativeCreated)6d | %(filename)s:%(lineno)d | %(message)s")
app.logger.handlers[0].setFormatter(format)
# resolve paths relative to this file
app_path = path.dirname(__file__)
app.config.update({
'RECORDINGS_PATH': path.realpath(app_path + '/../public/recordings/'),
'PATH_USER_PROFILE_IMAGE': path.realpath(app_path + '/../public/profile_images/'),
'PATH_ASSETS': path.realpath(app_path + '/../public/assets/'),
'PATH_PUBLIC': path.realpath(app_path + '/../public/'),
})
# sanity checks
if not path.isdir(app.config['RECORDINGS_PATH']):
raise Exception("Recordings path does not exist: " + app.config['RECORDINGS_PATH'])
if not path.isdir(app.config['PATH_USER_PROFILE_IMAGE']):
raise Exception("User profile images path does not exist: " + app.config['PATH_USER_PROFILE_IMAGE'])
# app.json_encoder = MongoJsonEncoder
# setup database and session storage
# db settings come from flask.ini
# and same engine is used for storing sessions
mongo = MongoEngine()
mongo.init_app(app)
app.session_interface = MongoEngineSessionInterface(mongo)
# toolbar = DebugToolbarExtension(app)
return app, mongo
class CoreApp(Flask):
"""
CoreApp is a regular :class:`Flask` app with cors, flask-principal,
"restfulness" flavors
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Support objectid in url routing
self.url_map.converters['objectid'] = ObjectIdConverter
# Custom json encoder for objectid and pagination
# Mix between flask's root_path (module's path) and running dir path
self.root_path = abspath(dirname(__file__) + '/..')
# Overload default request to return 400 if no payload is provided
self.request_class = JsonRequest
self.json_encoder = dynamic_json_encoder_factory()
restful.representations.json.settings['cls'] = self.json_encoder
self.db = MongoEngine()
self.solr = Solr()
def bootstrap(self):
"""
Initialize modules needing configuration
:example:
>>> app = CoreApp("my-app")
>>> app.config['MY_CONF'] = 'DEFAULT_VALUE'
>>> app.bootstrap()
"""
# Principal and CORS support must be initialized at bootstrap time
# in order to have up-to-date config
self._principal = Principal(self, use_sessions=False)
self._cors = cors.CORS(self)
self.db.init_app(self)
self.solr.init_app(self)
def setUp(self):
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = 'testing'
app.config['TESTING'] = True
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(app)
Todo.drop_collection()
self.Todo = Todo
@app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return 'added'
@app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.app = app
self.db = db
def __init__(self, app):
app.mail = Mail(app)
db = MongoEngine()
#TODO: pull these files out
class Role(db.Document, RoleMixin):
name = db.StringField(required=True, unique=True, max_length=80)
description = db.StringField(max_length=255)
class User(db.Document, UserMixin):
email = db.StringField(unique=True, max_length=255)
password = db.StringField(required=True, max_length=120)
active = db.BooleanField(default=True)
confirmation_token = db.StringField(max_length=255)
confirmation_sent_at = db.DateTimeField()
confirmed_at = db.DateTimeField()
reset_password_token = db.StringField(max_length=255)
reset_password_sent_at = db.DateTimeField()
roles = db.ListField(db.ReferenceField(Role), default=[])
try:
db.init_app(app)
Security(app, MongoEngineUserDatastore(db))
#TODO: make a fabric task?
@app.before_first_request
def before_first_request():
User.drop_collection()
Role.drop_collection()
populate_data()
except:
print 'cannot connect to mongo'
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
celery = make_celery(app)
# DB
db = MongoEngine()
db.init_app(app)
db_wrapper = Database(db, cfg)
if __name__ == '__main__':
# TODO - not this
__builtin__.flock_app = app
# Logging
setup_logger(cfg["logging"]["file"], cfg["logging"]["level"])
# Init Rollbar
@app.before_first_request
def init_rollbar():
rollbar.init(
cfg["rollbar"]["token"],
from flask import Flask
from giga_web.ext.ses_mailer import SES_Mailer
from flask.ext.mongoengine import MongoEngine
from make_celery import make_celery
from settings import ProductionConfig, TestConfig
from celery.utils.log import get_task_logger
giga_web = Flask('giga_web')
giga_web.config.from_object(ProductionConfig)
celery_logger = get_task_logger('giga_web')
celery = make_celery(giga_web)
mailer = SES_Mailer(giga_web)
db = MongoEngine(giga_web)
db.init_app(giga_web)
#running celery requires this command:
#celery worker -A giga_web.celery --autoscale=4,2 -Q test_queue
import helpers
from giga_web import views, tasks, ext, models
from flask.ext import admin
from flask.ext.mongoengine import MongoEngine
from flask.ext.admin.form import rules
from flask.ext.admin.contrib.mongoengine import ModelView
# Create application
app = Flask(__name__)
# Create dummy secrey key so we can use sessions
app.config['SECRET_KEY'] = '123456790'
app.config['MONGODB_SETTINGS'] = {'DB': 'testing'}
# Create models
db = MongoEngine()
db.init_app(app)
# Define mongoengine documents
class User(db.Document):
name = db.StringField(max_length=40)
tags = db.ListField(db.ReferenceField('Tag'))
password = db.StringField(max_length=40)
def __unicode__(self):
return self.name
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
import default_settings
from app import app
from flask.ext.mongoengine import MongoEngine
def _flush_db():
from mongoengine.connection import _get_db
me = _get_db()
#Truncate/wipe the database
names = [name for name in me.collection_names() \
if 'system.' not in name]
[me.drop_collection(name) for name in names]
app.config.from_object('default_settings')
me = MongoEngine()
me.init_app(app)
_flush_db()
g = globals.load()
g['usr'] = {"OID": "50468de92558713d84b03fd7", "at": (-84.163063, 9.980516)}
g['me'] = app.me
g['logger'] = app.logger
debug = app.logger.debug
post = ctrs.post.Post(g).post
put = ctrs.put.Put(g).put
resp = post({'slug': 'lwe', 'lNam': 'Stooge', 'emails': [{'_types': ['Email'], 'prim': True, '_cls': 'Email', 'address': '*****@*****.**', 'typ': 'work', 'eId': 1}], 'fNam': 'Moe', '_cls': 'Prs'})
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = 'testing'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
# For Flask-WTF < 0.9
self.app.config['CSRF_ENABLED'] = False
# For Flask-WTF >= 0.9
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context('/'):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({'binary': '1'}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context('/'):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
meta = {'allow_inheritance': True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True)
interest = db.DecimalField(required=True)
# Create a text-based post
TextPostForm = model_form(TextPost)
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']}))
self.assertFalse(form.validate())
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.first().title, 'Using MongoEngine')
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags': ['flask', 'mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags-0': 'flask',
'tags-1': 'mongodb',
'tags-2': 'mongoengine',
'tags-3': 'flask-mongoengine',
}), instance=post)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(post.tags, ['flask', 'mongodb', 'mongoengine', 'flask-mongoengine'])
# Create a link post
LinkPostForm = model_form(LinkPost)
form = LinkPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'url': 'http://flask-mongoengine.org',
'interest': '0',
}))
form.validate()
self.assertTrue(form.validate())
def test_model_form_only(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=['tags'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
BlogPostForm = model_form(BlogPost, exclude=['posted'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=['german sheppard', 'wolfhound'])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(DogOwner, field_args={'dog': {'queryset': Dog.large_objects}})
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertEqual(False, form.dog.widget.multiple)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertEqual(True, form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertTrue(choices[0].checked)
self.assertTrue(choices[1].checked)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertEqual(True, form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_modelradiofield(self):
with self.app.test_request_context('/'):
db = self.db
choices = (('male', 'Male'), ('female', 'Female'), ('other', 'Other'))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={'answer': {'radio': True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, 'RadioField')
self.assertEqual(form.answer.choices, choices)
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={'password': {'password': True}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context('/'):
db = self.db
class Item (db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with='owner_id')
Item.drop_collection()
object_id = ObjectId()
Item(object_id, owner_item_id="1").save()
try:
Item(object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {'lst': {'label': 'Custom Label',
'field_args': {'widget': wtforms.widgets.HiddenInput(),
'label': "Hidden Input"}}}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string("{{ custom_form.lst.label }}", custom_form=custom_form)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string("{{ custom_form.lst }}", custom_form=custom_form)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def test_shared_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {'title': {'validators': [
wtforms.validators.Regexp('test')
]}}
TitleOnlyForm = model_form(BlogPost, field_args=shared_field_args,
exclude=['content'])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_embedded_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = 'testing'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
# For Flask-WTF < 0.9
self.app.config['CSRF_ENABLED'] = False
# For Flask-WTF >= 0.9
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context('/'):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({'binary': '1'}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context('/'):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
meta = {'allow_inheritance': True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
lead_paragraph = db.StringField(max_length=200)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True, max_length=200)
interest = db.DecimalField(required=True)
# Create a text-based post
TextPostForm = model_form(
TextPost,
field_args={'lead_paragraph': {'textarea': True}})
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']}))
self.assertFalse(form.validate())
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(form.title.type, 'StringField')
self.assertEqual(form.content.type, 'TextAreaField')
self.assertEqual(form.lead_paragraph.type, 'TextAreaField')
self.assertEquals(BlogPost.objects.first().title, 'Using MongoEngine')
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags': ['flask', 'mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags-0': 'flask',
'tags-1': 'mongodb',
'tags-2': 'mongoengine',
'tags-3': 'flask-mongoengine',
}), instance=post)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(post.tags, ['flask', 'mongodb', 'mongoengine', 'flask-mongoengine'])
# Create a link post
LinkPostForm = model_form(LinkPost)
form = LinkPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'url': 'http://flask-mongoengine.org',
'interest': '0',
}))
form.validate()
self.assertTrue(form.validate())
def test_model_form_only(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=['tags'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
BlogPostForm = model_form(BlogPost, exclude=['posted'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=['german sheppard', 'wolfhound'])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(DogOwner, field_args={'dog': {'queryset': Dog.large_objects}})
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate selecting one item
form = DogOwnerForm(MultiDict({
'dog': dog.id,
}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({
'dog': u'__None',
}), dog=dog)
self.assertEqual(form.dog.data, None)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertTrue(choices[0].checked)
self.assertTrue(choices[1].checked)
# Validate selecting two items
form = DogOwnerForm(MultiDict({
'dogs': [dog.id for dog in dogs],
}))
self.assertEqual(form.dogs.data, dogs)
# Validate selecting none actually empties the list
form = DogOwnerForm(MultiDict({
'dogs': [],
}), dogs=dogs)
self.assertEqual(form.dogs.data, None)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_modelradiofield(self):
with self.app.test_request_context('/'):
db = self.db
choices = (('male', 'Male'), ('female', 'Female'), ('other', 'Other'))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={'answer': {'radio': True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, 'RadioField')
self.assertEqual(form.answer.choices, choices)
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={'password': {'password': True}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context('/'):
db = self.db
class Item (db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with='owner_id')
Item.drop_collection()
object_id = ObjectId()
Item(object_id, owner_item_id="1").save()
try:
Item(object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {'lst': {'label': 'Custom Label',
'field_args': {'widget': wtforms.widgets.HiddenInput(),
'label': "Hidden Input"}}}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string("{{ custom_form.lst.label }}", custom_form=custom_form)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string("{{ custom_form.lst }}", custom_form=custom_form)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def test_shared_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {'title': {'validators': [
wtforms.validators.Regexp('test')
]}}
TitleOnlyForm = model_form(BlogPost, field_args=shared_field_args,
exclude=['content'])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_embedded_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
from models import *
import config
import requests
import sendgrid
db = MongoEngine()
sg = sendgrid.SendGridClient(config.sendgrid_user, config.sendgrid_pw)
serve = Flask(__name__)
#serve.config.from_pyfile('the-config.cfg')
serve.config['MONGODB_SETTINGS'] = {
'db': 'test',
'host': 'localhost',
'port': 27017
}
db.init_app(serve)
@serve.route("/")
def hello():
#convert hash to username
# username = getUsername(userHash)
# subprocess.call(['python server.py &'], shell=True)
# print os.popen("jobs -l").read()
stuff2 = os.popen("ps -fA | grep python").read().replace('\n','<br>')
stuff2 = stuff2 + str('<br><br><br>') + os.popen('ls').read()
return render_template('index.html', stuff=stuff2)
@serve.route("/auth/", methods=['POST'])
def auth():
if request.method == 'POST':
class PaginationTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(PaginationTestCase, self).setUp()
self.db_name = 'testing'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
self.app.config['CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_queryset_paginator(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
for i in range(42):
Post(title="post: %s" % i).save()
self.assertRaises(NotFound, Pagination, Post.objects, 0, 10)
self.assertRaises(NotFound, Pagination, Post.objects, 6, 10)
paginator = Pagination(Post.objects, 1, 10)
self._test_paginator(paginator)
def test_paginate_plain_list(self):
self.assertRaises(NotFound, Pagination, range(1, 42), 0, 10)
self.assertRaises(NotFound, Pagination, range(1, 42), 6, 10)
paginator = Pagination(range(1, 42), 1, 10)
self._test_paginator(paginator)
def test_list_field_pagination(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
comments = db.ListField(db.StringField())
comment_count = db.IntField()
comments = ["comment: %s" % i for i in range(42)]
post = Post(title="post has comments",
comments=comments,
comment_count=len(comments)).save()
# Check without providing a total
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10)
self._test_paginator(paginator)
# Check with providing a total (saves a query)
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10, post.comment_count)
self._test_paginator(paginator)
paginator = post.paginate_field('comments', 1, 10)
self._test_paginator(paginator)
def _test_paginator(self, paginator):
self.assertEqual(5, paginator.pages)
self.assertEqual([1, 2, 3, 4, 5], list(paginator.iter_pages()))
for i in [1, 2, 3, 4, 5]:
if i == 1:
self.assertRaises(NotFound, paginator.prev)
self.assertFalse(paginator.has_prev)
else:
self.assertTrue(paginator.has_prev)
if i == 5:
self.assertRaises(NotFound, paginator.next)
self.assertFalse(paginator.has_next)
else:
self.assertTrue(paginator.has_next)
self.assertEqual(i, paginator.page)
self.assertEqual(i - 1, paginator.prev_num)
self.assertEqual(i + 1, paginator.next_num)
# Paginate to the next page
if i < 5:
paginator = paginator.next()
# -*- coding: utf-8 -*-
import os
from flask import Flask
from flask.ext.mongoengine import MongoEngine
from celery import Celery
from twitter_watcher.views import register_blueprints
api = Flask(__name__)
api.config.from_object('twitter_watcher.config.Config')
db = MongoEngine()
db.init_app(api)
register_blueprints(api)
app_celery = Celery()
app_celery.conf.update(BROKER_URL=api.config['BROKER_URL'])
class WTFormsAppTestCase(unittest.TestCase):
def setUp(self):
self.db_name = 'testing'
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = self.db_name
app.config['TESTING'] = True
app.config['CSRF_ENABLED'] = False
self.app = app
self.db = MongoEngine()
self.db.init_app(app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField(max_length=50))
class TextPost(BlogPost):
email = db.EmailField(required=False)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True)
# Create a text-based post
TextPostForm = model_form(TextPost)
form = TextPostForm(**{
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']})
self.assertFalse(form.validate())
form = TextPostForm(**{
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']})
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.first().title, 'Using MongoEngine')
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in = ['german sheppard', 'wolfhound'])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(DogOwner, field_args={'dog': {'queryset' : Dog.large_objects} })
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual( big_dogs, [d[1] for d in form.dog.iter_choices()] )
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertEqual(False, form.dog.widget.multiple)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertEqual(True, form.dogs.widget.multiple)
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args = { 'password': {'password' : True} })
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = "testing"
self.app.config["MONGODB_DB"] = self.db_name
self.app.config["TESTING"] = True
# For Flask-WTF < 0.9
self.app.config["CSRF_ENABLED"] = False
# For Flask-WTF >= 0.9
self.app.config["WTF_CSRF_ENABLED"] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context("/"):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({"binary": "1"}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context("/"):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context("/"):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context("/"):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
meta = {"allow_inheritance": True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True)
# Create a text-based post
TextPostForm = model_form(TextPost)
form = TextPostForm(**{"title": "Using MongoEngine", "tags": ["mongodb", "mongoengine"]})
self.assertFalse(form.validate())
form = TextPostForm(
**{"title": "Using MongoEngine", "content": "See the tutorial", "tags": ["mongodb", "mongoengine"]}
)
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.first().title, "Using MongoEngine")
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(
**{
"title": "Using Flask-MongoEngine",
"content": "See the tutorial",
"tags": ["flask", "mongodb", "mongoengine"],
}
)
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"content": "See the tutorial",
"tags-0": "flask",
"tags-1": "mongodb",
"tags-2": "mongoengine",
"tags-3": "flask-mongoengine",
}
),
instance=post,
)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(post.tags, ["flask", "mongodb", "mongoengine", "flask-mongoengine"])
def test_model_form_only(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=["tags"])
form = BlogPostForm()
self.assertTrue(hasattr(form, "tags"))
self.assertFalse(hasattr(form, "posted"))
BlogPostForm = model_form(BlogPost, exclude=["posted"])
form = BlogPostForm()
self.assertTrue(hasattr(form, "tags"))
self.assertFalse(hasattr(form, "posted"))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=["german sheppard", "wolfhound"])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(DogOwner, field_args={"dog": {"queryset": Dog.large_objects}})
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertEqual(False, form.dog.widget.multiple)
def test_modelselectfield_multiple(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertEqual(True, form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertTrue(choices[0].checked)
self.assertTrue(choices[1].checked)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertEqual(True, form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_passwordfield(self):
with self.app.test_request_context("/"):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={"password": {"password": True}})
form = UserForm(password="******")
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context("/"):
db = self.db
class Item(db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with="owner_id")
Item.drop_collection()
object_id = ObjectId()
Item(object_id, owner_item_id="1").save()
try:
Item(object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context("/"):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {
"lst": {
"label": "Custom Label",
"field_args": {"widget": wtforms.widgets.HiddenInput(), "label": "Hidden Input"},
}
}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string("{{ custom_form.lst.label }}", custom_form=custom_form)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string("{{ custom_form.lst }}", custom_form=custom_form)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def test_embedded_model_form(self):
with self.app.test_request_context("/"):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
class PaginationTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(PaginationTestCase, self).setUp()
self.db_name = 'testing'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
self.app.config['CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_queryset_paginator(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
for i in range(42):
Post(title="post: %s" % i).save()
self.assertRaises(NotFound, Pagination, Post.objects, 0, 10)
self.assertRaises(NotFound, Pagination, Post.objects, 6, 10)
paginator = Pagination(Post.objects, 1, 10)
self._test_paginator(paginator)
def test_paginate_plain_list(self):
self.assertRaises(NotFound, Pagination, range(1, 42), 0, 10)
self.assertRaises(NotFound, Pagination, range(1, 42), 6, 10)
paginator = Pagination(range(1, 42), 1, 10)
self._test_paginator(paginator)
def test_list_field_pagination(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
comments = db.ListField(db.StringField())
comment_count = db.IntField()
comments = ["comment: %s" % i for i in range(42)]
post = Post(title="post has comments", comments=comments,
comment_count=len(comments)).save()
# Check without providing a total
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10)
self._test_paginator(paginator)
# Check with providing a total (saves a query)
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10, post.comment_count)
self._test_paginator(paginator)
paginator = post.paginate_field('comments', 1, 10)
self._test_paginator(paginator)
def _test_paginator(self, paginator):
self.assertEqual(5, paginator.pages)
self.assertEqual([1, 2, 3, 4, 5], list(paginator.iter_pages()))
for i in [1, 2, 3, 4, 5]:
if i == 1:
self.assertRaises(NotFound, paginator.prev)
self.assertFalse(paginator.has_prev)
else:
self.assertTrue(paginator.has_prev)
if i == 5:
self.assertRaises(NotFound, paginator.next)
self.assertFalse(paginator.has_next)
else:
self.assertTrue(paginator.has_next)
self.assertEqual(i, paginator.page)
self.assertEqual(i-1, paginator.prev_num)
self.assertEqual(i+1, paginator.next_num)
# Paginate to the next page
if i < 5:
paginator = paginator.next()
#from flask_debugtoolbar import DebugToolbarExtension
import mongo
app = Flask(__name__)
app.config['DEBUG_TB_PANELS'] = (
'flask.ext.debugtoolbar.panels.versions.VersionDebugPanel',
'flask.ext.debugtoolbar.panels.timer.TimerDebugPanel',
'flask.ext.debugtoolbar.panels.headers.HeaderDebugPanel',
'flask.ext.debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
'flask.ext.debugtoolbar.panels.template.TemplateDebugPanel',
'flask.ext.debugtoolbar.panels.logger.LoggingPanel',
'flask.ext.mongoengine.panels.MongoDebugPanel'
)
app.debug = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
app.config['MONGODB_SETTINGS'] = mongo.get_mongo_params()
from flask.ext.mongoengine import MongoEngine
mongodb = MongoEngine()
mongodb.init_app(app)
#toolbar = DebugToolbarExtension(app)
class WTFormsAppTestCase(unittest.TestCase):
def setUp(self):
self.db_name = 'testing'
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = self.db_name
app.config['TESTING'] = True
app.config['CSRF_ENABLED'] = False
self.app = app
self.db = MongoEngine()
self.db.init_app(app)
def tearDown(self):
self.db.connection.drop_database(self.db_name)
def test_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField(max_length=50))
class TextPost(BlogPost):
email = db.EmailField(required=False)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True)
# Create a text-based post
TextPostForm = model_form(TextPost)
form = TextPostForm(**{
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']
})
self.assertFalse(form.validate())
form = TextPostForm(
**{
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']
})
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.first().title,
'Using MongoEngine')
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(
MultiDict({
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']
}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=['german sheppard', 'wolfhound'])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(
DogOwner, field_args={'dog': {
'queryset': Dog.large_objects
}})
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertEqual(False, form.dog.widget.multiple)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertEqual(True, form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertTrue(choices[0].checked)
self.assertTrue(choices[1].checked)
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User,
field_args={'password': {
'password': True
}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput,
type(form.password.widget))
