Merge remote-tracking branch 'upstream/master'

Conflicts:
	flask_mongoengine/__init__.py

Author: Len Buckens

README

@@ -17,3 +17,6 @@ You can find the documentation at http://readthedocs.org/docs/flask-mongoengine/
 
 You can install this package using pypi, $ pip install flask-mongoengine
 
+~ What about the license?
+
+Flask-MongoEngine is distributed under MIT license, see LICENSE for more details 

docs/index.rst

@@ -35,12 +35,45 @@ Or, if you are setting up your database before your app is initialized, as is th
     app = Flask(__name__)
     app.config.from_pyfile('the-config.cfg')
     db.init_app(app)
-    
-To configure the MongoDB connection settings set a key (DB, USERNAME, PASSWORD, HOST, PORT) in the
-`'MONGODB_SETTINGS'` dictionary wih `app.config`. For example :
 
-    app.config["MONGODB_SETTINGS"] = {"DB": "my_tumble_log", "USERNAME" : "my_user_name", "PASSWORD" : "my_secret_password", "HOST" : "127.0.0.1", "PORT": 27017 }
 
+By default, Flask-MongoEngine assumes that the :program:`mongod` instance is running
+on **localhost** on port **27017**, and you wish to connect to the database named **test**.
+
+If MongoDB is running elsewhere, you should provide the :attr:`host` and :attr:`port` settings
+in  the `'MONGODB_SETTINGS'` dictionary wih `app.config`.::
+
+    app.config['MONGODB_SETTINGS'] = {
+        'db': 'project1',
+        'host': '192.168.1.35',
+        'port': 12345
+    }
+
+If the database requires authentication, the :attr:`username` and :attr:`password`
+arguments should be provided `'MONGODB_SETTINGS'` dictionary wih `app.config`.::
+
+    app.config['MONGODB_SETTINGS'] = {
+        'db': 'project1',
+        'username':'webapp',
+        'password':'pwd123'
+    }
+
+Uri style connections are also supported, just supply the uri as the :attr:`host`
+in the `'MONGODB_SETTINGS'` dictionary with `app.config`. **Note that database name from uri has priority over name.** ::
+
+    app.config['MONGODB_SETTINGS'] = {
+        'db': 'project1',
+        'host': 'mongodb://localhost/database_name'
+    }
+
+
+Connection settings may also be provided individually by prefixing the setting with `'MONGODB_'` in the `app.config`.::
+
+    app.config['MONGODB_DB'] = 'project1'
+    app.config['MONGODB_HOST'] = '192.168.1.35'
+    app.config['MONGODB_PORT'] = 12345
+    app.config['MONGODB_USERNAME'] = 'webapp'
+    app.config['MONGODB_PASSWORD'] = 'pwd123'
 
 
 Custom Queryset
@@ -121,7 +154,7 @@ You can use MongoEngine and WTForms like so::
         if request.method == 'POST' and form.validate():
             # do something
             redirect('done')
-        return render_response('add_post.html', form=form)
+        return render_template('add_post.html', form=form)
 
 
 Supported fields

examples/simpleapp/app.py

@@ -48,7 +48,6 @@ def index():
     Todo(title="Simple todo A ПЫЩЬ!", text="12345678910").save()  # Insert
     Todo(title="Simple todo B", text="12345678910").save()  # Insert
     Todo.objects(title__contains="B").update(set__text="Hello world")  # Update
-    todos = list(Todo.objects[:10])
     todos = Todo.objects.all()
     return flask.render_template('index.html', todos=todos)
 

flask_mongoengine/__init__.py

@@ -1,13 +1,15 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import
 
-from flask import abort
+from flask import abort, current_app
 
 import mongoengine
 
 from mongoengine.queryset import MultipleObjectsReturned, DoesNotExist, QuerySet
 from mongoengine.base import ValidationError
 
+from pymongo import uri_parser
+
 from .sessions import *
 from .pagination import *
 from .json import overide_json_encoder
@@ -20,55 +22,81 @@ def _include_mongoengine(obj):
                 setattr(obj, key, getattr(module, key))
 
 
+def _create_connection(conn_settings):
+
+    # Handle multiple connections recursively
+    if isinstance(conn_settings, list):
+        connections = {}
+        for conn in conn_settings:
+            connections[conn.get('alias')] = _create_connection(conn)
+        return connections
+
+    conn = dict([(k.lower(), v) for k, v in conn_settings.items() if v])
+
+    if 'replicaset' in conn:
+        conn['replicaSet'] = conn.pop('replicaset')
+
+    # Handle uri style connections
+    if "://" in conn.get('host', ''):
+        uri_dict = uri_parser.parse_uri(conn_settings['host'])
+        conn['db'] = uri_dict['database']
+
+    return mongoengine.connect(conn.pop('db', 'test'), **conn)
+
+
 class MongoEngine(object):
 
