flask_mongoengine.MongoEngine

Here are the examples of the python api flask_mongoengine.MongoEngine taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

16 Examples 7

Example 1

Project: flask-admin Source File: __init__.py
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

Example 2

Project: flask-mongoengine Source File: test_basic_app.py
    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)

Example 3

Project: flask-mongoengine Source File: test_connection.py
    def test_live_connection(self):
        db = MongoEngine()
        self.app.config['TEMP_DB'] = True
        self.app.config['MONGODB_SETTINGS'] = {
            'HOST': 'localhost',
            'PORT': 27017,
            'USERNAME': None,
            'PASSWORD': None,
            'DB': 'test'
        }

        self._do_persist(db)

Example 4

Project: flask-mongoengine Source File: test_connection.py
    def test_uri_connection_string(self):
        db = MongoEngine()
        self.app.config['TEMP_DB'] = True
        self.app.config['MONGO_URI'] = 'mongodb://localhost:27017/test_uri'

        self._do_persist(db)

Example 5

Project: flask-mongoengine Source File: test_connection.py
    def test_mongodb_temp_instance(self):
        # String value used instead of boolean
        self.app.config['TESTING'] = True
        self.app.config['TEMP_DB'] = 'True'
        self.assertRaises(InvalidSettingsError, MongoEngine, self.app)

        self.app.config['TEMP_DB'] = True
        db = MongoEngine(self.app)
        self.assertTrue(isinstance(db.connection, pymongo.MongoClient))

Example 6

Project: flask-mongoengine Source File: test_connection.py
Function: test_connection_kwargs
    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.client.codec_options.tz_aware)

Example 7

Project: flask-mongoengine Source File: test_forms.py
Function: set_up
    def setUp(self):
        super(WTFormsAppTestCase, self).setUp()
        self.db_name = 'test_db'
        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)

Example 8

Project: flask-mongoengine Source File: test_json.py
Function: set_up
    def setUp(self):
        super(JSONAppTestCase, self).setUp()
        self.app.config['MONGODB_DB'] = 'test_db'
        self.app.config['TESTING'] = True
        self.app.json_encoder = DummyEncoder
        db = MongoEngine()
        db.init_app(self.app)
        self.db = db

Example 9

Project: flask-mongoengine Source File: test_pagination.py
Function: set_up
    def setUp(self):
        super(PaginationTestCase, self).setUp()
        self.db_name = 'test_db'
        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)

Example 10

Project: Flask-AppBuilder Source File: test_mongoengine.py
    def setUp(self):
        from flask import Flask
        from flask_appbuilder import AppBuilder
        from flask_appbuilder.models.mongoengine.interface import MongoEngineInterface
        from flask_appbuilder import ModelView
        from flask_appbuilder.security.mongoengine.manager import SecurityManager

        self.app = Flask(__name__)
        self.basedir = os.path.abspath(os.path.dirname(__file__))
        self.app.config['MONGODB_SETTINGS'] = {'DB': 'test'}
        self.app.config['CSRF_ENABLED'] = False
        self.app.config['SECRET_KEY'] = 'thisismyscretkey'
        self.app.config['WTF_CSRF_ENABLED'] = False

        self.db = MongoEngine(self.app)
        self.appbuilder = AppBuilder(self.app, security_manager_class=SecurityManager)

        class Model2View(ModelView):
            datamodel = MongoEngineInterface(Model2)
            list_columns = ['field_integer', 'field_float', 'field_string', 'field_method', 'group.field_string']
            edit_form_query_rel_fields = {'group':[['field_string', FilterEqual, 'G2']]}
            add_form_query_rel_fields = {'group':[['field_string', FilterEqual, 'G1']]}
            add_exclude_columns = ['excluded_string']

        class Model22View(ModelView):
            datamodel = MongoEngineInterface(Model2)
            list_columns = ['field_integer', 'field_float', 'field_string', 'field_method', 'group.field_string']
            add_exclude_columns = ['excluded_string']
            edit_exclude_columns = ['excluded_string']
            show_exclude_columns = ['excluded_string']


        class Model1View(ModelView):
            datamodel = MongoEngineInterface(Model1)
            related_views = [Model2View]
            list_columns = ['field_string','field_file']

        class Model1CompactView(CompactCRUDMixin, ModelView):
            datamodel = MongoEngineInterface(Model1)

        class Model1Filtered1View(ModelView):
            datamodel = MongoEngineInterface(Model1)
            base_filters = [['field_string', FilterStartsWith, 'a']]

        class Model1MasterView(MasterDetailView):
            datamodel = MongoEngineInterface(Model1)
            related_views = [Model2View]

        class Model1Filtered2View(ModelView):
            datamodel = MongoEngineInterface(Model1)
            base_filters = [['field_integer', FilterEqual, 0]]

        class Model2GroupByChartView(GroupByChartView):
            datamodel = MongoEngineInterface(Model2)
            chart_title = 'Test Model1 Chart'

            definitions = [
                {
                    'group':'field_string',
                    'series':[(aggregate_sum,'field_integer',
                               aggregate_avg, 'field_integer',
                               aggregate_count,'field_integer')
                            ]
                }
            ]
            
        class Model2DirectByChartView(DirectByChartView):
            datamodel = MongoEngineInterface(Model2)
            chart_title = 'Test Model1 Chart'

            definitions = [
                {
                    'group':'field_string',
                    'series':['field_integer','field_float']
                }
            ]

        class Model2DirectChartView(DirectChartView):
            datamodel = MongoEngineInterface(Model2)
            chart_title = 'Test Model1 Chart'
            direct_columns = {'stat1': ('group', 'field_integer')}

        class Model1MasterView(MasterDetailView):
            datamodel = MongoEngineInterface(Model1)
            related_views = [Model2View]

        class Model1MasterChartView(MasterDetailView):
            datamodel = MongoEngineInterface(Model1)
            related_views = [Model2DirectByChartView]


        self.appbuilder.add_view(Model1View, "Model1", category='Model1')
        self.appbuilder.add_view(Model1CompactView, "Model1Compact", category='Model1')
        self.appbuilder.add_view(Model1MasterView, "Model1Master", category='Model1')
        self.appbuilder.add_view(Model1MasterChartView, "Model1MasterChart", category='Model1')
        self.appbuilder.add_view(Model1Filtered1View, "Model1Filtered1", category='Model1')
        self.appbuilder.add_view(Model1Filtered2View, "Model1Filtered2", category='Model1')

        self.appbuilder.add_view(Model2View, "Model2")
        self.appbuilder.add_view(Model22View, "Model22")
        self.appbuilder.add_view(Model2View, "Model2 Add", href='/model2view/add')
        self.appbuilder.add_view(Model2GroupByChartView, "Model2 Group By Chart")
        self.appbuilder.add_view(Model2DirectByChartView, "Model2 Direct By Chart")
        self.appbuilder.add_view(Model2DirectChartView, "Model2 Direct Chart")

        role_admin = self.appbuilder.sm.find_role('Admin')
        try:
            self.appbuilder.sm.add_user('admin', 'admin', 'user', '[email protected]', role_admin, 'general')
        except:
            pass

