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))