/", view_func=dict_demo_view, methods=["GET", "POST"])
58 |
59 | if __name__ == "__main__":
60 | app.run(host="0.0.0.0", port=8000)
61 |
--------------------------------------------------------------------------------
/example_app/boolean_demo.py:
--------------------------------------------------------------------------------
1 | """Booleans fields demo model."""
2 |
3 | from example_app.models import db
4 |
5 |
6 | class BooleanDemoModel(db.Document):
7 | """Documentation example model."""
8 |
9 | simple_sting_name = db.StringField()
10 | boolean_field = db.BooleanField()
11 | boolean_field_with_null = db.BooleanField(null=True)
12 | true_boolean_field_with_allowed_null = db.BooleanField(null=True, default=True)
13 | boolean_field_with_as_choices_replace = db.BooleanField(
14 | wtf_options={
15 | "choices": [("", "Not selected"), ("yes", "Positive"), ("no", "Negative")]
16 | }
17 | )
18 |
19 |
20 | BooleanDemoForm = BooleanDemoModel.to_wtf_form()
21 |
22 |
23 | def boolean_demo_view(pk=None):
24 | """Return all fields demonstration."""
25 | from example_app.views import demo_view
26 |
27 | return demo_view(
28 | model=BooleanDemoModel, view_name=boolean_demo_view.__name__, pk=pk
29 | )
30 |
--------------------------------------------------------------------------------
/example_app/compose/flask/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM python:3.7-slim as dev
2 |
3 | ENV PYTHONUNBUFFERED 1
4 | RUN apt-get update && \
5 | apt-get install git -y --no-install-recommends && \
6 | rm -rf /var/lib/apt/lists/*
7 | RUN groupadd -r flask && useradd -r -g flask flask
8 | COPY --chown=flask . /flask_mongoengine
9 | RUN pip install --upgrade pip \
10 | && pip install -e /flask_mongoengine[toolbar,wtf] \
11 | && pip install Faker Pillow
12 | WORKDIR /flask_mongoengine
13 |
--------------------------------------------------------------------------------
/example_app/dates_demo.py:
--------------------------------------------------------------------------------
1 | """Date and DateTime fields demo model."""
2 |
3 | from wtforms.fields import DateTimeField
4 |
5 | from example_app.models import db
6 |
7 |
8 | class DateTimeModel(db.Document):
9 | """Documentation example model."""
10 |
11 | any_string = db.StringField()
12 | date = db.DateField()
13 | datetime = db.DateTimeField()
14 | datetime_no_sec = db.DateTimeField(wtf_options={"render_kw": {"step": "60"}})
15 | datetime_ms = db.DateTimeField(wtf_options={"render_kw": {"step": "0.001"}})
16 | complex_datetime = db.ComplexDateTimeField()
17 | complex_datetime_sec = db.ComplexDateTimeField(
18 | wtf_options={"render_kw": {"step": "1"}}
19 | )
20 | complex_datetime_microseconds = db.ComplexDateTimeField(
21 | wtf_field_class=DateTimeField, wtf_options={"format": "%Y-%m-%d %H:%M:%S.%f"}
22 | )
23 |
24 |
25 | DateTimeDemoForm = DateTimeModel.to_wtf_form()
26 |
27 |
28 | def dates_demo_view(pk=None):
29 | """Return all fields demonstration."""
30 | from example_app.views import demo_view
31 |
32 | return demo_view(model=DateTimeModel, view_name=dates_demo_view.__name__, pk=pk)
33 |
--------------------------------------------------------------------------------
/example_app/dict_demo.py:
--------------------------------------------------------------------------------
1 | """Dict fields demo model."""
2 |
3 | from example_app.models import db
4 |
5 |
6 | def get_default_dict():
7 | """Example of default dict specification."""
8 | return {"alpha": 1, "text": "text", "float": 1.2}
9 |
10 |
11 | class DictDemoModel(db.Document):
12 | """Documentation example model."""
13 |
14 | string = db.StringField(verbose_name="str")
15 | dict_field = db.DictField()
16 | no_dict_field = db.DictField(default=None)
17 | null_dict_field = db.DictField(default=None, null=True)
18 | dict_default = db.DictField(default=get_default_dict)
19 | null_dict_default = db.DictField(default=get_default_dict, null=True)
20 | no_dict_prefilled = db.DictField(
21 | default=None,
22 | null=False,
23 | wtf_options={"default": get_default_dict, "null": True},
24 | )
25 |
26 |
27 | DictDemoForm = DictDemoModel.to_wtf_form()
28 |
29 |
30 | def dict_demo_view(pk=None):
31 | """Return all fields demonstration."""
32 | from example_app.views import demo_view
33 |
34 | return demo_view(model=DictDemoModel, view_name=dict_demo_view.__name__, pk=pk)
35 |
--------------------------------------------------------------------------------
/example_app/models.py:
--------------------------------------------------------------------------------
1 | import datetime
2 |
3 | from flask_mongoengine import MongoEngine
4 |
5 | db = MongoEngine()
6 |
7 |
8 | class Todo(db.Document):
9 | """Test model for AllFieldsModel and pagination."""
10 |
11 | title = db.StringField(max_length=60)
12 | text = db.StringField()
13 | done = db.BooleanField(default=False)
14 | pub_date = db.DateTimeField(default=datetime.datetime.now)
15 |
16 |
17 | class Embedded(db.EmbeddedDocument):
18 | """Test embedded for AllFieldsModel."""
19 |
20 | string = db.StringField()
21 |
22 |
23 | class AllFieldsModel(db.Document):
24 | """Meaningless Document with all field types."""
25 |
26 | binary_field = db.BinaryField()
27 | boolean_field = db.BooleanField()
28 | date_field = db.DateField()
29 | date_time_field = db.DateTimeField()
30 | decimal_field = db.DecimalField()
31 | dict_field = db.DictField()
32 | email_field = db.EmailField()
33 | embedded_document_field = db.EmbeddedDocumentField(document_type=Embedded)
34 | file_field = db.FileField()
35 | float_field = db.FloatField()
36 | int_field = db.IntField()
37 | list_field = db.ListField(field=db.StringField)
38 | reference_field = db.ReferenceField(document_type=Todo)
39 | sorted_list_field = db.SortedListField(field=db.StringField)
40 | string_field = db.StringField()
41 | url_field = db.URLField()
42 | cached_reference_field = db.CachedReferenceField(document_type=Todo)
43 | complex_date_time_field = db.ComplexDateTimeField()
44 | dynamic_field = db.DynamicField()
45 | embedded_document_list_field = db.EmbeddedDocumentListField(document_type=Embedded)
46 | enum_field = db.EnumField(enum=[1, 2])
47 | generic_embedded_document_field = db.GenericEmbeddedDocumentField()
48 | generic_lazy_reference_field = db.GenericLazyReferenceField()
49 | geo_json_base_field = db.GeoJsonBaseField()
50 | geo_point_field = db.GeoPointField()
51 | image_field = db.ImageField()
52 | lazy_reference_field = db.LazyReferenceField(document_type=Todo)
53 | line_string_field = db.LineStringField()
54 | long_field = db.LongField()
55 | map_field = db.MapField(field=db.StringField())
56 | multi_line_string_field = db.MultiLineStringField()
57 | multi_point_field = db.MultiPointField()
58 | multi_polygon_field = db.MultiPolygonField()
59 | point_field = db.PointField()
60 | polygon_field = db.PolygonField()
61 | sequence_field = db.SequenceField()
62 | uuid_field = db.UUIDField()
63 | generic_reference_field = db.GenericReferenceField(document_type=Todo)
64 | object_id_field = db.ObjectIdField()
65 |
66 |
67 | TodoForm = Todo.to_wtf_form()
68 | AllFieldsForm = AllFieldsModel.to_wtf_form()
69 |
--------------------------------------------------------------------------------
/example_app/numbers_demo.py:
--------------------------------------------------------------------------------
1 | """Numbers and related fields demo model."""
2 |
3 | from decimal import Decimal
4 |
5 | from example_app.models import db
6 |
7 |
8 | class NumbersDemoModel(db.Document):
9 | """Documentation example model."""
10 |
11 | simple_sting_name = db.StringField()
12 | float_field_unlimited = db.FloatField()
13 | decimal_field_unlimited = db.DecimalField()
14 | integer_field_unlimited = db.IntField()
15 | float_field_limited = db.FloatField(min_value=float(1), max_value=200.455)
16 | decimal_field_limited = db.DecimalField(
17 | min_value=Decimal("1"), max_value=Decimal("200.455")
18 | )
19 | integer_field_limited = db.IntField(min_value=1, max_value=200)
20 |
21 |
22 | NumbersDemoForm = NumbersDemoModel.to_wtf_form()
23 |
24 |
25 | def numbers_demo_view(pk=None):
26 | """Return all fields demonstration."""
27 | from example_app.views import demo_view
28 |
29 | return demo_view(
30 | model=NumbersDemoModel, view_name=numbers_demo_view.__name__, pk=pk
31 | )
32 |
--------------------------------------------------------------------------------
/example_app/strings_demo.py:
--------------------------------------------------------------------------------
1 | """Strings and strings related fields demo model."""
2 | import re
3 |
4 | from example_app.models import db
5 | from flask_mongoengine.wtf import fields as mongo_fields
6 |
7 |
8 | class StringsDemoModel(db.Document):
9 | """Documentation example model."""
10 |
11 | string_field = db.StringField()
12 | regexp_string_field = db.StringField(
13 | regex=re.compile(
14 | r"^(https:\/\/)[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=]+$"
15 | )
16 | )
17 | sized_string_field = db.StringField(min_length=5)
18 | tel_field = db.StringField(wtf_field_class=mongo_fields.MongoTelField)
19 | password_field = db.StringField(
20 | wtf_field_class=mongo_fields.MongoPasswordField,
21 | required=True,
22 | min_length=5,
23 | )
24 | email_field = db.EmailField()
25 | url_field = db.URLField()
26 |
27 |
28 | StringsDemoForm = StringsDemoModel.to_wtf_form()
29 |
30 |
31 | def strings_demo_view(pk=None):
32 | """Return all fields demonstration."""
33 | from example_app.views import demo_view
34 |
35 | return demo_view(
36 | model=StringsDemoModel, view_name=strings_demo_view.__name__, pk=pk
37 | )
38 |
--------------------------------------------------------------------------------
/example_app/templates/_formhelpers.html:
--------------------------------------------------------------------------------
1 | {# Macro for creating navigation links #}
2 | {% macro render_navigation(pagination, endpoint) %}
3 |
4 | {% for page in pagination.iter_pages() %}
5 | {% if page %}
6 | {% if page != pagination.page %}
7 |
{{ page }}
8 | {% else %}
9 |
{{ page }}
10 | {% endif %}
11 | {% else %}
12 |
nothing to show
13 | {% endif %}
14 | {% endfor %}
15 |
8 |
9 |
10 |
11 | {% for field in model._fields_ordered %}
12 | | {{ model[field].verbose_name or model[field].name}} |
13 | {% endfor %}
14 | Edit |
15 |
16 |
17 |
18 | {% for page_object in page.items %}
19 |
20 | {% for field in page_object._fields_ordered %}
21 | | {{ page_object[field] }} |
22 | {% endfor %}
23 | edit |
24 |
25 | {% endfor %}
26 |
27 |
28 |
30 | {{ render_navigation(page, view) }}
31 |
32 |
33 |
39 |
40 |
41 | {% endblock %}
42 |
--------------------------------------------------------------------------------
/example_app/templates/index.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% block body %}
3 | This is demo application that shows Flask-Mongoengine features and integrations.
4 | Feel free to open Flask debug toolbar after any action to check executed database requests.
5 | If you use this application for first time, it is good idea to generate some fake data.
6 |
7 | Data will be generated inside docker container database.
8 | Two databases will be used to show Flask Debug Panel integration capabilities.
9 |
10 | You can also delete all data, to test forms only.
11 | {% if message %}
12 | {{ message }}
13 | {% endif %}
14 |
18 | {% endblock %}
19 |
--------------------------------------------------------------------------------
/example_app/templates/layout.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Flask MongoEngine
5 |
6 |
7 |
16 |
17 |
28 |
29 |
30 | {% block body %}{% endblock %}
31 |
32 |
8 |
9 |
10 |
11 | | Title |
12 | Text |
13 | Done |
14 | Publication date |
15 |
16 |
17 |
18 | {% for todo in todos_page.items %}
19 |
20 | | {{ todo.title }} |
21 | {{ todo.text }} |
22 | {{ todo.done }} |
23 | {{ todo.pub_date }} |
24 |
25 | {% endfor %}
26 |
27 |
28 |
30 | {{ render_navigation(todos_page, "pagination") }}
31 |
32 |
33 |
39 |
40 |
41 | {% endblock %}
42 |
--------------------------------------------------------------------------------
/example_app/views.py:
--------------------------------------------------------------------------------
1 | """Demo views for example application."""
2 | from faker import Faker
3 | from flask import render_template, request
4 | from mongoengine.context_managers import switch_db
5 |
6 | from example_app import models
7 | from example_app.boolean_demo import BooleanDemoModel
8 | from example_app.dates_demo import DateTimeModel
9 | from example_app.dict_demo import DictDemoModel
10 | from example_app.numbers_demo import NumbersDemoModel
11 | from example_app.strings_demo import StringsDemoModel
12 |
13 |
14 | def generate_data():
15 | """Generates fake data for all supported models and views."""
16 | fake = Faker(locale=["en_US"])
17 |
18 | with switch_db(models.Todo, "default"):
19 | models.Todo.objects().delete() # Removes
20 | models.Todo(
21 | title="Simple todo A", text=fake.sentence(), done=False
22 | ).save() # Insert
23 | models.Todo(
24 | title="Simple todo B", text=fake.sentence(), done=True
25 | ).save() # Insert
26 | models.Todo(
27 | title="Simple todo C", text=fake.sentence(), done=True
28 | ).save() # Insert
29 | # Bulk insert
30 | bulk = (
31 | models.Todo(title="Bulk 1", text=fake.sentence(), done=False),
32 | models.Todo(title="Bulk 2", text=fake.sentence(), done=True),
33 | )
34 | models.Todo.objects().insert(bulk)
35 | models.Todo.objects(title__contains="B").order_by("-title").update(
36 | set__text="Hello world"
37 | ) # Update
38 | models.Todo.objects(title__contains="C").order_by("-title").delete() # Removes
39 |
40 | with switch_db(models.Todo, "secondary"):
41 | models.Todo.objects().delete()
42 | for _ in range(10):
43 | models.Todo(
44 | title=fake.text(max_nb_chars=59),
45 | text=fake.sentence(),
46 | done=fake.pybool(),
47 | pub_date=fake.date(),
48 | ).save()
49 |
50 |
51 | def delete_data():
52 | """Clear database."""
53 | with switch_db(models.Todo, "default"):
54 | models.Todo.objects().delete()
55 | BooleanDemoModel.objects().delete()
56 | DateTimeModel.objects().delete()
57 | DictDemoModel.objects().delete()
58 | StringsDemoModel.objects().delete()
59 | NumbersDemoModel.objects().delete()
60 | with switch_db(models.Todo, "secondary"):
61 | models.Todo.objects().delete()
62 |
63 |
64 | def index():
65 | """Return page with welcome words and instructions."""
66 | message = None
67 | if request.method == "POST":
68 | if request.form["button"] == "Generate data":
69 | generate_data()
70 | message = "Fake data generated"
71 | if request.form["button"] == "Delete data":
72 | delete_data()
73 | message = "All data deleted"
74 | return render_template("index.html", message=message)
75 |
76 |
77 | def pagination():
78 | """Return pagination and easy form demonstration."""
79 | form = models.TodoForm()
80 |
81 | with switch_db(models.Todo, "secondary"):
82 | if request.method == "POST":
83 | form.validate_on_submit()
84 | form.save()
85 | page_num = int(request.args.get("page") or 1)
86 | todos_page = models.Todo.objects.paginate(page=page_num, per_page=3)
87 |
88 | return render_template("pagination.html", todos_page=todos_page, form=form)
89 |
90 |
91 | def demo_view(model, view_name, pk=None):
92 | """Return all fields demonstration."""
93 | FormClass = model.to_wtf_form()
94 | form = FormClass()
95 | if pk:
96 | obj = model.objects.get(pk=pk)
97 | form = FormClass(obj=obj)
98 |
99 | if request.method == "POST" and form.validate_on_submit():
100 | form.save()
101 | # form = FormClass(obj=form.instance)
102 | page_num = int(request.args.get("page") or 1)
103 | page = model.objects.paginate(page=page_num, per_page=100)
104 |
105 | return render_template(
106 | "form_demo.html", view=view_name, page=page, form=form, model=model
107 | )
108 |
--------------------------------------------------------------------------------
/flask_mongoengine/__init__.py:
--------------------------------------------------------------------------------
1 | import warnings
2 |
3 | import mongoengine
4 | from flask import Flask, current_app
5 |
6 | from flask_mongoengine import db_fields, documents
7 | from flask_mongoengine.connection import *
8 | from flask_mongoengine.json import override_json_encoder
9 | from flask_mongoengine.pagination import *
10 | from flask_mongoengine.sessions import *
11 |
12 |
13 | def current_mongoengine_instance():
14 | """Return a MongoEngine instance associated with current Flask app."""
15 | me = current_app.extensions.get("mongoengine", {})
16 | for k, v in me.items():
17 | if isinstance(k, MongoEngine):
18 | return k
19 |
20 |
21 | class MongoEngine:
22 | """Main class used for initialization of Flask-MongoEngine."""
23 |
24 | def __init__(self, app=None, config=None):
25 | if config is not None:
26 | warnings.warn(
27 | (
28 | "Passing flat configuration is deprecated. Please check "
29 | "http://docs.mongoengine.org/projects/flask-mongoengine/flask_config.html "
30 | "for more info."
31 | ),
32 | DeprecationWarning,
33 | stacklevel=2,
34 | )
35 | # Extended database fields
36 | self.BinaryField = db_fields.BinaryField
37 | self.BooleanField = db_fields.BooleanField
38 | self.CachedReferenceField = db_fields.CachedReferenceField
39 | self.ComplexDateTimeField = db_fields.ComplexDateTimeField
40 | self.DateField = db_fields.DateField
41 | self.DateTimeField = db_fields.DateTimeField
42 | self.DecimalField = db_fields.DecimalField
43 | self.DictField = db_fields.DictField
44 | self.DynamicField = db_fields.DynamicField
45 | self.EmailField = db_fields.EmailField
46 | self.EmbeddedDocumentField = db_fields.EmbeddedDocumentField
47 | self.EmbeddedDocumentListField = db_fields.EmbeddedDocumentListField
48 | self.EnumField = db_fields.EnumField
49 | self.FileField = db_fields.FileField
50 | self.FloatField = db_fields.FloatField
51 | self.GenericEmbeddedDocumentField = db_fields.GenericEmbeddedDocumentField
52 | self.GenericLazyReferenceField = db_fields.GenericLazyReferenceField
53 | self.GenericReferenceField = db_fields.GenericReferenceField
54 | self.GeoJsonBaseField = db_fields.GeoJsonBaseField
55 | self.GeoPointField = db_fields.GeoPointField
56 | self.ImageField = db_fields.ImageField
57 | self.IntField = db_fields.IntField
58 | self.LazyReferenceField = db_fields.LazyReferenceField
59 | self.LineStringField = db_fields.LineStringField
60 | self.ListField = db_fields.ListField
61 | self.LongField = db_fields.LongField
62 | self.MapField = db_fields.MapField
63 | self.MultiLineStringField = db_fields.MultiLineStringField
64 | self.MultiPointField = db_fields.MultiPointField
65 | self.MultiPolygonField = db_fields.MultiPolygonField
66 | self.ObjectIdField = db_fields.ObjectIdField
67 | self.PointField = db_fields.PointField
68 | self.PolygonField = db_fields.PolygonField
69 | self.ReferenceField = db_fields.ReferenceField
70 | self.SequenceField = db_fields.SequenceField
71 | self.SortedListField = db_fields.SortedListField
72 | self.StringField = db_fields.StringField
73 | self.URLField = db_fields.URLField
74 | self.UUIDField = db_fields.UUIDField
75 |
76 | # Flask related data
77 | self.app = None
78 | self.config = config
79 |
80 | # Extended documents classes
81 | self.Document = documents.Document
82 | self.DynamicDocument = documents.DynamicDocument
83 |
84 | if app is not None:
85 | self.init_app(app, config)
86 |
87 | def init_app(self, app, config=None):
88 | if not app or not isinstance(app, Flask):
89 | raise TypeError("Invalid Flask application instance")
90 |
91 | if config is not None:
92 | warnings.warn(
93 | (
94 | "Passing flat configuration is deprecated. Please check "
95 | "http://docs.mongoengine.org/projects/flask-mongoengine/flask_config.html "
96 | "for more info."
97 | ),
98 | DeprecationWarning,
99 | stacklevel=2,
100 | )
101 | self.app = app
102 |
103 | app.extensions = getattr(app, "extensions", {})
104 |
105 | # Make documents JSON serializable
106 | override_json_encoder(app)
107 |
108 | if "mongoengine" not in app.extensions:
109 | app.extensions["mongoengine"] = {}
110 |
111 | if self in app.extensions["mongoengine"]:
112 | # Raise an exception if extension already initialized as
113 | # potentially new configuration would not be loaded.
114 | raise ValueError("Extension already initialized")
115 |
116 | if config:
117 | # Passed config have max priority, over init config.
118 | self.config = config
119 |
120 | if not self.config:
121 | # If no configs passed, use app.config.
122 | self.config = app.config
123 |
124 | # Obtain db connection(s)
125 | connections = create_connections(self.config)
126 |
127 | # Store objects in application instance so that multiple apps do not
128 | # end up accessing the same objects.
129 | s = {"app": app, "conn": connections}
130 | app.extensions["mongoengine"][self] = s
131 |
132 | @property
133 | def connection(self) -> dict:
134 | """
135 | Return MongoDB connection(s) associated with this MongoEngine
136 | instance.
137 | """
138 | return current_app.extensions["mongoengine"][self]["conn"]
139 |
140 | def __getattr__(self, attr_name):
141 | """
142 | Mongoengine backward compatibility handler.
143 |
144 | Provide original :module:``mongoengine`` module methods/classes if they are not
145 | modified by us, and not mapped directly.
146 | """
147 | return getattr(mongoengine, attr_name)
148 |
--------------------------------------------------------------------------------
/flask_mongoengine/connection.py:
--------------------------------------------------------------------------------
1 | """Module responsible for connection setup."""
2 | import warnings
3 | from typing import List
4 |
5 | import mongoengine
6 |
7 | __all__ = (
8 | "create_connections",
9 | "get_connection_settings",
10 | )
11 |
12 |
13 | def _get_name(setting_name: str) -> str:
14 | """
15 | Return known pymongo setting name, or lower case name for unknown.
16 |
17 | This problem discovered in issue #451. As mentioned there pymongo settings are not
18 | case-sensitive, but mongoengine use exact name of some settings for matching,
19 | overwriting pymongo behaviour.
20 |
21 | This function address this issue, and potentially address cases when pymongo will
22 | become case-sensitive in some settings by same reasons as mongoengine done.
23 |
24 | Based on pymongo 4.1.1 settings.
25 | """
26 | KNOWN_CAMEL_CASE_SETTINGS = {
27 | "directconnection": "directConnection",
28 | "maxpoolsize": "maxPoolSize",
29 | "minpoolsize": "minPoolSize",
30 | "maxidletimems": "maxIdleTimeMS",
31 | "maxconnecting": "maxConnecting",
32 | "sockettimeoutms": "socketTimeoutMS",
33 | "connecttimeoutms": "connectTimeoutMS",
34 | "serverselectiontimeoutms": "serverSelectionTimeoutMS",
35 | "waitqueuetimeoutms": "waitQueueTimeoutMS",
36 | "heartbeatfrequencyms": "heartbeatFrequencyMS",
37 | "retrywrites": "retryWrites",
38 | "retryreads": "retryReads",
39 | "zlibcompressionlevel": "zlibCompressionLevel",
40 | "uuidrepresentation": "uuidRepresentation",
41 | "srvservicename": "srvServiceName",
42 | "wtimeoutms": "wTimeoutMS",
43 | "replicaset": "replicaSet",
44 | "readpreference": "readPreference",
45 | "readpreferencetags": "readPreferenceTags",
46 | "maxstalenessseconds": "maxStalenessSeconds",
47 | "authsource": "authSource",
48 | "authmechanism": "authMechanism",
49 | "authmechanismproperties": "authMechanismProperties",
50 | "tlsinsecure": "tlsInsecure",
51 | "tlsallowinvalidcertificates": "tlsAllowInvalidCertificates",
52 | "tlsallowinvalidhostnames": "tlsAllowInvalidHostnames",
53 | "tlscafile": "tlsCAFile",
54 | "tlscertificatekeyfile": "tlsCertificateKeyFile",
55 | "tlscrlfile": "tlsCRLFile",
56 | "tlscertificatekeyfilepassword": "tlsCertificateKeyFilePassword",
57 | "tlsdisableocspendpointcheck": "tlsDisableOCSPEndpointCheck",
58 | "readconcernlevel": "readConcernLevel",
59 | }
60 | _setting_name = KNOWN_CAMEL_CASE_SETTINGS.get(setting_name.lower())
61 | return setting_name.lower() if _setting_name is None else _setting_name
62 |
63 |
64 | def _sanitize_settings(settings: dict) -> dict:
65 | """Remove ``MONGODB_`` prefix from dict values, to correct bypass to mongoengine."""
66 | resolved_settings = {}
67 | for k, v in settings.items():
68 | # Replace with k.lower().removeprefix("mongodb_") when python 3.8 support ends.
69 | key = _get_name(k[8:]) if k.lower().startswith("mongodb_") else _get_name(k)
70 | resolved_settings[key] = v
71 |
72 | return resolved_settings
73 |
74 |
75 | def get_connection_settings(config: dict) -> List[dict]:
76 | """
77 | Given a config dict, return a sanitized dict of MongoDB connection
78 | settings that we can then use to establish connections. For new
79 | applications, settings should exist in a ``MONGODB_SETTINGS`` key, but
80 | for backward compatibility we also support several config keys
81 | prefixed by ``MONGODB_``, e.g. ``MONGODB_HOST``, ``MONGODB_PORT``, etc.
82 | """
83 |
84 | # If no "MONGODB_SETTINGS", sanitize the "MONGODB_" keys as single connection.
85 | if "MONGODB_SETTINGS" not in config:
86 | warnings.warn(
87 | (
88 | "Passing flat configuration is deprecated. Please check "
89 | "http://docs.mongoengine.org/projects/flask-mongoengine/flask_config.html "
90 | "for more info."
91 | ),
92 | DeprecationWarning,
93 | stacklevel=2,
94 | )
95 | config = {k: v for k, v in config.items() if k.lower().startswith("mongodb_")}
96 | return [_sanitize_settings(config)]
97 |
98 | # Sanitize all the settings living under a "MONGODB_SETTINGS" config var
99 | settings = config["MONGODB_SETTINGS"]
100 |
101 | # If MONGODB_SETTINGS is a list of settings dicts, sanitize each dict separately.
102 | if isinstance(settings, list):
103 | return [_sanitize_settings(settings_dict) for settings_dict in settings]
104 |
105 | # Otherwise, it should be a single dict describing a single connection.
106 | return [_sanitize_settings(settings)]
107 |
108 |
109 | def create_connections(config: dict):
110 | """
111 | Given Flask application's config dict, extract relevant config vars
112 | out of it and establish MongoEngine connection(s) based on them.
113 | """
114 | # Validate that the config is a dict and dict is not empty
115 | if not config or not isinstance(config, dict):
116 | raise TypeError(f"Config dictionary expected, but {type(config)} received.")
117 |
118 | # Get sanitized connection settings based on the config
119 | connection_settings = get_connection_settings(config)
120 |
121 | connections = {}
122 | for connection_setting in connection_settings:
123 | alias = connection_setting.setdefault(
124 | "alias",
125 | mongoengine.DEFAULT_CONNECTION_NAME,
126 | )
127 | connection_setting.setdefault("uuidRepresentation", "standard")
128 | connections[alias] = mongoengine.connect(**connection_setting)
129 |
130 | return connections
131 |
--------------------------------------------------------------------------------
/flask_mongoengine/decorators.py:
--------------------------------------------------------------------------------
1 | """Collection of project wide decorators."""
2 | import functools
3 | import logging
4 | import warnings
5 |
6 | try:
7 | import wtforms # noqa
8 |
9 | wtf_installed = True
10 | except ImportError: # pragma: no cover
11 | wtf_installed = False
12 |
13 | logger = logging.getLogger("flask_mongoengine")
14 |
15 |
16 | def wtf_required(func):
17 | """Special decorator to warn user on incorrect installation."""
18 |
19 | @functools.wraps(func)
20 | def wrapped(*args, **kwargs):
21 | if not wtf_installed:
22 | logger.error(f"WTForms not installed. Function '{func.__name__}' aborted.")
23 | return None
24 |
25 | return func(*args, **kwargs)
26 |
27 | return wrapped
28 |
29 |
30 | def orm_deprecated(func):
31 | """Warning about usage of deprecated functions, that will be removed in the future."""
32 |
33 | @functools.wraps(func)
34 | def wrapped(*args, **kwargs):
35 | # TODO: Insert URL
36 | warnings.warn(
37 | (
38 | f"ORM module and function '{func.__name__}' are deprecated and will be "
39 | "removed in version 3.0.0. Please switch to form generation from full "
40 | "model nesting. Support and bugfixes are not available for stalled code. "
41 | "Please read: "
42 | ),
43 | DeprecationWarning,
44 | stacklevel=2,
45 | )
46 |
47 | return func(*args, **kwargs)
48 |
49 | return wrapped
50 |
--------------------------------------------------------------------------------
/flask_mongoengine/documents.py:
--------------------------------------------------------------------------------
1 | """Extended version of :mod:`mongoengine.document`."""
2 | import logging
3 | from typing import Dict, List, Optional, Type, Union
4 |
5 | import mongoengine
6 | from flask import abort
7 | from mongoengine.errors import DoesNotExist
8 | from mongoengine.queryset import QuerySet
9 |
10 | from flask_mongoengine.decorators import wtf_required
11 | from flask_mongoengine.pagination import ListFieldPagination, Pagination
12 |
13 | try:
14 | from flask_mongoengine.wtf.models import ModelForm
15 | except ImportError: # pragma: no cover
16 | ModelForm = None
17 | logger = logging.getLogger("flask_mongoengine")
18 |
19 |
20 | class BaseQuerySet(QuerySet):
21 | """Extends :class:`~mongoengine.queryset.QuerySet` class with handly methods."""
22 |
23 | def _abort_404(self, _message_404):
24 | """Returns 404 error with message, if message provided.
25 |
26 | :param _message_404: Message for 404 comment
27 | """
28 | abort(404, _message_404) if _message_404 else abort(404)
29 |
30 | def get_or_404(self, *args, _message_404=None, **kwargs):
31 | """Get a document and raise a 404 Not Found error if it doesn't exist.
32 |
33 | :param _message_404: Message for 404 comment, not forwarded to
34 | :func:`~mongoengine.queryset.QuerySet.get`
35 | :param args: args list, silently forwarded to
36 | :func:`~mongoengine.queryset.QuerySet.get`
37 | :param kwargs: keywords arguments, silently forwarded to
38 | :func:`~mongoengine.queryset.QuerySet.get`
39 | """
40 | try:
41 | return self.get(*args, **kwargs)
42 | except DoesNotExist:
43 | self._abort_404(_message_404)
44 |
45 | def first_or_404(self, _message_404=None):
46 | """
47 | Same as :func:`~BaseQuerySet.get_or_404`, but uses
48 | :func:`~mongoengine.queryset.QuerySet.first`, not
49 | :func:`~mongoengine.queryset.QuerySet.get`.
50 |
51 | :param _message_404: Message for 404 comment, not forwarded to
52 | :func:`~mongoengine.queryset.QuerySet.get`
53 | """
54 | return self.first() or self._abort_404(_message_404)
55 |
56 | def paginate(self, page, per_page):
57 | """
58 | Paginate the QuerySet with a certain number of docs per page
59 | and return docs for a given page.
60 | """
61 | return Pagination(self, page, per_page)
62 |
63 | def paginate_field(self, field_name, doc_id, page, per_page, total=None):
64 | """
65 | Paginate items within a list field from one document in the
66 | QuerySet.
67 | """
68 | # TODO this doesn't sound useful at all - remove in next release?
69 | item = self.get(id=doc_id)
70 | count = getattr(item, f"{field_name}_count", "")
71 | total = total or count or len(getattr(item, field_name))
72 | return ListFieldPagination(
73 | self, doc_id, field_name, page, per_page, total=total
74 | )
75 |
76 |
77 | class WtfFormMixin:
78 | """Special mixin, for form generation functions."""
79 |
80 | @classmethod
81 | def _get_fields_names(
82 | cls: Union["WtfFormMixin", mongoengine.document.BaseDocument],
83 | only: Optional[List[str]],
84 | exclude: Optional[List[str]],
85 | ):
86 | """
87 | Filter fields names for further form generation.
88 |
89 | :param only:
90 | An optional iterable with the property names that should be included in
91 | the form. Only these properties will have fields.
92 | Fields are always appear in provided order, this allows user to change form
93 | fields ordering, without changing database model.
94 | :param exclude:
95 | An optional iterable with the property names that should be excluded
96 | from the form. All other properties will have fields.
97 | Fields are appears in order, defined in model, excluding provided fields
98 | names. For adjusting fields ordering, use :attr:`only`.
99 | """
100 | field_names = cls._fields_ordered
101 |
102 | if only:
103 | field_names = [field for field in only if field in field_names]
104 | elif exclude:
105 | field_names = [field for field in field_names if field not in exclude]
106 |
107 | return field_names
108 |
109 | @classmethod
110 | @wtf_required
111 | def to_wtf_form(
112 | cls: Union["WtfFormMixin", mongoengine.document.BaseDocument],
113 | base_class: Type[ModelForm] = ModelForm,
114 | only: Optional[List[str]] = None,
115 | exclude: Optional[List[str]] = None,
116 | fields_kwargs: Optional[Dict[str, Dict]] = None,
117 | ) -> Type[ModelForm]:
118 | """
119 | Generate WTForm from Document model.
120 |
121 | :param base_class:
122 | Base form class to extend from. Must be a :class:`.ModelForm` subclass.
123 | :param only:
124 | An optional iterable with the property names that should be included in
125 | the form. Only these properties will have fields.
126 | Fields are always appear in provided order, this allows user to change form
127 | fields ordering, without changing database model.
128 | :param exclude:
129 | An optional iterable with the property names that should be excluded
130 | from the form. All other properties will have fields.
131 | Fields are appears in order, defined in model, excluding provided fields
132 | names. For adjusting fields ordering, use :attr:`only`.
133 | :param fields_kwargs:
134 | An optional dictionary of dictionaries, where field names mapping to keyword
135 | arguments used to construct each field object. Has the highest priority over
136 | all fields settings (made in Document field definition). Field options are
137 | directly passed to field generation, so must match WTForm Field keyword
138 | arguments. Support special field keyword option ``wtf_field_class``, that
139 | can be used for complete field class replacement.
140 |
141 | Dictionary format example::
142 |
143 | dictionary = {
144 | "field_name":{
145 | "label":"new",
146 | "default": "new",
147 | "wtf_field_class": wtforms.fields.StringField
148 | }
149 | }
150 |
151 | With such dictionary for field with name ``field_name``
152 | :class:`wtforms.fields.StringField` will be called like::
153 |
154 | field_name = wtforms.fields.StringField(label="new", default="new")
155 | """
156 | form_fields_dict = {}
157 | fields_kwargs = fields_kwargs or {}
158 | fields_names = cls._get_fields_names(only, exclude)
159 |
160 | for field_name in fields_names:
161 | # noinspection PyUnresolvedReferences
162 | field_class = cls._fields[field_name]
163 | try:
164 | form_fields_dict[field_name] = field_class.to_wtf_field(
165 | model=cls,
166 | field_kwargs=fields_kwargs.get(field_name, {}),
167 | )
168 | except (AttributeError, NotImplementedError):
169 | logger.warning(
170 | f"Field {field_name} ignored, field type does not have "
171 | f".to_wtf_field() method or method raised NotImplementedError."
172 | )
173 |
174 | form_fields_dict["model_class"] = cls
175 | # noinspection PyTypeChecker
176 | return type(f"{cls.__name__}Form", (base_class,), form_fields_dict)
177 |
178 |
179 | class Document(WtfFormMixin, mongoengine.Document):
180 | """Abstract Document with QuerySet and WTForms extra helpers."""
181 |
182 | meta = {"abstract": True, "queryset_class": BaseQuerySet}
183 |
184 | def paginate_field(self, field_name, page, per_page, total=None):
185 | """Paginate items within a list field."""
186 | # TODO this doesn't sound useful at all - remove in next release?
187 | count = getattr(self, f"{field_name}_count", "")
188 | total = total or count or len(getattr(self, field_name))
189 | return ListFieldPagination(
190 | self.__class__.objects, self.pk, field_name, page, per_page, total=total
191 | )
192 |
193 |
194 | class DynamicDocument(WtfFormMixin, mongoengine.DynamicDocument):
195 | """Abstract DynamicDocument with QuerySet and WTForms extra helpers."""
196 |
197 | meta = {"abstract": True, "queryset_class": BaseQuerySet}
198 |
199 |
200 | class EmbeddedDocument(WtfFormMixin, mongoengine.EmbeddedDocument):
201 | """Abstract EmbeddedDocument document with extra WTForms helpers."""
202 |
203 | meta = {"abstract": True}
204 |
205 |
206 | class DynamicEmbeddedDocument(WtfFormMixin, mongoengine.DynamicEmbeddedDocument):
207 | """Abstract DynamicEmbeddedDocument document with extra WTForms helpers."""
208 |
209 | meta = {"abstract": True}
210 |
--------------------------------------------------------------------------------
/flask_mongoengine/json.py:
--------------------------------------------------------------------------------
1 | """Flask application JSON extension functions."""
2 | from functools import lru_cache
3 |
4 | from bson import DBRef, ObjectId, json_util
5 | from mongoengine.base import BaseDocument
6 | from mongoengine.queryset import QuerySet
7 | from pymongo.command_cursor import CommandCursor
8 |
9 |
10 | @lru_cache(maxsize=1)
11 | def use_json_provider() -> bool:
12 | """Split Flask before 2.2.0 and after, to use/not use JSON provider approach."""
13 | from flask import __version__
14 |
15 | version = list(__version__.split("."))
16 | return int(version[0]) > 2 or (int(version[0]) == 2 and int(version[1]) > 1)
17 |
18 |
19 | # noinspection PyProtectedMember
20 | def _convert_mongo_objects(obj):
21 | """Convert objects, related to Mongo database to JSON."""
22 | converted = None
23 | if isinstance(obj, BaseDocument):
24 | converted = json_util._json_convert(obj.to_mongo())
25 | elif isinstance(obj, QuerySet):
26 | converted = json_util._json_convert(obj.as_pymongo())
27 | elif isinstance(obj, CommandCursor):
28 | converted = json_util._json_convert(obj)
29 | elif isinstance(obj, DBRef):
30 | converted = obj.id
31 | elif isinstance(obj, ObjectId):
32 | converted = obj.__str__()
33 | return converted
34 |
35 |
36 | def _make_encoder(superclass):
37 | """Extend Flask JSON Encoder 'default' method with support of Mongo objects."""
38 | import warnings
39 |
40 | warnings.warn(
41 | (
42 | "JSONEncoder/JSONDecoder are deprecated in Flask 2.2 and will be removed "
43 | "in Flask 2.3."
44 | ),
45 | DeprecationWarning,
46 | stacklevel=2,
47 | )
48 |
49 | class MongoEngineJSONEncoder(superclass):
50 | """
51 | A JSONEncoder which provides serialization of MongoEngine
52 | documents and queryset objects.
53 | """
54 |
55 | def default(self, obj):
56 | """Extend JSONEncoder default method, with Mongo objects."""
57 | if isinstance(
58 | obj,
59 | (BaseDocument, QuerySet, CommandCursor, DBRef, ObjectId),
60 | ):
61 | return _convert_mongo_objects(obj)
62 | return super().default(obj)
63 |
64 | return MongoEngineJSONEncoder
65 |
66 |
67 | def _update_json_provider(superclass):
68 | """Extend Flask Provider 'default' static method with support of Mongo objects."""
69 |
70 | class MongoEngineJSONProvider(superclass):
71 | """A JSON Provider update for Flask 2.2.0+"""
72 |
73 | @staticmethod
74 | def default(obj):
75 | """Extend JSONProvider default static method, with Mongo objects."""
76 | if isinstance(
77 | obj,
78 | (BaseDocument, QuerySet, CommandCursor, DBRef, ObjectId),
79 | ):
80 | return _convert_mongo_objects(obj)
81 | return super().default(obj)
82 |
83 | return MongoEngineJSONProvider
84 |
85 |
86 | # Compatibility code for Flask 2.2.0+ support
87 | MongoEngineJSONEncoder = None
88 | MongoEngineJSONProvider = None
89 |
90 | if use_json_provider():
91 | from flask.json.provider import DefaultJSONProvider
92 |
93 | MongoEngineJSONProvider = _update_json_provider(DefaultJSONProvider)
94 | else:
95 | from flask.json import JSONEncoder
96 |
97 | MongoEngineJSONEncoder = _make_encoder(JSONEncoder)
98 | # End of compatibility code
99 |
100 |
101 | def override_json_encoder(app):
102 | """
103 | A function to dynamically create a new MongoEngineJSONEncoder class
104 | based upon a custom base class.
105 | This function allows us to combine MongoEngine serialization with
106 | any changes to Flask's JSONEncoder which a user may have made
107 | prior to calling init_app.
108 |
109 | NOTE: This does not cover situations where users override
110 | an instance's json_encoder after calling init_app.
111 | """
112 |
113 | if use_json_provider():
114 | app.json_provider_class = _update_json_provider(app.json_provider_class)
115 | app.json = app.json_provider_class(app)
116 | else:
117 | app.json_encoder = _make_encoder(app.json_encoder)
118 |
--------------------------------------------------------------------------------
/flask_mongoengine/pagination.py:
--------------------------------------------------------------------------------
1 | """Module responsible for custom pagination."""
2 | import math
3 |
4 | from flask import abort
5 | from mongoengine.queryset import QuerySet
6 |
7 | __all__ = ("Pagination", "ListFieldPagination")
8 |
9 |
10 | class Pagination(object):
11 | def __init__(self, iterable, page, per_page):
12 |
13 | if page < 1:
14 | abort(404)
15 |
16 | self.iterable = iterable
17 | self.page = page
18 | self.per_page = per_page
19 |
20 | if isinstance(self.iterable, QuerySet):
21 | self.total = iterable.count()
22 | self.items = (
23 | self.iterable.skip(self.per_page * (self.page - 1))
24 | .limit(self.per_page)
25 | .select_related()
26 | )
27 | else:
28 | start_index = (page - 1) * per_page
29 | end_index = page * per_page
30 |
31 | self.total = len(iterable)
32 | self.items = iterable[start_index:end_index]
33 | if not self.items and page != 1:
34 | abort(404)
35 |
36 | @property
37 | def pages(self):
38 | """The total number of pages"""
39 | return int(math.ceil(self.total / float(self.per_page)))
40 |
41 | def prev(self, error_out=False):
42 | """Returns a :class:`Pagination` object for the previous page."""
43 | assert (
44 | self.iterable is not None
45 | ), "an object is required for this method to work"
46 | iterable = self.iterable
47 | if isinstance(iterable, QuerySet):
48 | iterable._skip = None
49 | iterable._limit = None
50 | return self.__class__(iterable, self.page - 1, self.per_page)
51 |
52 | @property
53 | def prev_num(self):
54 | """Number of the previous page."""
55 | return self.page - 1
56 |
57 | @property
58 | def has_prev(self):
59 | """True if a previous page exists"""
60 | return self.page > 1
61 |
62 | def next(self, error_out=False):
63 | """Returns a :class:`Pagination` object for the next page."""
64 | assert (
65 | self.iterable is not None
66 | ), "an object is required for this method to work"
67 | iterable = self.iterable
68 | if isinstance(iterable, QuerySet):
69 | iterable._skip = None
70 | iterable._limit = None
71 | return self.__class__(iterable, self.page + 1, self.per_page)
72 |
73 | @property
74 | def has_next(self):
75 | """True if a next page exists."""
76 | return self.page < self.pages
77 |
78 | @property
79 | def next_num(self):
80 | """Number of the next page"""
81 | return self.page + 1
82 |
83 | def iter_pages(self, left_edge=2, left_current=2, right_current=5, right_edge=2):
84 | """Iterates over the page numbers in the pagination. The four
85 | parameters control the thresholds how many numbers should be produced
86 | from the sides. Skipped page numbers are represented as `None`.
87 | This is how you could render such a pagination in the templates:
88 |
89 | .. sourcecode:: html+jinja
90 |
91 | {% macro render_pagination(pagination, endpoint) %}
92 |
105 | {% endmacro %}
106 | """
107 | last = 0
108 | for num in range(1, self.pages + 1):
109 | if (
110 | num <= left_edge
111 | or num > self.pages - right_edge
112 | or (
113 | num >= self.page - left_current and num <= self.page + right_current
114 | )
115 | ):
116 | if last + 1 != num:
117 | yield None
118 | yield num
119 | last = num
120 | if last != self.pages:
121 | yield None
122 |
123 |
124 | class ListFieldPagination(Pagination):
125 | def __init__(self, queryset, doc_id, field_name, page, per_page, total=None):
126 | """Allows an array within a document to be paginated.
127 |
128 | Queryset must contain the document which has the array we're
129 | paginating, and doc_id should be it's _id.
130 | Field name is the name of the array we're paginating.
131 | Page and per_page work just like in Pagination.
132 | Total is an argument because it can be computed more efficiently
133 | elsewhere, but we still use array.length as a fallback.
134 | """
135 | if page < 1:
136 | abort(404)
137 |
138 | self.page = page
139 | self.per_page = per_page
140 |
141 | self.queryset = queryset
142 | self.doc_id = doc_id
143 | self.field_name = field_name
144 |
145 | start_index = (page - 1) * per_page
146 |
147 | field_attrs = {field_name: {"$slice": [start_index, per_page]}}
148 |
149 | qs = queryset(pk=doc_id)
150 | self.items = getattr(qs.fields(**field_attrs).first(), field_name)
151 | self.total = total or len(
152 | getattr(qs.fields(**{field_name: 1}).first(), field_name)
153 | )
154 |
155 | if not self.items and page != 1:
156 | abort(404)
157 |
158 | def prev(self, error_out=False):
159 | """Returns a :class:`Pagination` object for the previous page."""
160 | assert (
161 | self.items is not None
162 | ), "a query object is required for this method to work"
163 | return self.__class__(
164 | self.queryset,
165 | self.doc_id,
166 | self.field_name,
167 | self.page - 1,
168 | self.per_page,
169 | self.total,
170 | )
171 |
172 | def next(self, error_out=False):
173 | """Returns a :class:`Pagination` object for the next page."""
174 | assert (
175 | self.items is not None
176 | ), "a query object is required for this method to work"
177 | return self.__class__(
178 | self.queryset,
179 | self.doc_id,
180 | self.field_name,
181 | self.page + 1,
182 | self.per_page,
183 | self.total,
184 | )
185 |
--------------------------------------------------------------------------------
/flask_mongoengine/panels.py:
--------------------------------------------------------------------------------
1 | """Debug panel views and logic and related mongoDb event listeners."""
2 | __all__ = ["mongo_command_logger", "MongoDebugPanel"]
3 | import logging
4 | import sys
5 | from dataclasses import dataclass
6 | from typing import List, Union
7 |
8 | from flask import current_app
9 | from flask_debugtoolbar.panels import DebugPanel
10 | from jinja2 import ChoiceLoader, PackageLoader
11 | from pymongo import monitoring
12 |
13 | logger = logging.getLogger("flask_mongoengine")
14 |
15 |
16 | @dataclass
17 | class RawQueryEvent:
18 | # noinspection PyUnresolvedReferences
19 | """Responsible for parsing monitoring events to web panel interface.
20 |
21 | :param _event: Succeeded or Failed event object from pymongo monitoring.
22 | :param _start_event: Started event object from pymongo monitoring.
23 | :param _is_query_pass: Boolean status of db query reported by pymongo monitoring.
24 | """
25 |
26 | _event: Union[monitoring.CommandSucceededEvent, monitoring.CommandFailedEvent]
27 | _start_event: monitoring.CommandStartedEvent
28 | _is_query_pass: bool
29 |
30 | @property
31 | def time(self):
32 | """Query execution time."""
33 | return self._event.duration_micros * 0.001
34 |
35 | @property
36 | def size(self):
37 | """Query object size."""
38 | return sys.getsizeof(self.server_response, 0) / 1024
39 |
40 | @property
41 | def database(self):
42 | """Query database target."""
43 | return self._start_event.database_name
44 |
45 | @property
46 | def collection(self):
47 | """Query collection target."""
48 | return self.server_command.get(self.command_name)
49 |
50 | @property
51 | def command_name(self):
52 | """Query db level operation/command name."""
53 | return self._event.command_name
54 |
55 | @property
56 | def operation_id(self):
57 | """MongoDb operation_id used to match 'start' and 'final' monitoring events."""
58 | return self._start_event.operation_id
59 |
60 | @property
61 | def server_command(self):
62 | """Raw MongoDb command send to server."""
63 | return self._start_event.command
64 |
65 | @property
66 | def server_response(self):
67 | """Raw MongoDb response received from server."""
68 | return self._event.reply if self._is_query_pass else self._event.failure
69 |
70 | @property
71 | def request_status(self):
72 | """Query execution status."""
73 | return "Succeed" if self._is_query_pass else "Failed"
74 |
75 |
76 | class MongoCommandLogger(monitoring.CommandListener):
77 | """Receive point for :class:`~.pymongo.monitoring.CommandListener` events.
78 |
79 | Count and parse incoming events for display in debug panel.
80 | """
81 |
82 | def __init__(self):
83 | self.total_time: float = 0
84 | self.started_operations_count: int = 0
85 | self.succeeded_operations_count: int = 0
86 | self.failed_operations_count: int = 0
87 | self.queries: List[RawQueryEvent] = []
88 | self.started_events: dict = {}
89 |
90 | def append_raw_query(self, event, request_status):
91 | """Pass 'unknown' events to parser and include final result to final list."""
92 | self.total_time += event.duration_micros
93 | start_event = self.started_events.pop(event.operation_id, {})
94 | self.queries.append(RawQueryEvent(event, start_event, request_status))
95 | logger.debug(f"Added record to 'Unknown' section: {self.queries[-1]}")
96 |
97 | def failed(self, event):
98 | """Receives 'failed' events. Required to track database answer to request."""
99 | logger.debug(f"Received 'Failed' event from driver: {event}")
100 | self.failed_operations_count += 1
101 | self.append_raw_query(event, False)
102 |
103 | def reset_tracker(self):
104 | """Resets all counters to default, keeping instance itself the same."""
105 | self.__class__.__init__(self)
106 |
107 | def started(self, event):
108 | """Receives 'started' events. Required to track original request context."""
109 | logger.debug(f"Received 'Started' event from driver: {event}")
110 | self.started_operations_count += 1
111 | self.started_events[event.operation_id] = event
112 |
113 | def succeeded(self, event):
114 | """Receives 'succeeded' events. Required to track database answer to request."""
115 | logger.debug(f"Received 'Succeeded' event from driver: {event}")
116 | self.succeeded_operations_count += 1
117 | self.append_raw_query(event, True)
118 |
119 |
120 | mongo_command_logger = MongoCommandLogger()
121 |
122 |
123 | def _maybe_patch_jinja_loader(jinja_env):
124 | """Extend jinja_env loader with flask_mongoengine templates folder."""
125 | package_loader = PackageLoader("flask_mongoengine", "templates")
126 | if not isinstance(jinja_env.loader, ChoiceLoader):
127 | jinja_env.loader = ChoiceLoader([jinja_env.loader, package_loader])
128 | elif package_loader not in jinja_env.loader.loaders:
129 | jinja_env.loader.loaders += [package_loader]
130 |
131 |
132 | class MongoDebugPanel(DebugPanel):
133 | """Panel that shows information about MongoDB operations."""
134 |
135 | config_error_message = (
136 | "Pymongo monitoring configuration error. mongo_command_logger should be "
137 | "registered before database connection."
138 | )
139 | name = "MongoDB"
140 | has_content = True
141 |
142 | def __init__(self, *args, **kwargs):
143 | super().__init__(*args, **kwargs)
144 | _maybe_patch_jinja_loader(self.jinja_env)
145 |
146 | @property
147 | def _context(self) -> dict:
148 | """Context for rendering, as property for easy testing."""
149 | return {
150 | "queries": mongo_command_logger.queries,
151 | "slow_query_limit": current_app.config.get(
152 | "MONGO_DEBUG_PANEL_SLOW_QUERY_LIMIT", 100
153 | ),
154 | }
155 |
156 | @property
157 | def is_properly_configured(self) -> bool:
158 | """Checks that all required watchers registered before Flask application init."""
159 | # noinspection PyProtectedMember
160 | if mongo_command_logger not in monitoring._LISTENERS.command_listeners:
161 | logger.error(self.config_error_message)
162 | return False
163 | return True
164 |
165 | def process_request(self, request):
166 | """Resets logger stats between each request."""
167 | mongo_command_logger.reset_tracker()
168 |
169 | def nav_title(self) -> str:
170 | """Debug toolbar in the bottom right corner."""
171 | return self.name
172 |
173 | def nav_subtitle(self) -> str:
174 | """Count operations total time."""
175 | if not self.is_properly_configured:
176 | self.has_content = False
177 | return self.config_error_message
178 |
179 | return (
180 | f"{mongo_command_logger.started_operations_count} operations, "
181 | f"in {mongo_command_logger.total_time * 0.001: .2f}ms"
182 | )
183 |
184 | def title(self) -> str:
185 | """Title for 'opened' debug panel window."""
186 | return "MongoDB Operations"
187 |
188 | def url(self) -> str:
189 | """Placeholder for internal URLs."""
190 | return ""
191 |
192 | def content(self):
193 | """Gathers all template required variables in one dict."""
194 | return self.render("panels/mongo-panel.html", self._context)
195 |
--------------------------------------------------------------------------------
/flask_mongoengine/sessions.py:
--------------------------------------------------------------------------------
1 | import uuid
2 | from datetime import datetime, timedelta
3 |
4 | from bson.tz_util import utc
5 | from flask.sessions import SessionInterface, SessionMixin
6 | from werkzeug.datastructures import CallbackDict
7 |
8 | __all__ = ("MongoEngineSession", "MongoEngineSessionInterface")
9 |
10 |
11 | class MongoEngineSession(CallbackDict, SessionMixin):
12 | def __init__(self, initial=None, sid=None):
13 | def on_update(self):
14 | self.modified = True
15 |
16 | CallbackDict.__init__(self, initial, on_update)
17 | self.sid = sid
18 | self.modified = False
19 |
20 |
21 | class MongoEngineSessionInterface(SessionInterface):
22 | """SessionInterface for mongoengine"""
23 |
24 | def __init__(self, db, collection="session"):
25 | """
26 | The MongoSessionInterface
27 |
28 | :param db: The app's db eg: MongoEngine()
29 | :param collection: The session collection name defaults to "session"
30 | """
31 |
32 | if not isinstance(collection, str):
33 | raise ValueError("Collection argument should be string")
34 |
35 | class DBSession(db.Document):
36 | sid = db.StringField(primary_key=True)
37 | data = db.DictField()
38 | expiration = db.DateTimeField()
39 | meta = {
40 | "allow_inheritance": False,
41 | "collection": collection,
42 | "indexes": [
43 | {
44 | "fields": ["expiration"],
45 | "expireAfterSeconds": 60 * 60 * 24 * 7 * 31,
46 | }
47 | ],
48 | }
49 |
50 | self.cls = DBSession
51 |
52 | def get_expiration_time(self, app, session) -> timedelta:
53 | if session.permanent:
54 | return app.permanent_session_lifetime
55 | # Fallback to 1 day session ttl, if SESSION_TTL not set.
56 | return timedelta(**app.config.get("SESSION_TTL", {"days": 1}))
57 |
58 | def open_session(self, app, request):
59 | sid = request.cookies.get(app.session_cookie_name)
60 | if sid:
61 | stored_session = self.cls.objects(sid=sid).first()
62 |
63 | if stored_session:
64 | expiration = stored_session.expiration
65 |
66 | if not expiration.tzinfo:
67 | expiration = expiration.replace(tzinfo=utc)
68 |
69 | if expiration > datetime.utcnow().replace(tzinfo=utc):
70 | return MongoEngineSession(
71 | initial=stored_session.data, sid=stored_session.sid
72 | )
73 |
74 | return MongoEngineSession(sid=str(uuid.uuid4()))
75 |
76 | def save_session(self, app, session, response):
77 | domain = self.get_cookie_domain(app)
78 | httponly = self.get_cookie_httponly(app)
79 |
80 | # If the session is modified to be empty, remove the cookie.
81 | # If the session is empty, return without setting the cookie.
82 | if not session:
83 | if session.modified:
84 | response.delete_cookie(app.session_cookie_name, domain=domain)
85 | return
86 |
87 | expiration = datetime.utcnow().replace(tzinfo=utc) + self.get_expiration_time(
88 | app, session
89 | )
90 |
91 | if session.modified:
92 | self.cls(sid=session.sid, data=session, expiration=expiration).save()
93 |
94 | response.set_cookie(
95 | app.session_cookie_name,
96 | session.sid,
97 | expires=expiration,
98 | httponly=httponly,
99 | domain=domain,
100 | )
101 |
--------------------------------------------------------------------------------
/flask_mongoengine/templates/panels/mongo-panel.html:
--------------------------------------------------------------------------------
1 |
17 |
18 | {% macro render_stats(title, queries, slow_query_limit) %}
19 |
20 | {{ title }}
21 | {% if queries %}
22 |
23 |
24 |
25 | | Time (ms) |
26 | Size |
27 | Database |
28 | Collection |
29 | Command name |
30 | Operation id |
31 | Server command |
32 | Response data |
33 | Request status |
34 |
35 |
36 |
37 | {% for query in queries %}
38 |
39 | {% set colspan = 9 %}
40 | | slow_query_limit %}style="color:red;" {% endif %}>
41 | {{ query.time|round(3) }}
42 | |
43 | {{ query.size|round(2) }}Kb |
44 | {{ query.database }} |
45 | {{ query.collection }} |
46 | {{ query.command_name }} |
47 | {{ query.operation_id }} |
48 |
49 | Toggle
51 | |
52 |
53 | Toggle
55 | |
56 | {{ query.request_status }} |
57 |
58 |
59 |
61 |
62 | {{ query.server_command|pprint }}
63 | |
64 |
65 |
66 |
68 |
69 | {{ query.server_response|pprint }}
70 | |
71 |
72 |
73 | {% endfor %}
74 |
75 |
76 | {% else %}
77 | No {{ title|lower }} recorded
78 | {% endif %}
79 | {% endmacro %}
80 |
81 | {{ render_stats("Queries", queries, slow_query_limit) }}
82 |
83 |
94 |
--------------------------------------------------------------------------------
/flask_mongoengine/wtf/__init__.py:
--------------------------------------------------------------------------------
1 | """WTFForms integration module init file."""
2 | from flask_mongoengine.wtf.orm import model_fields, model_form # noqa
3 |
--------------------------------------------------------------------------------
/flask_mongoengine/wtf/models.py:
--------------------------------------------------------------------------------
1 | from typing import Type, Union
2 |
3 | import mongoengine
4 | from flask_wtf import FlaskForm
5 | from flask_wtf.form import _Auto
6 |
7 |
8 | class ModelForm(FlaskForm):
9 | """A WTForms mongoengine model form"""
10 |
11 | model_class: Type[Union[mongoengine.Document, mongoengine.DynamicDocument]]
12 |
13 | def __init__(self, formdata=_Auto, **kwargs):
14 | self.instance = kwargs.pop("instance", None) or kwargs.get("obj")
15 | if self.instance and not formdata:
16 | kwargs["obj"] = self.instance
17 | self.formdata = formdata
18 | super(ModelForm, self).__init__(formdata, **kwargs)
19 |
20 | def save(self, commit=True, **kwargs):
21 | if not self.instance:
22 | self.instance = self.model_class()
23 | self.populate_obj(self.instance)
24 |
25 | if commit:
26 | self.instance.save(**kwargs)
27 | return self.instance
28 |
--------------------------------------------------------------------------------
/flask_mongoengine/wtf/orm.py:
--------------------------------------------------------------------------------
1 | """
2 | Tools for generating forms based on mongoengine Document schemas.
3 | """
4 | import decimal
5 | from collections import OrderedDict
6 | from typing import List, Optional, Type
7 |
8 | from bson import ObjectId
9 | from mongoengine import ReferenceField
10 | from mongoengine.base import BaseDocument, DocumentMetaclass
11 | from wtforms import fields as f
12 | from wtforms import validators
13 |
14 | from flask_mongoengine.decorators import orm_deprecated
15 | from flask_mongoengine.wtf.fields import (
16 | BinaryField,
17 | DictField,
18 | ModelSelectField,
19 | ModelSelectMultipleField,
20 | NoneStringField,
21 | )
22 | from flask_mongoengine.wtf.models import ModelForm
23 |
24 | __all__ = (
25 | "model_fields",
26 | "model_form",
27 | )
28 |
29 |
30 | @orm_deprecated
31 | def converts(*args):
32 | def _inner(func):
33 | func._converter_for = frozenset(args)
34 | return func
35 |
36 | return _inner
37 |
38 |
39 | class ModelConverter(object):
40 | @orm_deprecated
41 | def __init__(self, converters=None):
42 | if not converters:
43 | converters = {}
44 |
45 | for name in dir(self):
46 | obj = getattr(self, name)
47 | if hasattr(obj, "_converter_for"):
48 | for classname in obj._converter_for:
49 | converters[classname] = obj
50 |
51 | self.converters = converters
52 |
53 | @orm_deprecated
54 | def _generate_convert_base_kwargs(self, field, field_args) -> dict:
55 | kwargs: dict = {
56 | "label": getattr(field, "verbose_name", field.name),
57 | "description": getattr(field, "help_text", None) or "",
58 | "validators": getattr(field, "wtf_validators", None)
59 | or getattr(field, "validators", None)
60 | or [],
61 | "filters": getattr(field, "wtf_filters", None)
62 | or getattr(field, "filters", None)
63 | or [],
64 | "default": field.default,
65 | }
66 | if field_args:
67 | kwargs.update(field_args)
68 |
69 | # Create a copy of the lists since we will be modifying it, and if
70 | # validators set as shared list between fields - duplicates/conflicts may
71 | # be created.
72 | kwargs["validators"] = list(kwargs["validators"])
73 | kwargs["filters"] = list(kwargs["filters"])
74 | if field.required:
75 | kwargs["validators"].append(validators.InputRequired())
76 | else:
77 | kwargs["validators"].append(validators.Optional())
78 |
79 | return kwargs
80 |
81 | @orm_deprecated
82 | def _process_convert_for_choice_fields(self, field, field_class, kwargs):
83 | kwargs["choices"] = field.choices
84 | kwargs["coerce"] = self.coerce(field_class)
85 | if kwargs.pop("multiple", False):
86 | return f.SelectMultipleField(**kwargs)
87 | if kwargs.pop("radio", False):
88 | return f.RadioField(**kwargs)
89 | return f.SelectField(**kwargs)
90 |
91 | @orm_deprecated
92 | def convert(self, model, field, field_args):
93 | field_class = type(field).__name__
94 |
95 | if field_class not in self.converters:
96 | return None
97 |
98 | kwargs = self._generate_convert_base_kwargs(field, field_args)
99 |
100 | if field.choices:
101 | return self._process_convert_for_choice_fields(field, field_class, kwargs)
102 |
103 | if hasattr(field, "field") and isinstance(field.field, ReferenceField):
104 | kwargs["label_modifier"] = getattr(
105 | model, f"{field.name}_label_modifier", None
106 | )
107 |
108 | return self.converters[field_class](model, field, kwargs)
109 |
110 | @classmethod
111 | def _string_common(cls, model, field, kwargs):
112 | if field.max_length or field.min_length:
113 | kwargs["validators"].append(
114 | validators.Length(
115 | max=field.max_length or -1, min=field.min_length or -1
116 | )
117 | )
118 |
119 | @classmethod
120 | def _number_common(cls, model, field, kwargs):
121 | if field.max_value or field.min_value:
122 | kwargs["validators"].append(
123 | validators.NumberRange(max=field.max_value, min=field.min_value)
124 | )
125 |
126 | @converts("StringField")
127 | def conv_String(self, model, field, kwargs):
128 | if field.regex:
129 | kwargs["validators"].append(validators.Regexp(regex=field.regex))
130 | self._string_common(model, field, kwargs)
131 | password_field = kwargs.pop("password", False)
132 | textarea_field = kwargs.pop("textarea", False) or not field.max_length
133 | if password_field:
134 | return f.PasswordField(**kwargs)
135 | if textarea_field:
136 | return f.TextAreaField(**kwargs)
137 | return f.StringField(**kwargs)
138 |
139 | @converts("URLField")
140 | def conv_URL(self, model, field, kwargs):
141 | kwargs["validators"].append(validators.URL())
142 | self._string_common(model, field, kwargs)
143 | return NoneStringField(**kwargs)
144 |
145 | @converts("EmailField")
146 | def conv_Email(self, model, field, kwargs):
147 | kwargs["validators"].append(validators.Email())
148 | self._string_common(model, field, kwargs)
149 | return NoneStringField(**kwargs)
150 |
151 | @converts("IntField")
152 | def conv_Int(self, model, field, kwargs):
153 | self._number_common(model, field, kwargs)
154 | return f.IntegerField(**kwargs)
155 |
156 | @converts("FloatField")
157 | def conv_Float(self, model, field, kwargs):
158 | self._number_common(model, field, kwargs)
159 | return f.FloatField(**kwargs)
160 |
161 | @converts("DecimalField")
162 | def conv_Decimal(self, model, field, kwargs):
163 | self._number_common(model, field, kwargs)
164 | kwargs["places"] = getattr(field, "precision", None)
165 | return f.DecimalField(**kwargs)
166 |
167 | @converts("BooleanField")
168 | def conv_Boolean(self, model, field, kwargs):
169 | return f.BooleanField(**kwargs)
170 |
171 | @converts("DateTimeField")
172 | def conv_DateTime(self, model, field, kwargs):
173 | return f.DateTimeField(**kwargs)
174 |
175 | @converts("DateField")
176 | def conv_Date(self, model, field, kwargs):
177 | return f.DateField(**kwargs)
178 |
179 | @converts("BinaryField")
180 | def conv_Binary(self, model, field, kwargs):
181 | # TODO: may be set file field that will save file`s data to MongoDB
182 | if field.max_bytes:
183 | kwargs["validators"].append(validators.Length(max=field.max_bytes))
184 | return BinaryField(**kwargs)
185 |
186 | @converts("DictField")
187 | def conv_Dict(self, model, field, kwargs):
188 | return DictField(**kwargs)
189 |
190 | @converts("ListField")
191 | def conv_List(self, model, field, kwargs):
192 | if isinstance(field.field, ReferenceField):
193 | return ModelSelectMultipleField(model=field.field.document_type, **kwargs)
194 | if field.field.choices:
195 | kwargs["multiple"] = True
196 | return self.convert(model, field.field, kwargs)
197 | field_args = kwargs.pop("field_args", {})
198 | unbound_field = self.convert(model, field.field, field_args)
199 | unacceptable = {
200 | "validators": [],
201 | "filters": [],
202 | "min_entries": kwargs.get("min_entries", 0),
203 | }
204 | kwargs.update(unacceptable)
205 | return f.FieldList(unbound_field, **kwargs)
206 |
207 | @converts("SortedListField")
208 | def conv_SortedList(self, model, field, kwargs):
209 | # TODO: sort functionality, may be need sortable widget
210 | return self.conv_List(model, field, kwargs)
211 |
212 | @converts("GeoLocationField")
213 | def conv_GeoLocation(self, model, field, kwargs):
214 | # TODO: create geo field and widget (also GoogleMaps)
215 | return
216 |
217 | @converts("ObjectIdField")
218 | def conv_ObjectId(self, model, field, kwargs):
219 | return
220 |
221 | @converts("EmbeddedDocumentField")
222 | def conv_EmbeddedDocument(self, model, field, kwargs):
223 | kwargs = {
224 | "validators": [],
225 | "filters": [],
226 | "default": field.default or field.document_type_obj,
227 | }
228 | form_class = model_form(field.document_type_obj, field_args={})
229 | return f.FormField(form_class, **kwargs)
230 |
231 | @converts("ReferenceField")
232 | def conv_Reference(self, model, field, kwargs):
233 | return ModelSelectField(model=field.document_type, **kwargs)
234 |
235 | @converts("GenericReferenceField")
236 | def conv_GenericReference(self, model, field, kwargs):
237 | return
238 |
239 | @converts("FileField")
240 | def conv_File(self, model, field, kwargs):
241 | return f.FileField(**kwargs)
242 |
243 | @orm_deprecated
244 | def coerce(self, field_type):
245 | coercions = {
246 | "IntField": int,
247 | "BooleanField": bool,
248 | "FloatField": float,
249 | "DecimalField": decimal.Decimal,
250 | "ObjectIdField": ObjectId,
251 | }
252 | return coercions.get(field_type, str)
253 |
254 |
255 | @orm_deprecated
256 | def _get_fields_names(
257 | model,
258 | only: Optional[List[str]],
259 | exclude: Optional[List[str]],
260 | ) -> List[str]:
261 | """
262 | Filter fields names for further form generation.
263 |
264 | :param model: Source model class for fields list retrieval
265 | :param only: If provided, only these field names will have fields definition.
266 | :param exclude: If provided, field names will be excluded from fields definition.
267 | All other field names will have fields.
268 | """
269 | field_names = model._fields_ordered
270 |
271 | if only:
272 | field_names = [field for field in only if field in field_names]
273 | elif exclude:
274 | field_names = [field for field in field_names if field not in set(exclude)]
275 |
276 | return field_names
277 |
278 |
279 | @orm_deprecated
280 | def model_fields(
281 | model: Type[BaseDocument],
282 | only: Optional[List[str]] = None,
283 | exclude: Optional[List[str]] = None,
284 | field_args=None,
285 | converter=None,
286 | ) -> OrderedDict:
287 | """
288 | Generate a dictionary of fields for a given database model.
289 |
290 | See :func:`model_form` docstring for description of parameters.
291 | """
292 | if not issubclass(model, (BaseDocument, DocumentMetaclass)):
293 | raise TypeError("model must be a mongoengine Document schema")
294 |
295 | converter = converter or ModelConverter()
296 | field_args = field_args or {}
297 | form_fields_dict = OrderedDict()
298 | # noinspection PyTypeChecker
299 | fields_names = _get_fields_names(model, only, exclude)
300 |
301 | for field_name in fields_names:
302 | # noinspection PyUnresolvedReferences
303 | model_field = model._fields[field_name]
304 | form_field = converter.convert(model, model_field, field_args.get(field_name))
305 | if form_field is not None:
306 | form_fields_dict[field_name] = form_field
307 |
308 | return form_fields_dict
309 |
310 |
311 | @orm_deprecated
312 | def model_form(
313 | model: Type[BaseDocument],
314 | base_class: Type[ModelForm] = ModelForm,
315 | only: Optional[List[str]] = None,
316 | exclude: Optional[List[str]] = None,
317 | field_args=None,
318 | converter=None,
319 | ) -> Type[ModelForm]:
320 | """
321 | Create a wtforms Form for a given mongoengine Document schema::
322 |
323 | from flask_mongoengine.wtf import model_form
324 | from myproject.myapp.schemas import Article
325 | ArticleForm = model_form(Article)
326 |
327 | :param model:
328 | A mongoengine Document schema class
329 | :param base_class:
330 | Base form class to extend from. Must be a :class:`.ModelForm` subclass.
331 | :param only:
332 | An optional iterable with the property names that should be included in
333 | the form. Only these properties will have fields.
334 | Fields are always appear in provided order, this allows user to change form
335 | fields ordering, without changing database model.
336 | :param exclude:
337 | An optional iterable with the property names that should be excluded
338 | from the form. All other properties will have fields.
339 | Fields are appears in order, defined in model, excluding provided fields
340 | names. For adjusting fields ordering, use :attr:`only`.
341 | :param field_args:
342 | An optional dictionary of field names mapping to keyword arguments used
343 | to construct each field object.
344 | :param converter:
345 | A converter to generate the fields based on the model properties. If
346 | not set, :class:`.ModelConverter` is used.
347 | """
348 | field_dict = model_fields(model, only, exclude, field_args, converter)
349 | field_dict["model_class"] = model
350 | # noinspection PyTypeChecker
351 | return type(f"{model.__name__}Form", (base_class,), field_dict)
352 |
--------------------------------------------------------------------------------
/noxfile.py:
--------------------------------------------------------------------------------
1 | """Nox tool configuration file.
2 |
3 | Nox is Tox tool replacement.
4 | """
5 | import shutil
6 | from pathlib import Path
7 |
8 | import nox
9 |
10 | nox.options.sessions = "latest", "lint", "documentation_tests"
11 | db_version = "5.0"
12 |
13 |
14 | def base_install(session, flask, mongoengine, toolbar, wtf):
15 | """Create basic environment setup for tests and linting."""
16 | session.run("python", "-m", "pip", "install", "--upgrade", "pip")
17 | session.run("python", "-m", "pip", "install", "setuptools_scm[toml]>=6.3.1")
18 |
19 | if toolbar and wtf:
20 | extra = "wtf,toolbar,"
21 | elif toolbar:
22 | extra = "toolbar,"
23 | elif wtf:
24 | extra = "wtf,"
25 | else:
26 | extra = ""
27 |
28 | if flask == "==1.1.4":
29 | session.install(
30 | f"Flask{flask}",
31 | f"mongoengine{mongoengine}",
32 | "-e",
33 | f".[{extra}legacy,legacy-dev]",
34 | )
35 | else:
36 | session.install(
37 | f"Flask{flask}",
38 | f"mongoengine{mongoengine}",
39 | "-e",
40 | f".[{extra}dev]",
41 | )
42 | return session
43 |
44 |
45 | @nox.session(python="3.7")
46 | def lint(session):
47 | """Run linting check locally."""
48 | session.install("pre-commit")
49 | session.run("pre-commit", "run", "-a")
50 |
51 |
52 | @nox.session(python=["3.7", "3.8", "3.9", "3.10", "pypy3.7"])
53 | @nox.parametrize("flask", ["==1.1.4", "==2.0.3", ">=2.1.2"])
54 | @nox.parametrize("mongoengine", ["==0.21.0", "==0.22.1", "==0.23.1", ">=0.24.1"])
55 | @nox.parametrize("toolbar", [True, False])
56 | @nox.parametrize("wtf", [True, False])
57 | def ci_cd_tests(session, flask, mongoengine, toolbar, wtf):
58 | """Run test suite with pytest into ci_cd (no docker)."""
59 | session = base_install(session, flask, mongoengine, toolbar, wtf)
60 | session.run("pytest", *session.posargs)
61 |
62 |
63 | def _run_in_docker(session):
64 | session.run(
65 | "docker",
66 | "run",
67 | "--name",
68 | "nox_docker_test",
69 | "-p",
70 | "27017:27017",
71 | "-d",
72 | f"mongo:{db_version}",
73 | external=True,
74 | )
75 | try:
76 | session.run("pytest", *session.posargs)
77 | finally:
78 | session.run_always("docker", "rm", "-fv", "nox_docker_test", external=True)
79 |
80 |
81 | @nox.session(python=["3.7", "3.8", "3.9", "3.10", "pypy3.7"])
82 | @nox.parametrize("flask", ["==1.1.4", "==2.0.3", ">=2.1.2"])
83 | @nox.parametrize("mongoengine", ["==0.21.0", "==0.22.1", "==0.23.1", ">=0.24.1"])
84 | @nox.parametrize("toolbar", [True, False])
85 | @nox.parametrize("wtf", [True, False])
86 | def full_tests(session, flask, mongoengine, toolbar, wtf):
87 | """Run tests locally with docker and complete support matrix."""
88 | session = base_install(session, flask, mongoengine, toolbar, wtf)
89 | _run_in_docker(session)
90 |
91 |
92 | @nox.session(python=["3.7", "3.8", "3.9", "3.10", "pypy3.7"])
93 | @nox.parametrize("toolbar", [True, False])
94 | @nox.parametrize("wtf", [True, False])
95 | def latest(session, toolbar, wtf):
96 | """Run minimum tests for checking minimum code quality."""
97 | flask = ">=2.1.2"
98 | mongoengine = ">=0.24.1"
99 | session = base_install(session, flask, mongoengine, toolbar, wtf)
100 | if session.interactive:
101 | _run_in_docker(session)
102 | else:
103 | session.run("pytest", *session.posargs)
104 |
105 |
106 | @nox.session(python="3.10")
107 | def documentation_tests(session):
108 | """Run documentation tests."""
109 | return docs(session, batch_run=True)
110 |
111 |
112 | @nox.session(python="3.10")
113 | def docs(session, batch_run: bool = False):
114 | """Build the documentation or serve documentation interactively."""
115 | shutil.rmtree(Path("docs").joinpath("_build"), ignore_errors=True)
116 | session.install("-r", "docs/requirements.txt")
117 | session.install("-e", ".[wtf,toolbar]")
118 | session.cd("docs")
119 | sphinx_args = ["-b", "html", "-W", ".", "_build/html"]
120 |
121 | if not session.interactive or batch_run:
122 | sphinx_cmd = "sphinx-build"
123 | else:
124 | sphinx_cmd = "sphinx-autobuild"
125 | sphinx_args.extend(
126 | [
127 | "--open-browser",
128 | "--port",
129 | "9812",
130 | "--watch",
131 | "../*.md",
132 | "--watch",
133 | "../*.rst",
134 | "--watch",
135 | "../*.py",
136 | "--watch",
137 | "../flask_mongoengine",
138 | ]
139 | )
140 |
141 | session.run(sphinx_cmd, *sphinx_args)
142 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "flask-mongoengine"
3 | description = "Flask extension that provides integration with MongoEngine and WTF model forms."
4 | readme = "README.md"
5 | requires-python = ">=3.7"
6 | license = {text = "BSD 3-Clause License"}
7 | classifiers = [
8 | "Development Status :: 4 - Beta",
9 | "Environment :: Web Environment",
10 | "Intended Audience :: Developers",
11 | "License :: OSI Approved :: BSD License",
12 | "Operating System :: OS Independent",
13 | "Programming Language :: Python",
14 | "Programming Language :: Python :: 3 :: Only",
15 | "Programming Language :: Python :: 3",
16 | "Programming Language :: Python :: 3.7",
17 | "Programming Language :: Python :: 3.8",
18 | "Programming Language :: Python :: 3.9",
19 | "Programming Language :: Python :: 3.10",
20 | "Programming Language :: Python :: Implementation :: PyPy",
21 | "Programming Language :: Python :: Implementation :: CPython",
22 | "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
23 | "Topic :: Software Development :: Libraries :: Python Modules",
24 | "Framework :: Flask",
25 | ]
26 | dependencies = [
27 | "Flask>=1.1.4",
28 | "mongoengine>=0.21",
29 | 'importlib-metadata; python_version<"3.8"',
30 | ]
31 | keywords = [
32 | "flask",
33 | "wtf",
34 | "wtf-forms",
35 | "forms",
36 | "mongo",
37 | "pymongo",
38 | "mongoengine",
39 | "extension"
40 | ]
41 | authors = [
42 | {name = "Ross Lawley", email = "ross.lawley@gmail.com"}
43 | ]
44 | maintainers = [
45 | {name = "Andrey Shpak", email = "ashpak@ashpak.ru"}
46 | ]
47 | dynamic = ["version"]
48 |
49 | [project.optional-dependencies]
50 | wtf = ["WTForms[email]>=3.0.0", "Flask-WTF>=0.14.3"]
51 | toolbar = ["Flask-DebugToolbar>=0.11.0"]
52 | dev = [
53 | "black==22.6.0",
54 | "pre-commit",
55 | "pytest",
56 | "pytest-cov",
57 | "pytest-mock",
58 | "nox",
59 | "Pillow>=7.0.0",
60 | "blinker",
61 | ]
62 | legacy = ["MarkupSafe==2.0.1"]
63 | legacy-dev = [
64 | "pytest",
65 | "pytest-cov",
66 | "pytest-mock",
67 | "Pillow>=7.0.0",
68 | "blinker",
69 | ]
70 |
71 | [project.urls]
72 | Homepage = "https://github.com/MongoEngine/flask-mongoengine"
73 | Documentation = "http://docs.mongoengine.org/projects/flask-mongoengine/en/latest/"
74 | Repository = "https://github.com/MongoEngine/flask-mongoengine"
75 | Changelog = "https://github.com/MongoEngine/flask-mongoengine/releases"
76 |
77 | [build-system]
78 | requires = [
79 | "setuptools>=45",
80 | "setuptools_scm[toml]>=6.3.1",
81 | "wheel"
82 | ]
83 | build-backend = "setuptools.build_meta"
84 |
85 | [tool.setuptools]
86 | zip-safe = false
87 | platforms = ["any"]
88 | packages=["flask_mongoengine", "flask_mongoengine.wtf"]
89 |
90 | [tool.setuptools.dynamic]
91 | version = {attr = "flask_mongoengine._version.version"}
92 |
93 | [tool.setuptools_scm]
94 | write_to = "flask_mongoengine/_version.py"
95 |
96 | [tool.black]
97 | line-length = 88
98 | target-version = ['py37']
99 | exclude = '''
100 | /(
101 | \.eggs
102 | | \.git
103 | | \.tox
104 | | \.venv
105 | | \.vscode
106 | | docs
107 | | _build
108 | | buck-out
109 | | build
110 | | dist
111 | )/
112 | '''
113 |
114 | [tool.isort]
115 | profile = "black"
116 | line_length = 88
117 | multi_line_output = 3
118 | include_trailing_comma = true
119 | force_grid_wrap = 0
120 | use_parentheses = true
121 |
122 | [tool.pytest.ini_options]
123 | addopts = "--cov=flask_mongoengine --cov-config=setup.cfg"
124 | testpaths = ["tests"]
125 | filterwarnings = [
126 | "error",
127 | "ignore::ResourceWarning",
128 | "ignore::DeprecationWarning:flask_mongoengine",
129 | "ignore::DeprecationWarning:tests",
130 | ]
131 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [flake8]
2 | ignore=E501,F403,F405,I201,W503,E203
3 | max-line-length=90
4 | exclude=build,dist,docs,examples,venv,.tox,.eggs,.nox
5 | max-complexity=17
6 |
7 | [report]
8 | sort = Cover
9 | # Regexes for lines to exclude from consideration
10 | exclude_lines =
11 | # Have to re-enable the standard pragma
12 | pragma: no cover
13 |
14 | # Don't complain about missing debug-only code:
15 | def __repr__
16 | def __str__
17 | if self\.debug
18 | if settings\.DEBUG:
19 |
20 | # Don't complain if tests don't hit defensive assertion code:
21 | raise AssertionError
22 | raise NotImplementedError
23 |
24 | # Don't complain if non-runnable code isn't run:
25 | if 0:
26 | if __name__ == .__main__.:
27 |
28 | ignore_errors = True
29 | show_missing = True
30 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | """Setup file for backward compatibility with setuptools, not supported PEP 660."""
2 | from setuptools import setup
3 |
4 | setup()
5 |
--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/flask-mongoengine/d4526139cb1e2e94111ab7de96bb629d574c1690/tests/__init__.py
--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime
2 | from typing import NoReturn
3 |
4 | import mongoengine
5 | import pytest
6 | from flask import Flask
7 | from pymongo import MongoClient
8 |
9 | from flask_mongoengine import MongoEngine
10 |
11 |
12 | @pytest.fixture(autouse=True, scope="session")
13 | def session_clean_up() -> NoReturn:
14 | """Mandatory tests environment clean up before/after test session."""
15 | client = MongoClient("localhost", 27017)
16 | client.drop_database("flask_mongoengine_test_db")
17 | client.drop_database("flask_mongoengine_test_db_1")
18 | client.drop_database("flask_mongoengine_test_db_2")
19 |
20 | yield
21 |
22 | client.drop_database("flask_mongoengine_test_db")
23 | client.drop_database("flask_mongoengine_test_db_1")
24 | client.drop_database("flask_mongoengine_test_db_2")
25 |
26 |
27 | @pytest.fixture()
28 | def app() -> Flask:
29 | app = Flask(__name__)
30 | app.config["TESTING"] = True
31 | app.config["WTF_CSRF_ENABLED"] = False
32 |
33 | with app.app_context():
34 | yield app
35 |
36 | mongoengine.connection.disconnect_all()
37 |
38 |
39 | @pytest.fixture()
40 | def db(app) -> MongoEngine:
41 | app.config["MONGODB_SETTINGS"] = [
42 | {
43 | "db": "flask_mongoengine_test_db",
44 | "host": "localhost",
45 | "port": 27017,
46 | "alias": "default",
47 | "uuidRepresentation": "standard",
48 | }
49 | ]
50 | test_db = MongoEngine(app)
51 | db_name = (
52 | test_db.connection["default"].get_database("flask_mongoengine_test_db").name
53 | )
54 |
55 | if not db_name.endswith("_test_db"):
56 | raise RuntimeError(
57 | f"DATABASE_URL must point to testing db, not to master db ({db_name})"
58 | )
59 |
60 | # Clear database before tests, for cases when some test failed before.
61 | test_db.connection["default"].drop_database(db_name)
62 |
63 | yield test_db
64 |
65 | # Clear database after tests, for graceful exit.
66 | test_db.connection["default"].drop_database(db_name)
67 |
68 |
69 | @pytest.fixture()
70 | def todo(db):
71 | class Todo(db.Document):
72 | title = mongoengine.StringField(max_length=60)
73 | text = mongoengine.StringField()
74 | done = mongoengine.BooleanField(default=False)
75 | pub_date = mongoengine.DateTimeField(default=datetime.utcnow)
76 | comments = mongoengine.ListField(mongoengine.StringField())
77 | comment_count = mongoengine.IntField()
78 |
79 | return Todo
80 |
--------------------------------------------------------------------------------
/tests/test_base.py:
--------------------------------------------------------------------------------
1 | """Tests for base MongoEngine class."""
2 | import pytest
3 |
4 | from flask_mongoengine import MongoEngine
5 |
6 |
7 | def test_mongoengine_class__should_raise_type_error__if_config_not_dict():
8 | """MongoEngine will handle None values, but will pass anything else as app."""
9 | input_value = "Not dict type"
10 | with pytest.raises(TypeError) as error:
11 | MongoEngine(input_value)
12 | assert str(error.value) == "Invalid Flask application instance"
13 |
14 |
15 | @pytest.mark.parametrize("input_value", [None, "Not dict type"])
16 | def test_init_app__should_raise_type_error__if_config_not_dict(input_value):
17 | db = MongoEngine()
18 | with pytest.raises(TypeError) as error:
19 | db.init_app(input_value)
20 | assert str(error.value) == "Invalid Flask application instance"
21 |
--------------------------------------------------------------------------------
/tests/test_basic_app.py:
--------------------------------------------------------------------------------
1 | import flask
2 | import pytest
3 | from bson import ObjectId
4 |
5 |
6 | @pytest.fixture(autouse=True)
7 | def setup_endpoints(app, todo):
8 | Todo = todo
9 |
10 | @app.route("/")
11 | def index():
12 | return "\n".join(x.title for x in Todo.objects)
13 |
14 | @app.route("/add", methods=["POST"])
15 | def add():
16 | form = flask.request.form
17 | todo = Todo(title=form["title"], text=form["text"])
18 | todo.save()
19 | return "added"
20 |
21 | @app.route("/show//")
22 | def show(id):
23 | todo = Todo.objects.get_or_404(id=id)
24 | return "\n".join([todo.title, todo.text])
25 |
26 |
27 | def test_with_id(app, todo):
28 | Todo = todo
29 | client = app.test_client()
30 | response = client.get(f"/show/{ObjectId()}/")
31 | assert response.status_code == 404
32 |
33 | client.post("/add", data={"title": "First Item", "text": "The text"})
34 |
35 | response = client.get(f"/show/{Todo.objects.first_or_404().id}/")
36 | assert response.status_code == 200
37 | assert response.data.decode("utf-8") == "First Item\nThe text"
38 |
39 |
40 | def test_basic_insert(app):
41 | client = app.test_client()
42 | client.post("/add", data={"title": "First Item", "text": "The text"})
43 | client.post("/add", data={"title": "2nd Item", "text": "The text"})
44 | response = client.get("/")
45 | assert response.data.decode("utf-8") == "First Item\n2nd Item"
46 |
--------------------------------------------------------------------------------
/tests/test_connection.py:
--------------------------------------------------------------------------------
1 | import mongoengine
2 | import pytest
3 | from mongoengine.connection import ConnectionFailure
4 | from mongoengine.context_managers import switch_db
5 | from pymongo.database import Database
6 | from pymongo.errors import InvalidURI
7 | from pymongo.mongo_client import MongoClient
8 | from pymongo.read_preferences import ReadPreference
9 |
10 | from flask_mongoengine import MongoEngine, current_mongoengine_instance
11 |
12 |
13 | def is_mongo_mock_installed() -> bool:
14 | try:
15 | import mongomock.__version__ # noqa
16 | except ImportError:
17 | return False
18 | return True
19 |
20 |
21 | def test_connection__should_use_defaults__if_no_settings_provided(app):
22 | """Make sure a simple connection to a standalone MongoDB works."""
23 | db = MongoEngine()
24 |
25 | # Verify no extension for Mongoengine yet created for app
26 | assert app.extensions == {}
27 | assert current_mongoengine_instance() is None
28 |
29 | # Create db connection. Should return None.
30 | assert db.init_app(app) is None
31 |
32 | # Verify db added to Flask extensions.
33 | assert current_mongoengine_instance() == db
34 |
35 | # Verify db settings passed to pymongo driver.
36 | # Default mongoengine db is 'default', default Flask-Mongoengine db is 'test'.
37 | connection = mongoengine.get_connection()
38 | mongo_engine_db = mongoengine.get_db()
39 | assert isinstance(mongo_engine_db, Database)
40 | assert isinstance(connection, MongoClient)
41 | assert mongo_engine_db.name == "test"
42 | assert connection.HOST == "localhost"
43 | assert connection.PORT == 27017
44 |
45 |
46 | @pytest.mark.parametrize(
47 | ("config_extension"),
48 | [
49 | {
50 | "MONGODB_SETTINGS": {
51 | "ALIAS": "simple_conn",
52 | "HOST": "localhost",
53 | "PORT": 27017,
54 | "DB": "flask_mongoengine_test_db",
55 | }
56 | },
57 | {
58 | "MONGODB_HOST": "localhost",
59 | "MONGODB_PORT": 27017,
60 | "MONGODB_DB": "flask_mongoengine_test_db",
61 | "MONGODB_ALIAS": "simple_conn",
62 | },
63 | ],
64 | ids=("Dict format", "Config variable format"),
65 | )
66 | def test_connection__should_pass_alias__if_provided(app, config_extension):
67 | """Make sure a simple connection pass ALIAS setting variable."""
68 | db = MongoEngine()
69 | app.config.update(config_extension)
70 |
71 | # Verify no extension for Mongoengine yet created for app
72 | assert app.extensions == {}
73 | assert current_mongoengine_instance() is None
74 |
75 | # Create db connection. Should return None.
76 | assert db.init_app(app) is None
77 |
78 | # Verify db added to Flask extensions.
79 | assert current_mongoengine_instance() == db
80 |
81 | # Verify db settings passed to pymongo driver.
82 | # ALIAS is used to find correct connection.
83 | # As we do not use default alias, default call to mongoengine.get_connection
84 | # should raise.
85 | with pytest.raises(ConnectionFailure):
86 | mongoengine.get_connection()
87 |
88 | connection = mongoengine.get_connection("simple_conn")
89 | mongo_engine_db = mongoengine.get_db("simple_conn")
90 | assert isinstance(mongo_engine_db, Database)
91 | assert isinstance(connection, MongoClient)
92 | assert mongo_engine_db.name == "flask_mongoengine_test_db"
93 | assert connection.HOST == "localhost"
94 | assert connection.PORT == 27017
95 |
96 |
97 | @pytest.mark.parametrize(
98 | ("config_extension"),
99 | [
100 | {
101 | "MONGODB_SETTINGS": {
102 | "HOST": "mongodb://localhost:27017/flask_mongoengine_test_db"
103 | }
104 | },
105 | {
106 | "MONGODB_HOST": "mongodb://localhost:27017/flask_mongoengine_test_db",
107 | "MONGODB_PORT": 27017,
108 | "MONGODB_DB": "should_ignore_it",
109 | },
110 | ],
111 | ids=("Dict format", "Config variable format"),
112 | )
113 | def test_connection__should_parse_host_uri__if_host_formatted_as_uri(
114 | app, config_extension
115 | ):
116 | """Make sure a simple connection pass ALIAS setting variable."""
117 | db = MongoEngine()
118 | app.config.update(config_extension)
119 |
120 | # Verify no extension for Mongoengine yet created for app
121 | assert app.extensions == {}
122 | assert current_mongoengine_instance() is None
123 |
124 | # Create db connection. Should return None.
125 | assert db.init_app(app) is None
126 |
127 | # Verify db added to Flask extensions.
128 | assert current_mongoengine_instance() == db
129 |
130 | connection = mongoengine.get_connection()
131 | mongo_engine_db = mongoengine.get_db()
132 | assert isinstance(mongo_engine_db, Database)
133 | assert isinstance(connection, MongoClient)
134 | assert mongo_engine_db.name == "flask_mongoengine_test_db"
135 | assert connection.HOST == "localhost"
136 | assert connection.PORT == 27017
137 |
138 |
139 | @pytest.mark.skipif(
140 | is_mongo_mock_installed(), reason="This test require mongomock not exist"
141 | )
142 | @pytest.mark.parametrize(
143 | ("config_extension"),
144 | [
145 | {
146 | "MONGODB_SETTINGS": {
147 | "HOST": "mongomock://localhost:27017/flask_mongoengine_test_db"
148 | }
149 | },
150 | {
151 | "MONGODB_SETTINGS": {
152 | "ALIAS": "simple_conn",
153 | "HOST": "localhost",
154 | "PORT": 27017,
155 | "DB": "flask_mongoengine_test_db",
156 | "IS_MOCK": True,
157 | }
158 | },
159 | {"MONGODB_HOST": "mongomock://localhost:27017/flask_mongoengine_test_db"},
160 | ],
161 | ids=("Dict format as URI", "Dict format as Param", "Config variable format as URI"),
162 | )
163 | def test_connection__should_parse_mongo_mock_uri__as_uri_and_as_settings(
164 | app, config_extension
165 | ):
166 | """Make sure a simple connection pass ALIAS setting variable."""
167 | db = MongoEngine()
168 | app.config.update(config_extension)
169 |
170 | # Verify no extension for Mongoengine yet created for app
171 | assert app.extensions == {}
172 | assert current_mongoengine_instance() is None
173 |
174 | # Create db connection. Should return None.
175 |
176 | with pytest.raises(RuntimeError) as error:
177 | assert db.init_app(app) is None
178 |
179 | assert str(error.value) == "You need mongomock installed to mock MongoEngine."
180 |
181 |
182 | @pytest.mark.parametrize(
183 | ("config_extension"),
184 | [
185 | {
186 | "MONGODB_SETTINGS": {
187 | "HOST": "postgre://localhost:27017/flask_mongoengine_test_db"
188 | }
189 | },
190 | {"MONGODB_HOST": "mysql://localhost:27017/flask_mongoengine_test_db"},
191 | ],
192 | ids=("Dict format as URI", "Config variable format as URI"),
193 | )
194 | def test_connection__should_raise__if_uri_not_properly_formatted(app, config_extension):
195 | """Make sure a simple connection pass ALIAS setting variable."""
196 | db = MongoEngine()
197 | app.config.update(config_extension)
198 |
199 | # Verify no extension for Mongoengine yet created for app
200 | assert app.extensions == {}
201 | assert current_mongoengine_instance() is None
202 |
203 | # Create db connection. Should return None.
204 |
205 | with pytest.raises(InvalidURI) as error:
206 | assert db.init_app(app) is None
207 |
208 | assert (
209 | str(error.value)
210 | == "Invalid URI scheme: URI must begin with 'mongodb://' or 'mongodb+srv://'"
211 | )
212 |
213 |
214 | def test_connection__should_accept_host_as_list(app):
215 | """Make sure MONGODB_HOST can be a list hosts."""
216 | db = MongoEngine()
217 | app.config["MONGODB_SETTINGS"] = {
218 | "ALIAS": "host_list",
219 | "HOST": ["localhost:27017"],
220 | "DB": "flask_mongoengine_list_test_db",
221 | }
222 | db.init_app(app)
223 |
224 | connection = mongoengine.get_connection("host_list")
225 | mongo_engine_db = mongoengine.get_db("host_list")
226 | assert isinstance(mongo_engine_db, Database)
227 | assert isinstance(connection, MongoClient)
228 | assert mongo_engine_db.name == "flask_mongoengine_list_test_db"
229 | assert connection.HOST == "localhost"
230 | assert connection.PORT == 27017
231 |
232 |
233 | def test_multiple_connections(app):
234 | """Make sure establishing multiple connections to a standalone
235 | MongoDB and switching between them works.
236 | """
237 | db = MongoEngine()
238 | app.config["MONGODB_SETTINGS"] = [
239 | {
240 | "ALIAS": "default",
241 | "DB": "flask_mongoengine_test_db_1",
242 | "HOST": "localhost",
243 | "PORT": 27017,
244 | },
245 | {
246 | "ALIAS": "alternative",
247 | "DB": "flask_mongoengine_test_db_2",
248 | "HOST": "localhost",
249 | "PORT": 27017,
250 | },
251 | ]
252 |
253 | class Todo(db.Document):
254 | title = db.StringField(max_length=60)
255 |
256 | db.init_app(app)
257 | # Drop default collection from init
258 | Todo.drop_collection()
259 | Todo.meta = {"db_alias": "alternative"}
260 | # Drop 'alternative' collection initiated early.
261 | Todo.drop_collection()
262 |
263 | # Make sure init correct and both databases are clean
264 | with switch_db(Todo, "default") as Todo:
265 | doc = Todo.objects().first()
266 | assert doc is None
267 |
268 | with switch_db(Todo, "alternative") as Todo:
269 | doc = Todo.objects().first()
270 | assert doc is None
271 |
272 | # Test saving a doc via the default connection
273 | with switch_db(Todo, "default") as Todo:
274 | todo = Todo()
275 | todo.text = "Sample"
276 | todo.title = "Testing"
277 | todo.done = True
278 | s_todo = todo.save()
279 |
280 | f_to = Todo.objects().first()
281 | assert s_todo.title == f_to.title
282 |
283 | # Make sure the doc still doesn't exist in the alternative db
284 | with switch_db(Todo, "alternative") as Todo:
285 | doc = Todo.objects().first()
286 | assert doc is None
287 |
288 | # Make sure switching back to the default connection shows the doc
289 | with switch_db(Todo, "default") as Todo:
290 | doc = Todo.objects().first()
291 | assert doc is not None
292 |
293 |
294 | def test_incorrect_value_with_mongodb_prefix__should_trigger_mongoengine_raise(app):
295 | db = MongoEngine()
296 | app.config["MONGODB_HOST"] = "mongodb://localhost:27017/flask_mongoengine_test_db"
297 | # Invalid host, should trigger exception if used
298 | app.config["MONGODB_TEST_HOST"] = "dummy://localhost:27017/test"
299 | with pytest.raises(ConnectionFailure):
300 | db.init_app(app)
301 |
302 |
303 | def test_connection_kwargs(app):
304 | """Make sure additional connection kwargs work."""
305 |
306 | app.config["MONGODB_SETTINGS"] = {
307 | "ALIAS": "tz_aware_true",
308 | "DB": "flask_mongoengine_test_db",
309 | "TZ_AWARE": True,
310 | "READ_PREFERENCE": ReadPreference.SECONDARY,
311 | "MAXPOOLSIZE": 10,
312 | }
313 | db = MongoEngine(app)
314 |
315 | assert db.connection["tz_aware_true"].codec_options.tz_aware
316 | assert db.connection["tz_aware_true"].read_preference == ReadPreference.SECONDARY
317 |
--------------------------------------------------------------------------------
/tests/test_db_fields_import_protection.py:
--------------------------------------------------------------------------------
1 | """Testing independency from WTForms."""
2 | import pytest
3 |
4 | try:
5 | import wtforms
6 |
7 | wtforms_not_installed = False
8 | except ImportError:
9 | wtforms = None
10 | wtforms_not_installed = True
11 |
12 |
13 | class TestImportProtection:
14 | def test__when_wtforms_available__import_use_its_data(self):
15 | from flask_mongoengine import db_fields
16 |
17 | assert db_fields is not None
18 |
19 | def test__core_class_imported_without_error(self):
20 | from flask_mongoengine import MongoEngine
21 |
22 | db = MongoEngine()
23 | assert db is not None
24 |
25 | @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
26 | def test__wtf_required_decorator__when_wtf_installed(self):
27 | from flask_mongoengine.decorators import wtf_required
28 |
29 | @wtf_required
30 | def foo(a, b=None):
31 | """Temp function."""
32 | return a + b
33 |
34 | assert foo(1, 1) == 2
35 |
36 | def test__wtf_required_decorator__when_wtf_not_installed(self, caplog, monkeypatch):
37 | monkeypatch.setattr("flask_mongoengine.decorators.wtf_installed", False)
38 | from flask_mongoengine.decorators import wtf_required
39 |
40 | @wtf_required
41 | def foo(a, b=None):
42 | """Temp function."""
43 | return a + b
44 |
45 | x = foo(1, 1)
46 | assert x is None
47 | assert caplog.messages[0] == "WTForms not installed. Function 'foo' aborted."
48 |
--------------------------------------------------------------------------------
/tests/test_debug_panel.py:
--------------------------------------------------------------------------------
1 | """
2 | Tests for ``MongoDebugPanel`` and related mongo events listener.
3 |
4 | - Independent of global configuration by design.
5 | """
6 | import contextlib
7 |
8 | import jinja2
9 | import pymongo
10 | import pytest
11 | from flask import Flask
12 |
13 | flask_debugtoolbar = pytest.importorskip("flask_debugtoolbar")
14 |
15 | from flask_debugtoolbar import DebugToolbarExtension # noqa
16 | from flask_debugtoolbar.panels import DebugPanel # noqa
17 | from jinja2 import ChoiceLoader, DictLoader # noqa
18 | from pymongo import monitoring # noqa
19 | from pymongo.errors import OperationFailure # noqa
20 | from pytest_mock import MockerFixture # noqa
21 |
22 | from flask_mongoengine.panels import ( # noqa
23 | MongoCommandLogger,
24 | MongoDebugPanel,
25 | _maybe_patch_jinja_loader,
26 | mongo_command_logger,
27 | )
28 |
29 |
30 | @pytest.fixture()
31 | def app_no_mongo_monitoring() -> Flask:
32 | app = Flask(__name__)
33 | app.config["TESTING"] = True
34 | app.config["WTF_CSRF_ENABLED"] = False
35 | app.config["SECRET_KEY"] = "flask+mongoengine=<3"
36 | app.debug = True
37 | app.config["DEBUG_TB_PANELS"] = ("flask_mongoengine.panels.MongoDebugPanel",)
38 | app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
39 | DebugToolbarExtension(app)
40 | with app.app_context():
41 | yield app
42 |
43 |
44 | @pytest.fixture(autouse=True)
45 | def registered_monitoring() -> MongoCommandLogger:
46 | """Register/Unregister mongo_command_logger in required tests"""
47 | monitoring.register(mongo_command_logger)
48 | mongo_command_logger.reset_tracker()
49 | yield mongo_command_logger
50 | # Unregister listener between independent tests
51 | mongo_command_logger.reset_tracker()
52 | with contextlib.suppress(ValueError):
53 | monitoring._LISTENERS.command_listeners.remove(mongo_command_logger)
54 |
55 |
56 | def test__maybe_patch_jinja_loader__replace_loader_when_initial_loader_is_not_choice_loader():
57 | jinja2_env = jinja2.Environment()
58 | assert not isinstance(jinja2_env.loader, ChoiceLoader)
59 | _maybe_patch_jinja_loader(jinja2_env)
60 | assert isinstance(jinja2_env.loader, ChoiceLoader)
61 |
62 |
63 | def test__maybe_patch_jinja_loader__extend_loader_when_initial_loader_is_choice_loader():
64 | jinja2_env = jinja2.Environment(loader=ChoiceLoader([DictLoader({"1": "1"})]))
65 | assert isinstance(jinja2_env.loader, ChoiceLoader)
66 | assert len(jinja2_env.loader.loaders) == 1
67 | _maybe_patch_jinja_loader(jinja2_env)
68 | assert len(jinja2_env.loader.loaders) == 2
69 |
70 |
71 | class TestMongoDebugPanel:
72 | """Trivial tests to highlight any unexpected changes in namings or code."""
73 |
74 | @pytest.fixture
75 | def toolbar_with_no_flask(self) -> MongoDebugPanel:
76 | """Simple instance of MongoDebugPanel without flask application"""
77 | jinja2_env = jinja2.Environment()
78 | return MongoDebugPanel(jinja2_env)
79 |
80 | def test__panel_name_and_static_properties_not_modified(
81 | self, toolbar_with_no_flask
82 | ):
83 | assert toolbar_with_no_flask.name == "MongoDB"
84 | assert toolbar_with_no_flask.title() == "MongoDB Operations"
85 | assert toolbar_with_no_flask.nav_title() == "MongoDB"
86 | assert toolbar_with_no_flask.url() == ""
87 |
88 | def test__config_error_message_not_modified(self, toolbar_with_no_flask):
89 | assert toolbar_with_no_flask.config_error_message == (
90 | "Pymongo monitoring configuration error. mongo_command_logger should be "
91 | "registered before database connection."
92 | )
93 |
94 | def test__is_properly_configured__return_false__when_mongo_command_logger__not_registered(
95 | self, toolbar_with_no_flask, caplog
96 | ):
97 | """Also verify logging done."""
98 | # Emulate not working state(against auto used registered_monitoring fixture)
99 | mongo_command_logger.reset_tracker()
100 | monitoring._LISTENERS.command_listeners.remove(mongo_command_logger)
101 | assert toolbar_with_no_flask.is_properly_configured is False
102 | assert caplog.messages[0] == toolbar_with_no_flask.config_error_message
103 |
104 | def test__is_properly_configured__return_true__when_mongo_command_logger_registered(
105 | self,
106 | toolbar_with_no_flask,
107 | ):
108 | assert toolbar_with_no_flask.is_properly_configured is True
109 |
110 | def test__nav_subtitle__return_config_error_message__when_toolbar_incorrectly_configured(
111 | self, toolbar_with_no_flask
112 | ):
113 | """Also check that content flag changed."""
114 | # Emulate not working state(against auto used registered_monitoring fixture)
115 | mongo_command_logger.reset_tracker()
116 | monitoring._LISTENERS.command_listeners.remove(mongo_command_logger)
117 | # First line is before nav_subtitle() call
118 | assert toolbar_with_no_flask.has_content is True
119 |
120 | assert (
121 | toolbar_with_no_flask.nav_subtitle()
122 | == toolbar_with_no_flask.config_error_message
123 | )
124 | assert toolbar_with_no_flask.has_content is False
125 |
126 | def test__nav_subtitle__return_correct_message_when_toolbar_correctly_configured(
127 | self,
128 | toolbar_with_no_flask,
129 | ):
130 | assert toolbar_with_no_flask.nav_subtitle() == "0 operations, in 0.00ms"
131 | assert toolbar_with_no_flask.has_content is True
132 |
133 | def test__context__is_empty_by_default(self, app, toolbar_with_no_flask):
134 | assert toolbar_with_no_flask._context == {
135 | "queries": [],
136 | "slow_query_limit": 100,
137 | }
138 |
139 | def test__process_request__correctly_resets_monitoring__without_instance_replace(
140 | self,
141 | registered_monitoring,
142 | app,
143 | toolbar_with_no_flask,
144 | ):
145 | # sourcery skip: simplify-empty-collection-comparison
146 | # Test setup
147 | initial_id = id(registered_monitoring)
148 | # Inject some fakes to monitoring engine
149 | registered_monitoring.total_time = 1
150 | registered_monitoring.started_operations_count = 1
151 | registered_monitoring.succeeded_operations_count = 1
152 | registered_monitoring.failed_operations_count = 1
153 | registered_monitoring.queries = [1, 2]
154 | registered_monitoring.started_events = {1: 1, 2: 2}
155 |
156 | # Pre-test validation
157 | assert registered_monitoring.total_time == 1
158 | assert registered_monitoring.started_operations_count == 1
159 | assert registered_monitoring.succeeded_operations_count == 1
160 | assert registered_monitoring.failed_operations_count == 1
161 | assert registered_monitoring.queries == [1, 2]
162 | assert registered_monitoring.started_events == {1: 1, 2: 2}
163 | toolbar_with_no_flask.process_request(None)
164 |
165 | assert id(registered_monitoring) == initial_id
166 | assert registered_monitoring.total_time == 0
167 | assert registered_monitoring.started_operations_count == 0
168 | assert registered_monitoring.succeeded_operations_count == 0
169 | assert registered_monitoring.failed_operations_count == 0
170 | assert registered_monitoring.queries == []
171 | assert registered_monitoring.started_events == {}
172 |
173 | def test__content__calls_parent__render__function(
174 | self,
175 | app,
176 | toolbar_with_no_flask,
177 | mocker: MockerFixture,
178 | ):
179 | spy = mocker.patch.object(DebugPanel, "render", autospec=True)
180 | toolbar_with_no_flask.content()
181 | spy.assert_called_with(
182 | toolbar_with_no_flask,
183 | "panels/mongo-panel.html",
184 | toolbar_with_no_flask._context,
185 | )
186 |
187 |
188 | class TestMongoCommandLogger:
189 | """By design tested with raw pymongo."""
190 |
191 | @pytest.fixture(autouse=True)
192 | def py_db(self, registered_monitoring) -> pymongo.MongoClient:
193 | """Clean up and returns special database for testing on pymongo driver level"""
194 | client = pymongo.MongoClient("localhost", 27017)
195 | db = client.pymongo_test_database
196 | client.drop_database(db)
197 | registered_monitoring.reset_tracker()
198 | yield db
199 | client.drop_database(db)
200 |
201 | def test__normal_command__logged(self, py_db, registered_monitoring):
202 | post = {
203 | "author": "Mike",
204 | "text": "My first blog post!",
205 | "tags": ["mongodb", "python", "pymongo"],
206 | }
207 |
208 | py_db.posts.insert_one(post)
209 | assert registered_monitoring.started_operations_count == 1
210 | assert registered_monitoring.succeeded_operations_count == 1
211 | assert registered_monitoring.queries[0].time >= 0
212 | assert registered_monitoring.queries[0].size >= 0
213 | assert registered_monitoring.queries[0].database == "pymongo_test_database"
214 | assert registered_monitoring.queries[0].collection == "posts"
215 | assert registered_monitoring.queries[0].command_name == "insert"
216 | assert isinstance(registered_monitoring.queries[0].operation_id, int)
217 | assert len(registered_monitoring.queries[0].server_command["documents"]) == 1
218 | assert registered_monitoring.queries[0].server_response == {"n": 1, "ok": 1.0}
219 | assert registered_monitoring.queries[0].request_status == "Succeed"
220 |
221 | def test__failed_command_logged__logged(self, py_db, registered_monitoring):
222 | """Failed command index 1 in provided test."""
223 | pymongo.collection.Collection(py_db, "test", create=True)
224 | with contextlib.suppress(OperationFailure):
225 | pymongo.collection.Collection(py_db, "test", create=True)
226 | assert registered_monitoring.started_operations_count == 2
227 | assert registered_monitoring.succeeded_operations_count == 1
228 | assert registered_monitoring.failed_operations_count == 1
229 | assert registered_monitoring.queries[0].time >= 0
230 | assert registered_monitoring.queries[0].size >= 0
231 | assert registered_monitoring.queries[0].database == "pymongo_test_database"
232 | assert registered_monitoring.queries[0].collection == "test"
233 | assert registered_monitoring.queries[0].command_name == "create"
234 | assert isinstance(registered_monitoring.queries[0].operation_id, int)
235 | assert registered_monitoring.queries[0].server_command["create"] == "test"
236 | assert registered_monitoring.queries[0].server_response == {"ok": 1.0}
237 | assert registered_monitoring.queries[0].request_status == "Succeed"
238 | assert registered_monitoring.queries[1].time >= 0
239 | assert registered_monitoring.queries[1].size >= 0
240 | assert registered_monitoring.queries[1].database == "pymongo_test_database"
241 | assert registered_monitoring.queries[1].collection == "test"
242 | assert registered_monitoring.queries[1].command_name == "create"
243 | assert isinstance(registered_monitoring.queries[1].operation_id, int)
244 | assert registered_monitoring.queries[1].server_command["create"] == "test"
245 | assert (
246 | "already exists"
247 | in registered_monitoring.queries[1].server_response["errmsg"]
248 | )
249 | assert registered_monitoring.queries[1].request_status == "Failed"
250 |
--------------------------------------------------------------------------------
/tests/test_decorators.py:
--------------------------------------------------------------------------------
1 | """Tests for project wide decorators."""
2 | from flask_mongoengine.decorators import orm_deprecated
3 |
4 |
5 | def test__orm_deprecated(recwarn):
6 | @orm_deprecated
7 | def func(a, b):
8 | """Function example."""
9 | return a + b
10 |
11 | assert func(1, 1) == 2
12 | assert str(recwarn.list[0].message) == (
13 | "ORM module and function 'func' are deprecated and will be removed in version 3.0.0. "
14 | "Please switch to form generation from full model nesting. "
15 | "Support and bugfixes are not available for stalled code. "
16 | "Please read: "
17 | )
18 |
--------------------------------------------------------------------------------
/tests/test_forms_v2.py:
--------------------------------------------------------------------------------
1 | """Integration tests for new WTForms generation in Flask-Mongoengine 2.0."""
2 | import json
3 |
4 | import pytest
5 | from bson.json_util import RELAXED_JSON_OPTIONS
6 | from markupsafe import Markup
7 | from werkzeug.datastructures import MultiDict
8 |
9 | wtforms = pytest.importorskip("wtforms")
10 | from wtforms import fields as wtf_fields # noqa
11 | from wtforms import widgets as wtf_widgets # noqa
12 |
13 | from flask_mongoengine.wtf import fields as mongo_fields # noqa
14 |
15 |
16 | @pytest.fixture()
17 | def local_app(app):
18 | """Helper fixture to minimize code indentation."""
19 | with app.test_request_context("/"):
20 | yield app
21 |
22 |
23 | @pytest.mark.parametrize(
24 | ["value", "expected_value"],
25 | [
26 | ("", None),
27 | ("none", None),
28 | ("nOne", None),
29 | ("None", None),
30 | ("null", None),
31 | (None, None),
32 | ("no", False),
33 | ("N", False),
34 | ("n", False),
35 | ("false", False),
36 | ("False", False),
37 | (False, False),
38 | ("yes", True),
39 | ("y", True),
40 | ("true", True),
41 | (True, True),
42 | ],
43 | )
44 | def test_coerce_boolean__return_correct_value(value, expected_value):
45 | assert mongo_fields.coerce_boolean(value) == expected_value
46 |
47 |
48 | def test_coerce_boolean__raise_on_unexpected_value():
49 | with pytest.raises(ValueError) as error:
50 | mongo_fields.coerce_boolean("some")
51 | assert str(error.value) == "Unexpected string value."
52 |
53 |
54 | def test__full_document_form__does_not_create_any_unexpected_data_in_database(db):
55 | """
56 | Test to ensure that we are following own promise in documentation, read:
57 | http://docs.mongoengine.org/projects/flask-mongoengine/en/latest/migration_to_v2.html#empty-fields-are-not-created-in-database
58 | """
59 |
60 | class Todo(db.Document):
61 | """Test model for AllFieldsModel."""
62 |
63 | string = db.StringField()
64 |
65 | class Embedded(db.EmbeddedDocument):
66 | """Test embedded for AllFieldsModel."""
67 |
68 | string = db.StringField()
69 |
70 | class AllFieldsModel(db.Document):
71 | """Meaningless Document with all field types."""
72 |
73 | binary_field = db.BinaryField()
74 | boolean_field = db.BooleanField()
75 | date_field = db.DateField()
76 | date_time_field = db.DateTimeField()
77 | decimal_field = db.DecimalField()
78 | dict_field = db.DictField()
79 | email_field = db.EmailField()
80 | embedded_document_field = db.EmbeddedDocumentField(document_type=Embedded)
81 | file_field = db.FileField()
82 | float_field = db.FloatField()
83 | int_field = db.IntField()
84 | list_field = db.ListField(field=db.StringField)
85 | reference_field = db.ReferenceField(document_type=Todo)
86 | sorted_list_field = db.SortedListField(field=db.StringField)
87 | string_field = db.StringField()
88 | url_field = db.URLField()
89 | cached_reference_field = db.CachedReferenceField(document_type=Todo)
90 | complex_date_time_field = db.ComplexDateTimeField()
91 | dynamic_field = db.DynamicField()
92 | embedded_document_list_field = db.EmbeddedDocumentListField(
93 | document_type=Embedded
94 | )
95 | enum_field = db.EnumField(enum=[1, 2])
96 | generic_embedded_document_field = db.GenericEmbeddedDocumentField()
97 | generic_lazy_reference_field = db.GenericLazyReferenceField()
98 | geo_json_base_field = db.GeoJsonBaseField()
99 | geo_point_field = db.GeoPointField()
100 | image_field = db.ImageField()
101 | lazy_reference_field = db.LazyReferenceField(document_type=Todo)
102 | line_string_field = db.LineStringField()
103 | long_field = db.LongField()
104 | map_field = db.MapField(field=db.StringField())
105 | multi_line_string_field = db.MultiLineStringField()
106 | multi_point_field = db.MultiPointField()
107 | multi_polygon_field = db.MultiPolygonField()
108 | point_field = db.PointField()
109 | polygon_field = db.PolygonField()
110 | sequence_field = db.SequenceField()
111 | uuid_field = db.UUIDField()
112 | generic_reference_field = db.GenericReferenceField(document_type=Todo)
113 | object_id_field = db.ObjectIdField()
114 |
115 | AllFieldsModelForm = AllFieldsModel.to_wtf_form()
116 | form = AllFieldsModelForm(
117 | MultiDict(
118 | {
119 | "binary_field": "",
120 | "boolean_field": "",
121 | "date_field": "",
122 | "date_time_field": "",
123 | "decimal_field": "",
124 | "dict_field": "",
125 | "email_field": "",
126 | "embedded_document_field": "",
127 | "file_field": "",
128 | "float_field": "",
129 | "int_field": "",
130 | "list_field": "",
131 | "reference_field": "",
132 | "sorted_list_field": "",
133 | "string_field": "",
134 | "url_field": "",
135 | "cached_reference_field": "",
136 | "complex_date_time_field": "",
137 | "dynamic_field": "",
138 | "embedded_document_list_field": "",
139 | "enum_field": "",
140 | "generic_embedded_document_field": "",
141 | "generic_lazy_reference_field": "",
142 | "geo_json_base_field": "",
143 | "geo_point_field": "",
144 | "image_field": "",
145 | "lazy_reference_field": "",
146 | "line_string_field": "",
147 | "long_field": "",
148 | "map_field": "",
149 | "multi_line_string_field": "",
150 | "multi_point_field": "",
151 | "multi_polygon_field": "",
152 | "point_field": "",
153 | "polygon_field": "",
154 | "sequence_field": "",
155 | "uuid_field": "",
156 | "generic_reference_field": "",
157 | "object_id_field": "",
158 | }
159 | )
160 | )
161 | assert form.validate()
162 | form.save()
163 |
164 | obj = AllFieldsModel.objects.get(id=form.instance.pk)
165 | object_dict = json.loads(obj.to_json(json_options=RELAXED_JSON_OPTIONS))
166 | object_dict.pop("_id")
167 |
168 | assert object_dict == {
169 | "dict_field": {},
170 | "list_field": [],
171 | "sorted_list_field": [],
172 | "embedded_document_list_field": [],
173 | "map_field": {},
174 | "sequence_field": 1,
175 | }
176 |
177 |
178 | class TestEmptyStringIsNoneMixin:
179 | """Special mixin to ignore empty strings **before** parent class processing."""
180 |
181 | class ParentClass:
182 | """MRO parent."""
183 |
184 | def __init__(self):
185 | self.data = True
186 |
187 | def process_formdata(self, valuelist):
188 | """Status changer"""
189 | assert valuelist != ""
190 | self.data = False
191 |
192 | class FakeClass(mongo_fields.EmptyStringIsNoneMixin, ParentClass):
193 | """Just MRO setter."""
194 |
195 | pass
196 |
197 | @pytest.mark.parametrize("value", ["", None, [], {}, (), "", ("",), [""]])
198 | def test__process_formdata__does_not_call_parent_method_if_value_is_empty(
199 | self, value
200 | ):
201 | obj = self.FakeClass()
202 | assert obj.data is True
203 | obj.process_formdata(value)
204 | assert obj.data is None
205 |
206 | @pytest.mark.parametrize("value", [[None], [1], (1,), (" ",), [" "]])
207 | def test__process_formdata__does_call_parent_method_if_value_is_not_empty(
208 | self, value
209 | ):
210 | obj = self.FakeClass()
211 | assert obj.data is True
212 | obj.process_formdata(value)
213 | assert obj.data is False
214 |
215 |
216 | class TestMongoDictField:
217 | def test_mongo_dict_field_mro_not_changed(self):
218 | field_mro = list(mongo_fields.MongoDictField.__mro__[:5])
219 | assert field_mro == [
220 | mongo_fields.MongoDictField,
221 | mongo_fields.MongoTextAreaField,
222 | mongo_fields.EmptyStringIsNoneMixin,
223 | wtf_fields.TextAreaField,
224 | wtf_fields.StringField,
225 | ]
226 |
227 | def test_mongo_dict_field_default_dict_in_form_object(self, db):
228 | class DefaultDictModel(db.Document):
229 | """Should populate form with {}."""
230 |
231 | dict_field = db.DictField()
232 |
233 | DefaultDictForm = DefaultDictModel.to_wtf_form()
234 |
235 | form = DefaultDictForm()
236 |
237 | assert str(form.dict_field) == Markup(
238 | ''
239 | )
240 | assert form.dict_field.data == {} # This is mongoengine default
241 | assert form.dict_field.null is False
242 |
243 | assert form.validate()
244 | form.save()
245 |
246 | obj = DefaultDictModel.objects.get(id=form.instance.pk)
247 | object_dict = json.loads(obj.to_json(json_options=RELAXED_JSON_OPTIONS))
248 | object_dict.pop("_id")
249 |
250 | assert object_dict == {"dict_field": {}}
251 |
252 | @pytest.mark.parametrize(
253 | ["null", "expected_obj"],
254 | [
255 | (True, {"placeholder_string": "1", "null_dict_field": None}),
256 | (False, {"placeholder_string": "1"}),
257 | ],
258 | )
259 | def test_mongo_dict_field_default_null_dict_in_form_object(
260 | self, db, null, expected_obj
261 | ):
262 | class DefaultDictModel(db.Document):
263 | """Should populate form with empty form."""
264 |
265 | placeholder_string = db.StringField(default="1")
266 | null_dict_field = db.DictField(default=None, null=null)
267 |
268 | DefaultDictForm = DefaultDictModel.to_wtf_form()
269 |
270 | form = DefaultDictForm()
271 |
272 | assert str(form.null_dict_field) == Markup(
273 | ''
274 | )
275 | assert form.null_dict_field.data is None
276 |
277 | assert form.validate()
278 | form.save()
279 |
280 | obj = DefaultDictModel.objects.get(id=form.instance.pk)
281 | object_dict = json.loads(obj.to_json(json_options=RELAXED_JSON_OPTIONS))
282 | object_dict.pop("_id")
283 |
284 | assert object_dict == expected_obj
285 |
286 | def test__parse_json_data__raise_error_when_input_is_incorrect_json(self, db):
287 | class DictModel(db.Document):
288 | """Should populate form with empty form."""
289 |
290 | dict_field = db.DictField()
291 |
292 | FormClass = DictModel.to_wtf_form()
293 | form = FormClass(MultiDict({"dict_field": "foobar"}))
294 | assert not form.validate()
295 | assert "Cannot load data" in form.errors["dict_field"][0]
296 |
297 | def test__ensure_data_is_dict__raise_error_when_input_is_a_list(self, db):
298 | class DictModel(db.Document):
299 | """Should populate form with empty form."""
300 |
301 | dict_field = db.DictField()
302 |
303 | FormClass = DictModel.to_wtf_form()
304 | form = FormClass(MultiDict({"dict_field": "[]"}))
305 | assert not form.validate()
306 | assert form.errors == {
307 | "dict_field": ["Not a valid dictionary (list input detected)."]
308 | }
309 |
310 |
311 | class TestMongoEmailField:
312 | def test_email_field_mro_not_changed(self):
313 | field_mro = list(mongo_fields.MongoEmailField.__mro__[:4])
314 | assert field_mro == [
315 | mongo_fields.MongoEmailField,
316 | mongo_fields.EmptyStringIsNoneMixin,
317 | wtf_fields.EmailField,
318 | wtf_fields.StringField,
319 | ]
320 |
321 |
322 | class TestMongoFloatField:
323 | def test_ensure_widget_not_accidentally_replaced(self):
324 | field = mongo_fields.MongoFloatField
325 | assert isinstance(field.widget, wtf_widgets.NumberInput)
326 |
327 |
328 | class TestMongoHiddenField:
329 | def test_hidden_field_mro_not_changed(self):
330 | field_mro = list(mongo_fields.MongoHiddenField.__mro__[:4])
331 | assert field_mro == [
332 | mongo_fields.MongoHiddenField,
333 | mongo_fields.EmptyStringIsNoneMixin,
334 | wtf_fields.HiddenField,
335 | wtf_fields.StringField,
336 | ]
337 |
338 |
339 | class TestMongoPasswordField:
340 | def test_password_field_mro_not_changed(self):
341 | field_mro = list(mongo_fields.MongoPasswordField.__mro__[:4])
342 | assert field_mro == [
343 | mongo_fields.MongoPasswordField,
344 | mongo_fields.EmptyStringIsNoneMixin,
345 | wtf_fields.PasswordField,
346 | wtf_fields.StringField,
347 | ]
348 |
349 |
350 | class TestMongoSearchField:
351 | def test_search_field_mro_not_changed(self):
352 | field_mro = list(mongo_fields.MongoSearchField.__mro__[:4])
353 | assert field_mro == [
354 | mongo_fields.MongoSearchField,
355 | mongo_fields.EmptyStringIsNoneMixin,
356 | wtf_fields.SearchField,
357 | wtf_fields.StringField,
358 | ]
359 |
360 |
361 | class TestMongoStringField:
362 | def test__parent__process_formdata__method_included_in_mro_chain(self, db, mocker):
363 | """Test to protect from accidental incorrect __init__ method overwrite."""
364 | base_init_spy = mocker.spy(wtf_fields.StringField, "process_formdata")
365 | mixin_init_spy = mocker.spy(
366 | mongo_fields.EmptyStringIsNoneMixin, "process_formdata"
367 | )
368 |
369 | class DocumentModel(db.Document):
370 | """Test DB model."""
371 |
372 | string_field = db.StringField()
373 |
374 | DocumentForm = DocumentModel.to_wtf_form()
375 | form = DocumentForm(formdata=MultiDict({"string_field": "1"}))
376 | assert form.validate()
377 | obj = form.save()
378 | mixin_init_spy.assert_called_once()
379 | base_init_spy.assert_called_once()
380 | assert obj.string_field == "1"
381 |
382 | def test_string_field_mro_not_changed(self):
383 | field_mro = list(mongo_fields.MongoStringField.__mro__[:3])
384 | assert field_mro == [
385 | mongo_fields.MongoStringField,
386 | mongo_fields.EmptyStringIsNoneMixin,
387 | wtf_fields.StringField,
388 | ]
389 |
390 |
391 | class TestMongoTelField:
392 | def test_tel_field_mro_not_changed(self):
393 | field_mro = list(mongo_fields.MongoTelField.__mro__[:4])
394 | assert field_mro == [
395 | mongo_fields.MongoTelField,
396 | mongo_fields.EmptyStringIsNoneMixin,
397 | wtf_fields.TelField,
398 | wtf_fields.StringField,
399 | ]
400 |
401 |
402 | class TestMongoTextAreaField:
403 | def test_text_area_field_mro_not_changed(self):
404 | field_mro = list(mongo_fields.MongoTextAreaField.__mro__[:4])
405 | assert field_mro == [
406 | mongo_fields.MongoTextAreaField,
407 | mongo_fields.EmptyStringIsNoneMixin,
408 | wtf_fields.TextAreaField,
409 | wtf_fields.StringField,
410 | ]
411 |
412 |
413 | class TestMongoURLField:
414 | def test_url_field_mro_not_changed(self):
415 | field_mro = list(mongo_fields.MongoURLField.__mro__[:4])
416 | assert field_mro == [
417 | mongo_fields.MongoURLField,
418 | mongo_fields.EmptyStringIsNoneMixin,
419 | wtf_fields.URLField,
420 | wtf_fields.StringField,
421 | ]
422 |
--------------------------------------------------------------------------------
/tests/test_json.py:
--------------------------------------------------------------------------------
1 | """Extension of app JSON capabilities."""
2 | import flask
3 | import pytest
4 |
5 | from flask_mongoengine import MongoEngine
6 | from flask_mongoengine.json import use_json_provider
7 |
8 |
9 | @pytest.fixture()
10 | def extended_db(app):
11 | """Provider config fixture."""
12 | if use_json_provider():
13 | app.json_provider_class = DummyProvider
14 | else:
15 | app.json_encoder = DummyEncoder
16 | app.config["MONGODB_SETTINGS"] = [
17 | {
18 | "db": "flask_mongoengine_test_db",
19 | "host": "localhost",
20 | "port": 27017,
21 | "alias": "default",
22 | "uuidRepresentation": "standard",
23 | }
24 | ]
25 | test_db = MongoEngine(app)
26 | db_name = (
27 | test_db.connection["default"].get_database("flask_mongoengine_test_db").name
28 | )
29 |
30 | if not db_name.endswith("_test_db"):
31 | raise RuntimeError(
32 | f"DATABASE_URL must point to testing db, not to master db ({db_name})"
33 | )
34 |
35 | # Clear database before tests, for cases when some test failed before.
36 | test_db.connection["default"].drop_database(db_name)
37 |
38 | yield test_db
39 |
40 | # Clear database after tests, for graceful exit.
41 | test_db.connection["default"].drop_database(db_name)
42 |
43 |
44 | class DummyEncoder(flask.json.JSONEncoder):
45 | """
46 | An example encoder which a user may create and override
47 | the apps json_encoder with.
48 | This class is a NO-OP, but used to test proper inheritance.
49 | """
50 |
51 |
52 | DummyProvider = None
53 | if use_json_provider():
54 |
55 | class DummyProvider(flask.json.provider.DefaultJSONProvider):
56 | """Dummy Provider, to test correct MRO in new flask versions."""
57 |
58 |
59 | @pytest.mark.skipif(condition=use_json_provider(), reason="New flask use other test")
60 | @pytest.mark.usefixtures("extended_db")
61 | def test_inheritance_old_flask(app):
62 | assert issubclass(app.json_encoder, DummyEncoder)
63 | json_encoder_name = app.json_encoder.__name__
64 |
65 | assert json_encoder_name == "MongoEngineJSONEncoder"
66 |
67 |
68 | @pytest.mark.skipif(
69 | condition=not use_json_provider(), reason="Old flask use other test"
70 | )
71 | @pytest.mark.usefixtures("extended_db")
72 | def test_inheritance(app):
73 | assert issubclass(app.json_provider_class, DummyProvider)
74 | json_provider_class = app.json_provider_class.__name__
75 |
76 | assert json_provider_class == "MongoEngineJSONProvider"
77 | assert isinstance(app.json, DummyProvider)
78 |
--------------------------------------------------------------------------------
/tests/test_json_app.py:
--------------------------------------------------------------------------------
1 | import flask
2 | import pytest
3 | from bson import DBRef, ObjectId
4 |
5 |
6 | @pytest.fixture(autouse=True)
7 | def setup_endpoints(app, todo):
8 | Todo = todo
9 |
10 | @app.route("/")
11 | def index():
12 | return flask.jsonify(result=Todo.objects())
13 |
14 | @app.route("/as_pymongo")
15 | def as_pymongo():
16 | return flask.jsonify(result=Todo.objects().as_pymongo())
17 |
18 | @app.route("/aggregate")
19 | def aggregate():
20 | return flask.jsonify(
21 | result=Todo.objects().aggregate([{"$match": {"title": {"$ne": "lksdjh"}}}])
22 | )
23 |
24 | @app.route("/add", methods=["POST"])
25 | def add():
26 | form = flask.request.form
27 | todo = Todo(title=form["title"], text=form["text"])
28 | todo.save()
29 | return flask.jsonify(result=todo)
30 |
31 | @app.route("/show//")
32 | def show(id):
33 | return flask.jsonify(result=Todo.objects.get_or_404(id=id))
34 |
35 | @app.route("/object_id")
36 | def object_id():
37 | return flask.jsonify(result=ObjectId())
38 |
39 | @app.route("/dbref")
40 | def dbref():
41 | return flask.jsonify(result=DBRef("Todo", ObjectId()))
42 |
43 |
44 | def test_with_id(app, todo):
45 | Todo = todo
46 | client = app.test_client()
47 | response = client.get(f"/show/{ObjectId()}/")
48 | assert response.status_code == 404
49 |
50 | response = client.post("/add", data={"title": "First Item", "text": "The text"})
51 | assert response.status_code == 200
52 |
53 | response = client.get("/dbref")
54 | assert response.status_code == 200
55 |
56 | response = client.get("/object_id")
57 | assert response.status_code == 200
58 |
59 | response = client.get(f"/show/{Todo.objects.first().id}/")
60 | assert response.status_code == 200
61 |
62 | result = flask.json.loads(response.data).get("result")
63 | assert ("title", "First Item") in result.items()
64 |
65 |
66 | def test_basic_insert(app):
67 | client = app.test_client()
68 | client.post("/add", data={"title": "First Item", "text": "The text"})
69 | client.post("/add", data={"title": "2nd Item", "text": "The text"})
70 |
71 | rv = client.get("/")
72 | result = flask.json.loads(rv.data).get("result")
73 | assert len(result) == 2
74 | for i in result:
75 | assert "title" in i
76 | assert "text" in i
77 |
78 | rv = client.get("/as_pymongo")
79 | result = flask.json.loads(rv.data).get("result")
80 | assert len(result) == 2
81 | for i in result:
82 | assert "title" in i
83 | assert "text" in i
84 |
85 | rv = client.get("/aggregate")
86 | result = flask.json.loads(rv.data).get("result")
87 | for i in result:
88 | assert "title" in i
89 | assert "text" in i
90 | assert len(result) == 2
91 |
--------------------------------------------------------------------------------
/tests/test_pagination.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | from werkzeug.exceptions import NotFound
3 |
4 | from flask_mongoengine import ListFieldPagination, Pagination
5 |
6 |
7 | def test_queryset_paginator(app, todo):
8 | Todo = todo
9 | for i in range(42):
10 | Todo(title=f"post: {i}").save()
11 |
12 | with pytest.raises(NotFound):
13 | Pagination(iterable=Todo.objects, page=0, per_page=10)
14 |
15 | with pytest.raises(NotFound):
16 | Pagination(iterable=Todo.objects, page=6, per_page=10)
17 |
18 | paginator = Pagination(Todo.objects, 1, 10)
19 | _test_paginator(paginator)
20 |
21 | for page in range(1, 10):
22 | for index, todo in enumerate(
23 | Todo.objects.paginate(page=page, per_page=5).items
24 | ):
25 | assert todo.title == f"post: {(page-1) * 5 + index}"
26 |
27 |
28 | def test_paginate_plain_list():
29 | with pytest.raises(NotFound):
30 | Pagination(iterable=range(1, 42), page=0, per_page=10)
31 |
32 | with pytest.raises(NotFound):
33 | Pagination(iterable=range(1, 42), page=6, per_page=10)
34 |
35 | paginator = Pagination(range(1, 42), 1, 10)
36 | _test_paginator(paginator)
37 |
38 |
39 | def test_list_field_pagination(app, todo):
40 | Todo = todo
41 |
42 | comments = [f"comment: {i}" for i in range(42)]
43 | todo = Todo(
44 | title="todo has comments",
45 | comments=comments,
46 | comment_count=len(comments),
47 | ).save()
48 |
49 | # Check without providing a total
50 | paginator = ListFieldPagination(Todo.objects, todo.id, "comments", 1, 10)
51 | _test_paginator(paginator)
52 |
53 | # Check with providing a total (saves a query)
54 | paginator = ListFieldPagination(
55 | Todo.objects, todo.id, "comments", 1, 10, todo.comment_count
56 | )
57 | _test_paginator(paginator)
58 |
59 | paginator = todo.paginate_field("comments", 1, 10)
60 | _test_paginator(paginator)
61 |
62 |
63 | def _test_paginator(paginator):
64 | assert 5 == paginator.pages
65 | assert [1, 2, 3, 4, 5] == list(paginator.iter_pages())
66 |
67 | for i in [1, 2, 3, 4, 5]:
68 |
69 | if i == 1:
70 | assert not paginator.has_prev
71 | with pytest.raises(NotFound):
72 | paginator.prev()
73 | else:
74 | assert paginator.has_prev
75 |
76 | if i == 5:
77 | assert not paginator.has_next
78 | with pytest.raises(NotFound):
79 | paginator.next()
80 | else:
81 | assert paginator.has_next
82 |
83 | if i == 3:
84 | assert [None, 2, 3, 4, None] == list(paginator.iter_pages(0, 1, 1, 0))
85 |
86 | assert i == paginator.page
87 | assert i - 1 == paginator.prev_num
88 | assert i + 1 == paginator.next_num
89 |
90 | # Paginate to the next page
91 | if i < 5:
92 | paginator = paginator.next()
93 |
--------------------------------------------------------------------------------
/tests/test_session.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | from flask import session
3 | from pytest_mock import MockerFixture
4 |
5 | from flask_mongoengine import MongoEngineSessionInterface
6 |
7 |
8 | @pytest.fixture(autouse=True)
9 | def setup_endpoints(app, db):
10 |
11 | app.session_interface = MongoEngineSessionInterface(db)
12 |
13 | @app.route("/")
14 | def index():
15 | session["a"] = "hello session"
16 | return session["a"]
17 |
18 | @app.route("/check-session")
19 | def check_session():
20 | return f'session: {session["a"]}'
21 |
22 |
23 | @pytest.fixture
24 | def permanent_session_app(app):
25 | @app.before_request
26 | def make_session_permanent():
27 | session.permanent = True
28 |
29 | return app
30 |
31 |
32 | def test__save_session__called_on_session_set(app, mocker: MockerFixture):
33 | save_spy = mocker.spy(MongoEngineSessionInterface, "save_session")
34 | expiration_spy = mocker.spy(MongoEngineSessionInterface, "get_expiration_time")
35 | client = app.test_client()
36 |
37 | response = client.get("/")
38 | call_args, _ = expiration_spy.call_args_list[0]
39 |
40 | assert response.status_code == 200
41 | assert response.data.decode("utf-8") == "hello session"
42 | assert app.session_interface.cls.objects.count() == 1
43 | save_spy.assert_called_once()
44 | assert call_args[2].permanent is False # session object
45 |
46 |
47 | def test__save_session__called_on_session_set__should_respect_permanent_session_setting(
48 | permanent_session_app, mocker: MockerFixture
49 | ):
50 | expiration_spy = mocker.spy(MongoEngineSessionInterface, "get_expiration_time")
51 | client = permanent_session_app.test_client()
52 | client.get("/")
53 |
54 | call_args, _ = expiration_spy.call_args_list[0]
55 | assert call_args[2].permanent is True # session object
56 |
57 |
58 | def test__open_session_called_on_session_get(app, mocker: MockerFixture):
59 | client = app.test_client()
60 | open_spy = mocker.spy(MongoEngineSessionInterface, "open_session")
61 | client.get("/")
62 | open_spy.assert_called_once() # On init call with no session
63 |
64 | response = client.get("/check-session")
65 |
66 | assert response.status_code == 200
67 | assert response.data.decode("utf-8") == "session: hello session"
68 | assert open_spy.call_count == 2 # On init + get with sid
69 |
70 |
71 | @pytest.mark.parametrize("unsupported_value", (1, None, True, False, [], {}))
72 | def test_session_interface__should_raise_value_error_if_collection_name_not_string(
73 | db, unsupported_value
74 | ):
75 | with pytest.raises(ValueError) as error:
76 | MongoEngineSessionInterface(db, collection=unsupported_value)
77 |
78 | assert str(error.value) == "Collection argument should be string"
79 |
--------------------------------------------------------------------------------