-    def __init__(self, app=None):
+    def __init__(self, app=None, config=None):
 
         _include_mongoengine(self)
 
         self.Document = Document
         self.DynamicDocument = DynamicDocument
 
         if app is not None:
-            self.init_app(app)
+            self.init_app(app, config)
 
-    def init_app(self, app):
+    def init_app(self, app, config=None):
 
-        conn_settings = app.config.get('MONGODB_SETTINGS', None)
+        app.extensions = getattr(app, 'extensions', {})
 
-        if not conn_settings:
-            conn_settings = {
-                'db': app.config.get('MONGODB_DB', None),
-                'username': app.config.get('MONGODB_USERNAME', None),
-                'password': app.config.get('MONGODB_PASSWORD', None),
-                'host': app.config.get('MONGODB_HOST', None),
-                'port': int(app.config.get('MONGODB_PORT', 0)) or None
-            }
+        # Make documents JSON serializable
+        overide_json_encoder(app)
 
-        if isinstance(conn_settings, list):
-            self.connection = {}
-            for conn in conn_settings:
-                conn = dict((k.lower(), v) for k, v in conn.items() if v is not None)
+        if not 'mongoengine' in app.extensions:
+            app.extensions['mongoengine'] = {}
 
-                if 'replicaset' in conn:
-                    conn['replicaSet'] = conn['replicaset']
-                    del conn['replicaset']
+        if self in app.extensions['mongoengine']:
+            # Raise an exception if extension already initialized as
+            # potentially new configuration would not be loaded.
+            raise Exception('Extension already initialized')
 
-                self.connection[conn.get('alias')] = mongoengine.connect(**conn)
+        if not config:
+            # If not passed a config then we read the connection settings
+            # from the app config.
+            config = app.config
 
+        if 'MONGODB_SETTINGS' in config:
+            # Connection settings provided as a dictionary.
+            connection = _create_connection(config['MONGODB_SETTINGS'])
         else:
-            conn_settings = dict([(k.lower(), v) for k, v in conn_settings.items() if v])
-
-            if 'replicaset' in conn_settings:
-                conn_settings['replicaSet'] = conn_settings['replicaset']
-                del conn_settings['replicaset']
-
-            self.connection = mongoengine.connect(**conn_settings)
-
-        app.extensions = getattr(app, 'extensions', {})
-        app.extensions['mongoengine'] = self
-        self.app = app
-        overide_json_encoder(app)
+            # Connection settings provided in standard format.
+            settings = {'alias': config.get('MONGODB_ALIAS', None),
+                        'db': config.get('MONGODB_DB', None),
+                        'host': config.get('MONGODB_HOST', None),
+                        'password': config.get('MONGODB_PASSWORD', None),
+                        'port': config.get('MONGODB_PORT', None),
+                        'username': config.get('MONGODB_USERNAME', None)}
+            connection = _create_connection(settings)
+
+        # Store objects in application instance so that multiple apps do
+        # not end up accessing the same objects.
+        app.extensions['mongoengine'][self] = {'app': app,
+                                               'conn': connection}
+
+    @property
+    def connection(self):
+        return current_app.extensions['mongoengine'][self]['conn']
 
 
 class BaseQuerySet(QuerySet):

flask_mongoengine/sessions.py

@@ -4,6 +4,7 @@
 
 from flask.sessions import SessionInterface, SessionMixin
 from werkzeug.datastructures import CallbackDict
+from bson.tz_util import utc
 
 __all__ = ("MongoEngineSession", "MongoEngineSessionInterface")
 
@@ -57,21 +58,31 @@ def open_session(self, app, request):
         sid = request.cookies.get(app.session_cookie_name)
         if sid:
             stored_session = self.cls.objects(sid=sid).first()
-            if stored_session and stored_session.expiration > datetime.datetime.utcnow():
-                return MongoEngineSession(initial=stored_session.data, sid=stored_session.sid)
+
+            if stored_session:
+                expiration = stored_session.expiration
+
+                if not expiration.tzinfo:
+                    expiration = expiration.replace(tzinfo=utc)
+
+                if expiration > datetime.datetime.utcnow().replace(tzinfo=utc):
+                    return MongoEngineSession(initial=stored_session.data, sid=stored_session.sid)
+
         return MongoEngineSession(sid=str(uuid.uuid4()))
 
     def save_session(self, app, session, response):
         domain = self.get_cookie_domain(app)