Example 11

Project: flask-security Source File: conftest.py
@pytest.fixture()
def mongoengine_datastore(request, app):
    from flask_mongoengine import MongoEngine

    db_name = 'flask_security_test_%s' % str(time.time()).replace('.', '_')
    app.config['MONGODB_SETTINGS'] = {
        'db': db_name,
        'host': 'localhost',
        'port': 27017,
        'alias': db_name
    }

    db = MongoEngine(app)

    class Role(db.Docuement, RoleMixin):
        name = db.StringField(required=True, unique=True, max_length=80)
        description = db.StringField(max_length=255)
        meta = {"db_alias": db_name}

    class User(db.Docuement, UserMixin):
        email = db.StringField(unique=True, max_length=255)
        username = db.StringField(max_length=255)
        password = db.StringField(required=False, max_length=255)
        last_login_at = db.DateTimeField()
        current_login_at = db.DateTimeField()
        last_login_ip = db.StringField(max_length=100)
        current_login_ip = db.StringField(max_length=100)
        login_count = db.IntField()
        active = db.BooleanField(default=True)
        confirmed_at = db.DateTimeField()
        roles = db.ListField(db.ReferenceField(Role), default=[])
        meta = {"db_alias": db_name}

    request.addfinalizer(lambda: db.connection.drop_database(db_name))

    return MongoEngineUserDatastore(db, User, Role)

Example 12

Project: flask-mongoengine Source File: test_basic_app.py
Function: set_up
    def setUp(self):
        super(BasicAppTestCase, self).setUp()
        db = MongoEngine()

        class Todo(db.Docuement):
            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

Example 13

Project: flask-mongoengine Source File: test_connection.py
    def ensure_mongomock_connection(self):
        db = MongoEngine(self.app)
        self.assertTrue(isinstance(db.connection.client, mongomock.MongoClient))

Example 14

Project: flask-mongoengine Source File: test_connection.py
Function: test_multiple_connections
    def test_multiple_connections(self):
        db = MongoEngine()
        self.app.config['TESTING'] = True
        self.app.config['TEMP_DB'] = True
        self.app.config['MONGODB_SETTINGS'] = [
            {
                'ALIAS': 'default',
                'DB': 'testing_db1',
                'HOST': 'localhost',
                'PORT': 27017
            },
            {
                "ALIAS": "testing_db2",
                "DB": 'testing_db2',
                "HOST": 'localhost',
                "PORT": 27017
            },
        ]

        class Todo(db.Docuement):
            title = db.StringField(max_length=60)
            text = db.StringField()
            done = db.BooleanField(default=False)
            meta = {"db_alias": "testing_db2"}

        db.init_app(self.app)
        Todo.drop_collection()

        # Switch DB
        from mongoengine.context_managers import switch_db
        with switch_db(Todo, 'default') as Todo:
            todo = Todo()
            todo.text = "Sample"
            todo.title = "Testing"
            todo.done = True
            s_todo = todo.save()

            f_to = Todo.objects().first()
            self.assertEqual(s_todo.title, f_to.title)

Example 15

Project: flask-mongoengine Source File: test_json_app.py
Function: set_up
    def setUp(self):
        super(JSONAppTestCase, self).setUp()
        self.app.config['MONGODB_DB'] = 'test_db'
        self.app.config['TESTING'] = True
        self.app.config['TEMP_DB'] = True
        db = MongoEngine()

        class Todo(db.Docuement):
            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

Example 16

Project: flask-mongoengine Source File: test_session.py
Function: set_up
    def setUp(self):
        super(SessionTestCase, self).setUp()
        self.db_name = 'test_db'
        self.app.config['MONGODB_DB'] = self.db_name
        self.app.config['TESTING'] = True
        db = MongoEngine(self.app)
        self.app.session_interface = MongoEngineSessionInterface(db)

        @self.app.route('/')
        def index():
            session["a"] = "hello session"
            return session["a"]

        @self.app.route('/check-session')
        def check_session():
            return "session: %s" % session["a"]

        @self.app.route('/check-session-database')
        def check_session_database():
            sessions = self.app.session_interface.cls.objects.count()
            return "sessions: %s" % sessions

        self.db = db