+        httponly = self.get_cookie_httponly(app)
+
         if not session:
             if session.modified:
                 response.delete_cookie(app.session_cookie_name, domain=domain)
             return
 
-        expiration = datetime.datetime.now() + self.get_expiration_time(app, session)
+        expiration = datetime.datetime.utcnow().replace(tzinfo=utc) + self.get_expiration_time(app, session)
 
         if session.modified:
             self.cls(sid=session.sid, data=session, expiration=expiration).save()
 
         response.set_cookie(app.session_cookie_name, session.sid,
-                            expires=expiration, httponly=True, domain=domain)
+                            expires=expiration, httponly=httponly, domain=domain)

flask_mongoengine/wtf/fields.py

@@ -70,7 +70,7 @@ def process_formdata(self, valuelist):
 
                 try:
                     # clone() because of https://github.com/MongoEngine/mongoengine/issues/56
-                    obj = self.queryset.clone().get(id=valuelist[0])
+                    obj = self.queryset.clone().get(pk=valuelist[0])
                     self.data = obj
                 except DoesNotExist:
                     self.data = None

tests/__init__.py

@@ -0,0 +1,15 @@
+import flask
+import unittest
+
+class FlaskMongoEngineTestCase(unittest.TestCase):
+    """Parent class of all test cases"""
+
+    def setUp(self):
+        self.app = flask.Flask(__name__)
+        self.app.config['MONGODB_DB'] = 'testing'
+        self.app.config['TESTING'] = True
+        self.ctx = self.app.app_context()
+        self.ctx.push()
+
+    def tearDown(self):
+        self.ctx.pop()

tests/test_basic_app.py

@@ -1,19 +1,17 @@
 import sys
-sys.path[0:0] = [""]
 
 import unittest
 import datetime
 import flask
 
 from flask.ext.mongoengine import MongoEngine
+from . import FlaskMongoEngineTestCase
 
 
-class BasicAppTestCase(unittest.TestCase):
+class BasicAppTestCase(FlaskMongoEngineTestCase):
 
     def setUp(self):
-        app = flask.Flask(__name__)
-        app.config['MONGODB_DB'] = 'testing'
-        app.config['TESTING'] = True
+        super(BasicAppTestCase, self).setUp()
         db = MongoEngine()
 
         class Todo(db.Document):
@@ -22,67 +20,79 @@ class Todo(db.Document):
             done = db.BooleanField(default=False)
             pub_date = db.DateTimeField(default=datetime.datetime.now)
 
-        db.init_app(app)
+        db.init_app(self.app)
 
         Todo.drop_collection()
         self.Todo = Todo
 
-        @app.route('/')
+        @self.app.route('/')
         def index():
             return '\n'.join(x.title for x in self.Todo.objects)
 
-        @app.route('/add', methods=['POST'])
+        @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'
 
-        @app.route('/show/<id>/')
+        @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.app = app
         self.db = db
 
     def test_connection_kwargs(self):
-        app = flask.Flask(__name__)
-        app.config['MONGODB_SETTINGS'] = {
+        self.app.config['MONGODB_SETTINGS'] = {
             'DB': 'testing_tz_aware',
-            'alias': 'tz_aware_true',
+            'ALIAS': 'tz_aware_true',
             'TZ_AWARE': True
         }
-        app.config['TESTING'] = True
+        self.app.config['TESTING'] = True
         db = MongoEngine()
-        db.init_app(app)
+        db.init_app(self.app)
         self.assertTrue(db.connection.tz_aware)
 
-        app.config['MONGODB_SETTINGS'] = {
+        # 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',
+            'ALIAS': 'tz_aware_false',
+            'TZ_AWARE': False
         }
-        db.init_app(app)
+        db = MongoEngine()
+        db.init_app(self.app)
         self.assertFalse(db.connection.tz_aware)
 
     def test_connection_kwargs_as_list(self):
-        app = flask.Flask(__name__)
-        app.config['MONGODB_SETTINGS'] = [{
+        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
+            'alias': 'tz_aware_false',
+            'TZ_AWARE': False
         }]
-        app.config['TESTING'] = True
+        self.app.config['TESTING'] = True
         db = MongoEngine()
-        db.init_app(app)
+        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_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_with_id(self):
         c = self.app.test_client()
         resp = c.get('/show/38783728378090/')