pub/mongoengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #2444 from bagerard/improve_code_health

Browse Source 
Improve code health
This commit is contained in:
Bastien Gérard 2020-12-13 10:27:37 +01:00 committed by GitHub
commit aa3ff39ef8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
60 changed files with 526 additions and 728 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.pre-commit-config.yaml
View File

@ -1,12 +1,17 @@
fail_fast: false fail_fast: false
repos: repos:
- repo: https://github.com/ambv/black - repo: https://github.com/ambv/black
rev: 19.10b0 rev: 20.8b1
hooks: hooks:
- id: black - id: black
- repo: https://gitlab.com/pycqa/flake8 - repo: https://gitlab.com/pycqa/flake8
rev: 3.8.0a2 rev: 3.8.4
hooks: hooks:
- id: flake8 - id: flake8
additional_dependencies: additional_dependencies:
- flake8-import-order - flake8-import-order
- repo: https://github.com/asottile/pyupgrade
rev: v2.7.4
hooks:
- id: pyupgrade
args: [--py36-plus]

32
.travis.yml
View File

@ -16,11 +16,11 @@
language: python language: python
dist: xenial dist: xenial
python: python:
- 3.6 - 3.6
- 3.7 - 3.7
- 3.8 - 3.8
- 3.9 - 3.9
- pypy3 - pypy3
env: env:
global: global:
@ -42,14 +42,14 @@ matrix:
fast_finish: true fast_finish: true
include: include:
- python: 3.7 - python: 3.7
env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_6} env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_6}
- python: 3.7 - python: 3.7
env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_9} env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_9}
- python: 3.7 - python: 3.7
env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_11} env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_11}
- python: 3.8 - python: 3.8
env: MONGODB=${MONGODB_4_0} PYMONGO=${PYMONGO_3_11} env: MONGODB=${MONGODB_4_0} PYMONGO=${PYMONGO_3_11}
install: install:
# Install Mongo # Install Mongo
@ -69,7 +69,7 @@ before_script:
- ${PWD}/mongodb-linux-x86_64-${MONGODB}/bin/mongod --dbpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/data --logpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/mongodb.log --fork - ${PWD}/mongodb-linux-x86_64-${MONGODB}/bin/mongod --dbpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/data --logpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/mongodb.log --fork
# Run pre-commit hooks (black, flake8, etc) on entire codebase # Run pre-commit hooks (black, flake8, etc) on entire codebase
- if [[ $TRAVIS_PYTHON_VERSION == $MAIN_PYTHON_VERSION ]]; then pre-commit run -a; else echo "pre-commit checks only runs on py37"; fi - if [[ $TRAVIS_PYTHON_VERSION == $MAIN_PYTHON_VERSION ]]; then pre-commit run -a; else echo "pre-commit checks only runs on py37"; fi
- mongo --eval 'db.version();' # Make sure mongo is awake - mongo --eval 'db.version();' # Make sure mongo is awake
script: script:
- tox -e $(echo py$TRAVIS_PYTHON_VERSION-mg$PYMONGO | tr -d . | sed -e 's/pypypy/pypy/') -- -a "--cov=mongoengine" - tox -e $(echo py$TRAVIS_PYTHON_VERSION-mg$PYMONGO | tr -d . | sed -e 's/pypypy/pypy/') -- -a "--cov=mongoengine"
@ -83,8 +83,8 @@ notifications:
# Only run builds on the master branch and GitHub releases (tagged as vX.Y.Z) # Only run builds on the master branch and GitHub releases (tagged as vX.Y.Z)
branches: branches:
only: only:
- master - master
- /^v.*$/ - /^v.*$/
# Whenever a new release is created via GitHub, publish it on PyPI. # Whenever a new release is created via GitHub, publish it on PyPI.
deploy: deploy:

2
benchmarks/test_basic_doc_ops.py
View File

@ -45,7 +45,7 @@ def test_basic():
print( print(
"Doc setattr: %.3fus" "Doc setattr: %.3fus"
% (timeit(lambda: setattr(b, "name", "New name"), 10000) * 10 ** 6) % (timeit(lambda: setattr(b, "name", "New name"), 10000) * 10 ** 6) # noqa B010
) )
print("Doc to mongo: %.3fus" % (timeit(b.to_mongo, 1000) * 10 ** 6)) print("Doc to mongo: %.3fus" % (timeit(b.to_mongo, 1000) * 10 ** 6))

4
docs/conf.py
View File

@ -41,8 +41,8 @@ source_suffix = ".rst"
master_doc = "index" master_doc = "index"
# General information about the project. # General information about the project.
project = u"MongoEngine" project = "MongoEngine"
copyright = u"2009, MongoEngine Authors" copyright = "2009, MongoEngine Authors" # noqa: A001
# The version info for the project you're documenting, acts as replacement for # The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the # |version| and |release|, also used in various other places throughout the

12
mongoengine/__init__.py
View File

@ -10,12 +10,12 @@ from mongoengine import signals
# mongoengine, e.g. instead of `from mongoengine.connection import connect`, # mongoengine, e.g. instead of `from mongoengine.connection import connect`,
# users can simply use `from mongoengine import connect`, or even # users can simply use `from mongoengine import connect`, or even
# `from mongoengine import *` and then `connect('testdb')`. # `from mongoengine import *` and then `connect('testdb')`.
from mongoengine.connection import * from mongoengine.connection import * # noqa: F401
from mongoengine.document import * from mongoengine.document import * # noqa: F401
from mongoengine.errors import * from mongoengine.errors import * # noqa: F401
from mongoengine.fields import * from mongoengine.fields import * # noqa: F401
from mongoengine.queryset import * from mongoengine.queryset import * # noqa: F401
from mongoengine.signals import * from mongoengine.signals import * # noqa: F401
__all__ = ( __all__ = (

18
mongoengine/base/datastructures.py
View File

@ -67,11 +67,11 @@ class BaseDict(dict):
if isinstance(value, EmbeddedDocument) and value._instance is None: if isinstance(value, EmbeddedDocument) and value._instance is None:
value._instance = self._instance value._instance = self._instance
elif isinstance(value, dict) and not isinstance(value, BaseDict): elif isinstance(value, dict) and not isinstance(value, BaseDict):
value = BaseDict(value, None, "{}.{}".format(self._name, key)) value = BaseDict(value, None, f"{self._name}.{key}")
super().__setitem__(key, value) super().__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
elif isinstance(value, list) and not isinstance(value, BaseList): elif isinstance(value, list) and not isinstance(value, BaseList):
value = BaseList(value, None, "{}.{}".format(self._name, key)) value = BaseList(value, None, f"{self._name}.{key}")
super().__setitem__(key, value) super().__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
return value return value
@ -97,7 +97,7 @@ class BaseDict(dict):
def _mark_as_changed(self, key=None): def _mark_as_changed(self, key=None):
if hasattr(self._instance, "_mark_as_changed"): if hasattr(self._instance, "_mark_as_changed"):
if key: if key:
self._instance._mark_as_changed("{}.{}".format(self._name, key)) self._instance._mark_as_changed(f"{self._name}.{key}")
else: else:
self._instance._mark_as_changed(self._name) self._instance._mark_as_changed(self._name)
@ -133,12 +133,12 @@ class BaseList(list):
value._instance = self._instance value._instance = self._instance
elif isinstance(value, dict) and not isinstance(value, BaseDict): elif isinstance(value, dict) and not isinstance(value, BaseDict):
# Replace dict by BaseDict # Replace dict by BaseDict
value = BaseDict(value, None, "{}.{}".format(self._name, key)) value = BaseDict(value, None, f"{self._name}.{key}")
super().__setitem__(key, value) super().__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
elif isinstance(value, list) and not isinstance(value, BaseList): elif isinstance(value, list) and not isinstance(value, BaseList):
# Replace list by BaseList # Replace list by BaseList
value = BaseList(value, None, "{}.{}".format(self._name, key)) value = BaseList(value, None, f"{self._name}.{key}")
super().__setitem__(key, value) super().__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
return value return value
@ -180,9 +180,7 @@ class BaseList(list):
def _mark_as_changed(self, key=None): def _mark_as_changed(self, key=None):
if hasattr(self._instance, "_mark_as_changed"): if hasattr(self._instance, "_mark_as_changed"):
if key is not None: if key is not None:
self._instance._mark_as_changed( self._instance._mark_as_changed(f"{self._name}.{key % len(self)}")
"{}.{}".format(self._name, key % len(self))
)
else: else:
self._instance._mark_as_changed(self._name) self._instance._mark_as_changed(self._name)
@ -429,7 +427,7 @@ class StrictDict:
def __repr__(self): def __repr__(self):
return "{%s}" % ", ".join( return "{%s}" % ", ".join(
'"{!s}": {!r}'.format(k, v) for k, v in self.items() f'"{k!s}": {v!r}' for k, v in self.items()
) )
cls._classes[allowed_keys] = SpecificStrictDict cls._classes[allowed_keys] = SpecificStrictDict
@ -472,4 +470,4 @@ class LazyReference(DBRef):
raise AttributeError() raise AttributeError()
def __repr__(self): def __repr__(self):
return "<LazyReference({}, {!r})>".format(self.document_type, self.pk) return f"<LazyReference({self.document_type}, {self.pk!r})>"

55
mongoengine/base/document.py
View File

@ -89,9 +89,7 @@ class BaseDocument:
list(self._fields.keys()) + ["id", "pk", "_cls", "_text_score"] list(self._fields.keys()) + ["id", "pk", "_cls", "_text_score"]
) )
if _undefined_fields: if _undefined_fields:
msg = ('The fields "{}" do not exist on the document "{}"').format( msg = f'The fields "{_undefined_fields}" do not exist on the document "{self._class_name}"'
_undefined_fields, self._class_name
)
raise FieldDoesNotExist(msg) raise FieldDoesNotExist(msg)
if self.STRICT and not self._dynamic: if self.STRICT and not self._dynamic:
@ -231,10 +229,10 @@ class BaseDocument:
setattr(self, k, data[k]) setattr(self, k, data[k])
if "_fields_ordered" in data: if "_fields_ordered" in data:
if self._dynamic: if self._dynamic:
setattr(self, "_fields_ordered", data["_fields_ordered"]) self._fields_ordered = data["_fields_ordered"]
else: else:
_super_fields_ordered = type(self)._fields_ordered _super_fields_ordered = type(self)._fields_ordered
setattr(self, "_fields_ordered", _super_fields_ordered) self._fields_ordered = _super_fields_ordered
dynamic_fields = data.get("_dynamic_fields") or SON() dynamic_fields = data.get("_dynamic_fields") or SON()
for k in dynamic_fields.keys(): for k in dynamic_fields.keys():
@ -244,8 +242,7 @@ class BaseDocument:
return iter(self._fields_ordered) return iter(self._fields_ordered)
def __getitem__(self, name): def __getitem__(self, name):
"""Dictionary-style field access, return a field's value if present. """Dictionary-style field access, return a field's value if present."""
"""
try: try:
if name in self._fields_ordered: if name in self._fields_ordered:
return getattr(self, name) return getattr(self, name)
@ -254,8 +251,7 @@ class BaseDocument:
raise KeyError(name) raise KeyError(name)
def __setitem__(self, name, value): def __setitem__(self, name, value):
"""Dictionary-style field access, set a field's value. """Dictionary-style field access, set a field's value."""
"""
# Ensure that the field exists before settings its value # Ensure that the field exists before settings its value
if not self._dynamic and name not in self._fields: if not self._dynamic and name not in self._fields:
raise KeyError(name) raise KeyError(name)
@ -277,7 +273,7 @@ class BaseDocument:
except (UnicodeEncodeError, UnicodeDecodeError): except (UnicodeEncodeError, UnicodeDecodeError):
u = "[Bad Unicode data]" u = "[Bad Unicode data]"
repr_type = str if u is None else type(u) repr_type = str if u is None else type(u)
return repr_type("<{}: {}>".format(self.__class__.__name__, u)) return repr_type(f"<{self.__class__.__name__}: {u}>")
def __str__(self): def __str__(self):
# TODO this could be simpler? # TODO this could be simpler?
@ -433,7 +429,7 @@ class BaseDocument:
pk = self.pk pk = self.pk
elif self._instance and hasattr(self._instance, "pk"): elif self._instance and hasattr(self._instance, "pk"):
pk = self._instance.pk pk = self._instance.pk
message = "ValidationError ({}:{}) ".format(self._class_name, pk) message = f"ValidationError ({self._class_name}:{pk}) "
raise ValidationError(message, errors=errors) raise ValidationError(message, errors=errors)
def to_json(self, *args, **kwargs): def to_json(self, *args, **kwargs):
@ -506,7 +502,7 @@ class BaseDocument:
if "." in key: if "." in key:
key, rest = key.split(".", 1) key, rest = key.split(".", 1)
key = self._db_field_map.get(key, key) key = self._db_field_map.get(key, key)
key = "{}.{}".format(key, rest) key = f"{key}.{rest}"
else: else:
key = self._db_field_map.get(key, key) key = self._db_field_map.get(key, key)
@ -578,7 +574,7 @@ class BaseDocument:
else: else:
iterator = data.items() iterator = data.items()
for index_or_key, value in iterator: for _index_or_key, value in iterator:
if hasattr(value, "_get_changed_fields") and not isinstance( if hasattr(value, "_get_changed_fields") and not isinstance(
value, Document value, Document
): # don't follow references ): # don't follow references
@ -602,7 +598,7 @@ class BaseDocument:
iterator = data.items() iterator = data.items()
for index_or_key, value in iterator: for index_or_key, value in iterator:
item_key = "{}{}.".format(base_key, index_or_key) item_key = f"{base_key}{index_or_key}."
# don't check anything lower if this key is already marked # don't check anything lower if this key is already marked
# as changed. # as changed.
if item_key[:-1] in changed_fields: if item_key[:-1] in changed_fields:
@ -610,15 +606,14 @@ class BaseDocument:
if hasattr(value, "_get_changed_fields"): if hasattr(value, "_get_changed_fields"):
changed = value._get_changed_fields() changed = value._get_changed_fields()
changed_fields += ["{}{}".format(item_key, k) for k in changed if k] changed_fields += [f"{item_key}{k}" for k in changed if k]
elif isinstance(value, (list, tuple, dict)): elif isinstance(value, (list, tuple, dict)):
BaseDocument._nestable_types_changed_fields( BaseDocument._nestable_types_changed_fields(
changed_fields, item_key, value changed_fields, item_key, value
) )
def _get_changed_fields(self): def _get_changed_fields(self):
"""Return a list of all fields that have explicitly been changed. """Return a list of all fields that have explicitly been changed."""
"""
EmbeddedDocument = _import_class("EmbeddedDocument") EmbeddedDocument = _import_class("EmbeddedDocument")
ReferenceField = _import_class("ReferenceField") ReferenceField = _import_class("ReferenceField")
GenericReferenceField = _import_class("GenericReferenceField") GenericReferenceField = _import_class("GenericReferenceField")
@ -643,7 +638,7 @@ class BaseDocument:
if isinstance(data, EmbeddedDocument): if isinstance(data, EmbeddedDocument):
# Find all embedded fields that have been changed # Find all embedded fields that have been changed
changed = data._get_changed_fields() changed = data._get_changed_fields()
changed_fields += ["{}{}".format(key, k) for k in changed if k] changed_fields += [f"{key}{k}" for k in changed if k]
elif isinstance(data, (list, tuple, dict)): elif isinstance(data, (list, tuple, dict)):
if hasattr(field, "field") and isinstance( if hasattr(field, "field") and isinstance(
field.field, (ReferenceField, GenericReferenceField) field.field, (ReferenceField, GenericReferenceField)
@ -750,8 +745,7 @@ class BaseDocument:
@classmethod @classmethod
def _from_son(cls, son, _auto_dereference=True, created=False): def _from_son(cls, son, _auto_dereference=True, created=False):
"""Create an instance of a Document (subclass) from a PyMongo SON (dict) """Create an instance of a Document (subclass) from a PyMongo SON (dict)"""
"""
if son and not isinstance(son, dict): if son and not isinstance(son, dict):
raise ValueError( raise ValueError(
"The source SON object needs to be of type 'dict' but a '%s' was found" "The source SON object needs to be of type 'dict' but a '%s' was found"
@ -796,11 +790,10 @@ class BaseDocument:
errors_dict[field_name] = e errors_dict[field_name] = e
if errors_dict: if errors_dict:
errors = "\n".join( errors = "\n".join([f"Field '{k}' - {v}" for k, v in errors_dict.items()])
["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()]
)
msg = "Invalid data to create a `{}` instance.\n{}".format( msg = "Invalid data to create a `{}` instance.\n{}".format(
cls._class_name, errors, cls._class_name,
errors,
) )
raise InvalidDocumentError(msg) raise InvalidDocumentError(msg)
@ -968,10 +961,7 @@ class BaseDocument:
unique_fields += unique_with unique_fields += unique_with
# Add the new index to the list # Add the new index to the list
fields = [ fields = [(f"{namespace}{f}", pymongo.ASCENDING) for f in unique_fields]
("{}{}".format(namespace, f), pymongo.ASCENDING)
for f in unique_fields
]
index = {"fields": fields, "unique": True, "sparse": sparse} index = {"fields": fields, "unique": True, "sparse": sparse}
unique_indexes.append(index) unique_indexes.append(index)
@ -1007,9 +997,7 @@ class BaseDocument:
"PolygonField", "PolygonField",
) )
geo_field_types = tuple( geo_field_types = tuple(_import_class(field) for field in geo_field_type_names)
[_import_class(field) for field in geo_field_type_names]
)
for field in cls._fields.values(): for field in cls._fields.values():
if not isinstance(field, geo_field_types): if not isinstance(field, geo_field_types):
@ -1027,7 +1015,7 @@ class BaseDocument:
elif field._geo_index: elif field._geo_index:
field_name = field.db_field field_name = field.db_field
if parent_field: if parent_field:
field_name = "{}.{}".format(parent_field, field_name) field_name = f"{parent_field}.{field_name}"
geo_indices.append({"fields": [(field_name, field._geo_index)]}) geo_indices.append({"fields": [(field_name, field._geo_index)]})
return geo_indices return geo_indices
@ -1165,8 +1153,7 @@ class BaseDocument:
@classmethod @classmethod
def _translate_field_name(cls, field, sep="."): def _translate_field_name(cls, field, sep="."):
"""Translate a field attribute name to a database field name. """Translate a field attribute name to a database field name."""
"""
parts = field.split(sep) parts = field.split(sep)
parts = [f.db_field for f in cls._lookup_field(parts)] parts = [f.db_field for f in cls._lookup_field(parts)]
return ".".join(parts) return ".".join(parts)

14
mongoengine/base/fields.py
View File

@ -40,7 +40,7 @@ class BaseField:
choices=None, choices=None,
null=False, null=False,
sparse=False, sparse=False,
**kwargs **kwargs,
): ):
""" """
:param db_field: The database field to store this field in :param db_field: The database field to store this field in
@ -117,8 +117,7 @@ class BaseField:
BaseField.creation_counter += 1 BaseField.creation_counter += 1
def __get__(self, instance, owner): def __get__(self, instance, owner):
"""Descriptor for retrieving a value from a field in a document. """Descriptor for retrieving a value from a field in a document."""
"""
if instance is None: if instance is None:
# Document class being used rather than a document object # Document class being used rather than a document object
return self return self
@ -466,9 +465,7 @@ class ComplexBaseField(BaseField):
if errors: if errors:
field_class = self.field.__class__.__name__ field_class = self.field.__class__.__name__
self.error( self.error(f"Invalid {field_class} item ({value})", errors=errors)
"Invalid {} item ({})".format(field_class, value), errors=errors
)
# Don't allow empty values if required # Don't allow empty values if required
if self.required and not value: if self.required and not value:
self.error("Field is required and cannot be empty") self.error("Field is required and cannot be empty")
@ -517,8 +514,7 @@ class ObjectIdField(BaseField):
class GeoJsonBaseField(BaseField): class GeoJsonBaseField(BaseField):
"""A geo json field storing a geojson style object. """A geo json field storing a geojson style object."""
"""
_geo_index = pymongo.GEOSPHERE _geo_index = pymongo.GEOSPHERE
_type = "GeoBase" _type = "GeoBase"
@ -538,7 +534,7 @@ class GeoJsonBaseField(BaseField):
if isinstance(value, dict): if isinstance(value, dict):
if set(value.keys()) == {"type", "coordinates"}: if set(value.keys()) == {"type", "coordinates"}:
if value["type"] != self._type: if value["type"] != self._type:
self.error('{} type must be "{}"'.format(self._name, self._type)) self.error(f'{self._name} type must be "{self._type}"')
return self.validate(value["coordinates"]) return self.validate(value["coordinates"])
else: else:
self.error( self.error(

6
mongoengine/base/metaclasses.py
View File

@ -337,7 +337,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
# allow_inheritance to False. If the base Document allows inheritance, # allow_inheritance to False. If the base Document allows inheritance,
# none of its subclasses can override allow_inheritance to False. # none of its subclasses can override allow_inheritance to False.
simple_class = all( simple_class = all(
[b._meta.get("abstract") for b in flattened_bases if hasattr(b, "_meta")] b._meta.get("abstract") for b in flattened_bases if hasattr(b, "_meta")
) )
if ( if (
not simple_class not simple_class
@ -439,8 +439,8 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0) id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0)
for i in itertools.count(): for i in itertools.count():
id_name = "{}_{}".format(id_basename, i) id_name = f"{id_basename}_{i}"
id_db_name = "{}_{}".format(id_db_basename, i) id_db_name = f"{id_db_basename}_{i}"
if id_name not in existing_fields and id_db_name not in existing_db_fields: if id_name not in existing_fields and id_db_name not in existing_db_fields:
return id_name, id_db_name return id_name, id_db_name

8
mongoengine/connection.py
View File

@ -54,7 +54,7 @@ def _get_connection_settings(
password=None, password=None,
authentication_source=None, authentication_source=None,
authentication_mechanism=None, authentication_mechanism=None,
**kwargs **kwargs,
): ):
"""Get the connection settings as a dict """Get the connection settings as a dict
@ -177,7 +177,7 @@ def register_connection(
password=None, password=None,
authentication_source=None, authentication_source=None,
authentication_mechanism=None, authentication_mechanism=None,
**kwargs **kwargs,
): ):
"""Register the connection settings. """Register the connection settings.
@ -210,7 +210,7 @@ def register_connection(
password=password, password=password,
authentication_source=authentication_source, authentication_source=authentication_source,
authentication_mechanism=authentication_mechanism, authentication_mechanism=authentication_mechanism,
**kwargs **kwargs,
) )
_connection_settings[alias] = conn_settings _connection_settings[alias] = conn_settings
@ -313,7 +313,7 @@ def _create_connection(alias, connection_class, **connection_settings):
try: try:
return connection_class(**connection_settings) return connection_class(**connection_settings)
except Exception as e: except Exception as e:
raise ConnectionFailure("Cannot connect to database {} :\n{}".format(alias, e)) raise ConnectionFailure(f"Cannot connect to database {alias} :\n{e}")
def _find_existing_connection(connection_settings): def _find_existing_connection(connection_settings):

3
mongoengine/context_managers.py
View File

@ -184,8 +184,7 @@ class query_counter:
""" """
def __init__(self, alias=DEFAULT_CONNECTION_NAME): def __init__(self, alias=DEFAULT_CONNECTION_NAME):
"""Construct the query_counter """Construct the query_counter"""
"""
self.db = get_db(alias=alias) self.db = get_db(alias=alias)
self.initial_profiling_level = None self.initial_profiling_level = None
self._ctx_query_counter = 0 # number of queries issued by the context self._ctx_query_counter = 0 # number of queries issued by the context

11
mongoengine/dereference.py
View File

@ -51,10 +51,10 @@ class DeReference:
doc_type = doc_type.document_type doc_type = doc_type.document_type
is_list = not hasattr(items, "items") is_list = not hasattr(items, "items")
if is_list and all([i.__class__ == doc_type for i in items]): if is_list and all(i.__class__ == doc_type for i in items):
return items return items
elif not is_list and all( elif not is_list and all(
[i.__class__ == doc_type for i in items.values()] i.__class__ == doc_type for i in items.values()
): ):
return items return items
elif not field.dbref: elif not field.dbref:
@ -157,8 +157,7 @@ class DeReference:
return reference_map return reference_map
def _fetch_objects(self, doc_type=None): def _fetch_objects(self, doc_type=None):
"""Fetch all references and convert to their document objects """Fetch all references and convert to their document objects"""
"""
object_map = {} object_map = {}
for collection, dbrefs in self.reference_map.items(): for collection, dbrefs in self.reference_map.items():
@ -272,12 +271,12 @@ class DeReference:
(v["_ref"].collection, v["_ref"].id), v (v["_ref"].collection, v["_ref"].id), v
) )
elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
item_name = "{}.{}.{}".format(name, k, field_name) item_name = f"{name}.{k}.{field_name}"
data[k]._data[field_name] = self._attach_objects( data[k]._data[field_name] = self._attach_objects(
v, depth, instance=instance, name=item_name v, depth, instance=instance, name=item_name
) )
elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
item_name = "{}.{}".format(name, k) if name else name item_name = f"{name}.{k}" if name else name
data[k] = self._attach_objects( data[k] = self._attach_objects(
v, depth - 1, instance=instance, name=item_name v, depth - 1, instance=instance, name=item_name
) )

8
mongoengine/errors.py
View File

@ -94,7 +94,7 @@ class ValidationError(AssertionError):
return str(self.message) return str(self.message)
def __repr__(self): def __repr__(self):
return "{}({},)".format(self.__class__.__name__, self.message) return f"{self.__class__.__name__}({self.message},)"
def __getattribute__(self, name): def __getattribute__(self, name):
message = super().__getattribute__(name) message = super().__getattribute__(name)
@ -102,7 +102,7 @@ class ValidationError(AssertionError):
if self.field_name: if self.field_name:
message = "%s" % message message = "%s" % message
if self.errors: if self.errors:
message = "{}({})".format(message, self._format_errors()) message = f"{message}({self._format_errors()})"
return message return message
def _get_message(self): def _get_message(self):
@ -147,13 +147,13 @@ class ValidationError(AssertionError):
elif isinstance(value, dict): elif isinstance(value, dict):
value = " ".join([generate_key(v, k) for k, v in value.items()]) value = " ".join([generate_key(v, k) for k, v in value.items()])
results = "{}.{}".format(prefix, value) if prefix else value results = f"{prefix}.{value}" if prefix else value
return results return results
error_dict = defaultdict(list) error_dict = defaultdict(list)
for k, v in self.to_dict().items(): for k, v in self.to_dict().items():
error_dict[generate_key(v)].append(k) error_dict[generate_key(v)].append(k)
return " ".join(["{}: {}".format(k, v) for k, v in error_dict.items()]) return " ".join([f"{k}: {v}" for k, v in error_dict.items()])
class DeprecatedError(Exception): class DeprecatedError(Exception):

42
mongoengine/fields.py
View File

@ -189,17 +189,15 @@ class URLField(StringField):
# Check first if the scheme is valid # Check first if the scheme is valid
scheme = value.split("://")[0].lower() scheme = value.split("://")[0].lower()
if scheme not in self.schemes: if scheme not in self.schemes:
self.error("Invalid scheme {} in URL: {}".format(scheme, value)) self.error(f"Invalid scheme {scheme} in URL: {value}")
# Then check full URL # Then check full URL
if not self.url_regex.match(value): if not self.url_regex.match(value):
self.error("Invalid URL: {}".format(value)) self.error(f"Invalid URL: {value}")
class EmailField(StringField): class EmailField(StringField):
"""A field that validates input as an email address. """A field that validates input as an email address."""
"""
USER_REGEX = LazyRegexCompiler( USER_REGEX = LazyRegexCompiler(
# `dot-atom` defined in RFC 5322 Section 3.2.3. # `dot-atom` defined in RFC 5322 Section 3.2.3.
@ -233,7 +231,7 @@ class EmailField(StringField):
allow_utf8_user=False, allow_utf8_user=False,
allow_ip_domain=False, allow_ip_domain=False,
*args, *args,
**kwargs **kwargs,
): ):
""" """
:param domain_whitelist: (optional) list of valid domain names applied during validation :param domain_whitelist: (optional) list of valid domain names applied during validation
@ -440,7 +438,7 @@ class DecimalField(BaseField):
force_string=False, force_string=False,
precision=2, precision=2,
rounding=decimal.ROUND_HALF_UP, rounding=decimal.ROUND_HALF_UP,
**kwargs **kwargs,
): ):
""" """
:param min_value: (optional) A min value that will be applied during validation :param min_value: (optional) A min value that will be applied during validation
@ -1299,8 +1297,7 @@ class ReferenceField(BaseField):
class CachedReferenceField(BaseField): class CachedReferenceField(BaseField):
"""A referencefield with cache fields to purpose pseudo-joins """A referencefield with cache fields to purpose pseudo-joins"""
"""
def __init__(self, document_type, fields=None, auto_sync=True, **kwargs): def __init__(self, document_type, fields=None, auto_sync=True, **kwargs):
"""Initialises the Cached Reference Field. """Initialises the Cached Reference Field.
@ -1337,7 +1334,7 @@ class CachedReferenceField(BaseField):
return None return None
update_kwargs = { update_kwargs = {
"set__{}__{}".format(self.name, key): val f"set__{self.name}__{key}": val
for key, val in document._delta()[0].items() for key, val in document._delta()[0].items()
if key in self.fields if key in self.fields
} }
@ -1680,8 +1677,7 @@ class GridFSError(Exception):
class GridFSProxy: class GridFSProxy:
"""Proxy object to handle writing and reading of files to and from GridFS """Proxy object to handle writing and reading of files to and from GridFS"""
"""
_fs = None _fs = None
@ -1739,12 +1735,12 @@ class GridFSProxy:
return self.__copy__() return self.__copy__()
def __repr__(self): def __repr__(self):
return "<{}: {}>".format(self.__class__.__name__, self.grid_id) return f"<{self.__class__.__name__}: {self.grid_id}>"
def __str__(self): def __str__(self):
gridout = self.get() gridout = self.get()
filename = getattr(gridout, "filename") if gridout else "<no file>" filename = gridout.filename if gridout else "<no file>"
return "<{}: {} ({})>".format(self.__class__.__name__, filename, self.grid_id) return f"<{self.__class__.__name__}: {filename} ({self.grid_id})>"
def __eq__(self, other): def __eq__(self, other):
if isinstance(other, GridFSProxy): if isinstance(other, GridFSProxy):
@ -1843,8 +1839,7 @@ class GridFSProxy:
class FileField(BaseField): class FileField(BaseField):
"""A GridFS storage field. """A GridFS storage field."""
"""
proxy_class = GridFSProxy proxy_class = GridFSProxy
@ -2120,7 +2115,7 @@ class SequenceField(BaseField):
sequence_name=None, sequence_name=None,
value_decorator=None, value_decorator=None,
*args, *args,
**kwargs **kwargs,
): ):
self.collection_name = collection_name or self.COLLECTION_NAME self.collection_name = collection_name or self.COLLECTION_NAME
self.db_alias = db_alias or DEFAULT_CONNECTION_NAME self.db_alias = db_alias or DEFAULT_CONNECTION_NAME
@ -2135,7 +2130,7 @@ class SequenceField(BaseField):
Generate and Increment the counter Generate and Increment the counter
""" """
sequence_name = self.get_sequence_name() sequence_name = self.get_sequence_name()
sequence_id = "{}.{}".format(sequence_name, self.name) sequence_id = f"{sequence_name}.{self.name}"
collection = get_db(alias=self.db_alias)[self.collection_name] collection = get_db(alias=self.db_alias)[self.collection_name]
counter = collection.find_one_and_update( counter = collection.find_one_and_update(
@ -2149,7 +2144,7 @@ class SequenceField(BaseField):
def set_next_value(self, value): def set_next_value(self, value):
"""Helper method to set the next sequence value""" """Helper method to set the next sequence value"""
sequence_name = self.get_sequence_name() sequence_name = self.get_sequence_name()
sequence_id = "{}.{}".format(sequence_name, self.name) sequence_id = f"{sequence_name}.{self.name}"
collection = get_db(alias=self.db_alias)[self.collection_name] collection = get_db(alias=self.db_alias)[self.collection_name]
counter = collection.find_one_and_update( counter = collection.find_one_and_update(
filter={"_id": sequence_id}, filter={"_id": sequence_id},
@ -2166,7 +2161,7 @@ class SequenceField(BaseField):
as it is only fixed on set. as it is only fixed on set.
""" """
sequence_name = self.get_sequence_name() sequence_name = self.get_sequence_name()
sequence_id = "{}.{}".format(sequence_name, self.name) sequence_id = f"{sequence_name}.{self.name}"
collection = get_db(alias=self.db_alias)[self.collection_name] collection = get_db(alias=self.db_alias)[self.collection_name]
data = collection.find_one({"_id": sequence_id}) data = collection.find_one({"_id": sequence_id})
@ -2219,8 +2214,7 @@ class SequenceField(BaseField):
class UUIDField(BaseField): class UUIDField(BaseField):
"""A UUID field. """A UUID field."""
"""
_binary = None _binary = None
@ -2427,7 +2421,7 @@ class LazyReferenceField(BaseField):
passthrough=False, passthrough=False,
dbref=False, dbref=False,
reverse_delete_rule=DO_NOTHING, reverse_delete_rule=DO_NOTHING,
**kwargs **kwargs,
): ):
"""Initialises the Reference Field. """Initialises the Reference Field.

3
mongoengine/pymongo_support.py
View File

@ -14,8 +14,7 @@ IS_PYMONGO_GTE_37 = PYMONGO_VERSION >= _PYMONGO_37
def count_documents( def count_documents(
collection, filter, skip=None, limit=None, hint=None, collation=None collection, filter, skip=None, limit=None, hint=None, collation=None
): ):
"""Pymongo>3.7 deprecates count in favour of count_documents """Pymongo>3.7 deprecates count in favour of count_documents"""
"""
if limit == 0: if limit == 0:
return 0 # Pymongo raises an OperationFailure if called with limit=0 return 0 # Pymongo raises an OperationFailure if called with limit=0

35
mongoengine/queryset/base.py
View File

@ -189,7 +189,8 @@ class BaseQuerySet:
if queryset._scalar: if queryset._scalar:
return queryset._get_scalar( return queryset._get_scalar(
queryset._document._from_son( queryset._document._from_son(
queryset._cursor[key], _auto_dereference=self._auto_dereference, queryset._cursor[key],
_auto_dereference=self._auto_dereference,
) )
) )
@ -197,7 +198,8 @@ class BaseQuerySet:
return queryset._cursor[key] return queryset._cursor[key]
return queryset._document._from_son( return queryset._document._from_son(
queryset._cursor[key], _auto_dereference=self._auto_dereference, queryset._cursor[key],
_auto_dereference=self._auto_dereference,
) )
raise TypeError("Provide a slice or an integer index") raise TypeError("Provide a slice or an integer index")
@ -279,8 +281,7 @@ class BaseQuerySet:
) )
def create(self, **kwargs): def create(self, **kwargs):
"""Create new object. Returns the saved object instance. """Create new object. Returns the saved object instance."""
"""
return self._document(**kwargs).save(force_insert=True) return self._document(**kwargs).save(force_insert=True)
def first(self): def first(self):
@ -420,7 +421,7 @@ class BaseQuerySet:
count = count_documents( count = count_documents(
collection=self._cursor.collection, collection=self._cursor.collection,
filter=self._cursor._Cursor__spec, filter=self._cursor._Cursor__spec,
**kwargs **kwargs,
) )
self._cursor_obj = None self._cursor_obj = None
@ -524,7 +525,7 @@ class BaseQuerySet:
write_concern=None, write_concern=None,
read_concern=None, read_concern=None,
full_result=False, full_result=False,
**update **update,
): ):
"""Perform an atomic update on the fields matched by the query. """Perform an atomic update on the fields matched by the query.
@ -601,7 +602,7 @@ class BaseQuerySet:
write_concern=write_concern, write_concern=write_concern,
read_concern=read_concern, read_concern=read_concern,
full_result=True, full_result=True,
**update **update,
) )
if atomic_update.raw_result["updatedExisting"]: if atomic_update.raw_result["updatedExisting"]:
@ -632,7 +633,7 @@ class BaseQuerySet:
multi=False, multi=False,
write_concern=write_concern, write_concern=write_concern,
full_result=full_result, full_result=full_result,
**update **update,
) )
def modify( def modify(
@ -690,7 +691,7 @@ class BaseQuerySet:
upsert=upsert, upsert=upsert,
sort=sort, sort=sort,
return_document=return_doc, return_document=return_doc,
**self._cursor_args **self._cursor_args,
) )
except pymongo.errors.DuplicateKeyError as err: except pymongo.errors.DuplicateKeyError as err:
raise NotUniqueError("Update failed (%s)" % err) raise NotUniqueError("Update failed (%s)" % err)
@ -720,7 +721,7 @@ class BaseQuerySet:
return queryset.filter(pk=object_id).first() return queryset.filter(pk=object_id).first()
def in_bulk(self, object_ids): def in_bulk(self, object_ids):
""""Retrieve a set of documents by their ids. """ "Retrieve a set of documents by their ids.
:param object_ids: a list or tuple of ObjectId's :param object_ids: a list or tuple of ObjectId's
:rtype: dict of ObjectId's as keys and collection-specific :rtype: dict of ObjectId's as keys and collection-specific
@ -738,7 +739,8 @@ class BaseQuerySet:
else: else:
for doc in docs: for doc in docs:
doc_map[doc["_id"]] = self._document._from_son( doc_map[doc["_id"]] = self._document._from_son(
doc, _auto_dereference=self._auto_dereference, doc,
_auto_dereference=self._auto_dereference,
) )
return doc_map return doc_map
@ -1191,7 +1193,7 @@ class BaseQuerySet:
preference. preference.
""" """
if read_concern is not None and not isinstance(read_concern, Mapping): if read_concern is not None and not isinstance(read_concern, Mapping):
raise TypeError("%r is not a valid read concern." % (read_concern,)) raise TypeError(f"{read_concern!r} is not a valid read concern.")
queryset = self.clone() queryset = self.clone()
queryset._read_concern = ( queryset._read_concern = (
@ -1556,8 +1558,7 @@ class BaseQuerySet:
# Iterator helpers # Iterator helpers
def __next__(self): def __next__(self):
"""Wrap the result in a :class:`~mongoengine.Document` object. """Wrap the result in a :class:`~mongoengine.Document` object."""
"""
if self._none or self._empty: if self._none or self._empty:
raise StopIteration raise StopIteration
@ -1567,7 +1568,8 @@ class BaseQuerySet:
return raw_doc return raw_doc
doc = self._document._from_son( doc = self._document._from_son(
raw_doc, _auto_dereference=self._auto_dereference, raw_doc,
_auto_dereference=self._auto_dereference,
) )
if self._scalar: if self._scalar:
@ -1576,8 +1578,7 @@ class BaseQuerySet:
return doc return doc
def rewind(self): def rewind(self):
"""Rewind the cursor to its unevaluated state. """Rewind the cursor to its unevaluated state."""
"""
self._iter = False self._iter = False
self._cursor.rewind() self._cursor.rewind()

9
mongoengine/queryset/queryset.py
View File

@ -150,8 +150,7 @@ class QuerySet(BaseQuerySet):
return self._len return self._len
def no_cache(self): def no_cache(self):
"""Convert to a non-caching queryset """Convert to a non-caching queryset"""
"""
if self._result_cache is not None: if self._result_cache is not None:
raise OperationError("QuerySet already cached") raise OperationError("QuerySet already cached")
@ -162,13 +161,11 @@ class QuerySetNoCache(BaseQuerySet):
"""A non caching QuerySet""" """A non caching QuerySet"""
def cache(self): def cache(self):
"""Convert to a caching queryset """Convert to a caching queryset"""
"""
return self._clone_into(QuerySet(self._document, self._collection)) return self._clone_into(QuerySet(self._document, self._collection))
def __repr__(self): def __repr__(self):
"""Provides the string representation of the QuerySet """Provides the string representation of the QuerySet"""
"""
if self._iter: if self._iter:
return ".. queryset mid-iteration .." return ".. queryset mid-iteration .."

12
mongoengine/queryset/visitor.py
View File

@ -13,17 +13,14 @@ def warn_empty_is_deprecated():
class QNodeVisitor: class QNodeVisitor:
"""Base visitor class for visiting Q-object nodes in a query tree. """Base visitor class for visiting Q-object nodes in a query tree."""
"""
def visit_combination(self, combination): def visit_combination(self, combination):
"""Called by QCombination objects. """Called by QCombination objects."""
"""
return combination return combination
def visit_query(self, query): def visit_query(self, query):
"""Called by (New)Q objects. """Called by (New)Q objects."""
"""
return query return query
@ -49,8 +46,7 @@ class SimplificationVisitor(QNodeVisitor):
return combination return combination
def _query_conjunction(self, queries): def _query_conjunction(self, queries):
"""Merges query dicts - effectively &ing them together. """Merges query dicts - effectively &ing them together."""
"""
query_ops = set() query_ops = set()
combined_query = {} combined_query = {}
for query in queries: for query in queries:

2
setup.cfg
View File

@ -1,5 +1,5 @@
[flake8] [flake8]
ignore=E501,F401,F403,F405,I201,I202,W504, W605, W503 ignore=E501,F403,F405,I201,I202,W504,W605,W503,B007
exclude=build,dist,docs,venv,venv3,.tox,.eggs,tests exclude=build,dist,docs,venv,venv3,.tox,.eggs,tests
max-complexity=47 max-complexity=47
application-import-names=mongoengine,tests application-import-names=mongoengine,tests

2
setup.py
View File

@ -7,7 +7,7 @@ from setuptools.command.test import test as TestCommand
# Hack to silence atexit traceback in newer python versions # Hack to silence atexit traceback in newer python versions
try: try:
import multiprocessing import multiprocessing # noqa: F401
except ImportError: except ImportError:
pass pass

37
tests/document/test_class_methods.py
View File

@ -26,16 +26,14 @@ class TestClassMethods(unittest.TestCase):
self.db.drop_collection(collection) self.db.drop_collection(collection)
def test_definition(self): def test_definition(self):
"""Ensure that document may be defined using fields. """Ensure that document may be defined using fields."""
"""
assert ["_cls", "age", "id", "name"] == sorted(self.Person._fields.keys()) assert ["_cls", "age", "id", "name"] == sorted(self.Person._fields.keys())
assert ["IntField", "ObjectIdField", "StringField", "StringField"] == sorted( assert ["IntField", "ObjectIdField", "StringField", "StringField"] == sorted(
[x.__class__.__name__ for x in self.Person._fields.values()] x.__class__.__name__ for x in self.Person._fields.values()
) )
def test_get_db(self): def test_get_db(self):
"""Ensure that get_db returns the expected db. """Ensure that get_db returns the expected db."""
"""
db = self.Person._get_db() db = self.Person._get_db()
assert self.db == db assert self.db == db
@ -47,15 +45,13 @@ class TestClassMethods(unittest.TestCase):
assert collection_name == self.Person._get_collection_name() assert collection_name == self.Person._get_collection_name()
def test_get_collection(self): def test_get_collection(self):
"""Ensure that get_collection returns the expected collection. """Ensure that get_collection returns the expected collection."""
"""
collection_name = "person" collection_name = "person"
collection = self.Person._get_collection() collection = self.Person._get_collection()
assert self.db[collection_name] == collection assert self.db[collection_name] == collection
def test_drop_collection(self): def test_drop_collection(self):
"""Ensure that the collection may be dropped from the database. """Ensure that the collection may be dropped from the database."""
"""
collection_name = "person" collection_name = "person"
self.Person(name="Test").save() self.Person(name="Test").save()
assert collection_name in list_collection_names(self.db) assert collection_name in list_collection_names(self.db)
@ -77,7 +73,7 @@ class TestClassMethods(unittest.TestCase):
assert self.Person._meta["delete_rules"] == {(Job, "employee"): NULLIFY} assert self.Person._meta["delete_rules"] == {(Job, "employee"): NULLIFY}
def test_compare_indexes(self): def test_compare_indexes(self):
""" Ensure that the indexes are properly created and that """Ensure that the indexes are properly created and that
compare_indexes identifies the missing/extra indexes compare_indexes identifies the missing/extra indexes
""" """
@ -110,7 +106,7 @@ class TestClassMethods(unittest.TestCase):
} }
def test_compare_indexes_inheritance(self): def test_compare_indexes_inheritance(self):
""" Ensure that the indexes are properly created and that """Ensure that the indexes are properly created and that
compare_indexes identifies the missing/extra indexes for subclassed compare_indexes identifies the missing/extra indexes for subclassed
documents (_cls included) documents (_cls included)
""" """
@ -150,7 +146,7 @@ class TestClassMethods(unittest.TestCase):
} }
def test_compare_indexes_multiple_subclasses(self): def test_compare_indexes_multiple_subclasses(self):
""" Ensure that compare_indexes behaves correctly if called from a """Ensure that compare_indexes behaves correctly if called from a
class, which base class has multiple subclasses class, which base class has multiple subclasses
""" """
@ -203,7 +199,7 @@ class TestClassMethods(unittest.TestCase):
assert actual == expected assert actual == expected
def test_list_indexes_inheritance(self): def test_list_indexes_inheritance(self):
""" ensure that all of the indexes are listed regardless of the super- """ensure that all of the indexes are listed regardless of the super-
or sub-class that we call it from or sub-class that we call it from
""" """
@ -235,7 +231,7 @@ class TestClassMethods(unittest.TestCase):
assert BlogPost.list_indexes() == [ assert BlogPost.list_indexes() == [
[("_cls", 1), ("author", 1), ("tags", 1)], [("_cls", 1), ("author", 1), ("tags", 1)],
[("_cls", 1), ("author", 1), ("tags", 1), ("extra_text", 1)], [("_cls", 1), ("author", 1), ("tags", 1), ("extra_text", 1)],
[(u"_id", 1)], [("_id", 1)],
[("_cls", 1)], [("_cls", 1)],
] ]
@ -260,8 +256,7 @@ class TestClassMethods(unittest.TestCase):
assert Vaccine._meta["delete_rules"][(Cat, "vaccine_made")] == PULL assert Vaccine._meta["delete_rules"][(Cat, "vaccine_made")] == PULL
def test_collection_naming(self): def test_collection_naming(self):
"""Ensure that a collection with a specified name may be used. """Ensure that a collection with a specified name may be used."""
"""
class DefaultNamingTest(Document): class DefaultNamingTest(Document):
pass pass
@ -293,7 +288,7 @@ class TestClassMethods(unittest.TestCase):
assert "wibble" == InheritedAbstractNamingTest._get_collection_name() assert "wibble" == InheritedAbstractNamingTest._get_collection_name()
# Mixin tests # Mixin tests
class BaseMixin(object): class BaseMixin:
meta = {"collection": lambda c: c.__name__.lower()} meta = {"collection": lambda c: c.__name__.lower()}
class OldMixinNamingConvention(Document, BaseMixin): class OldMixinNamingConvention(Document, BaseMixin):
@ -304,7 +299,7 @@ class TestClassMethods(unittest.TestCase):
== OldMixinNamingConvention._get_collection_name() == OldMixinNamingConvention._get_collection_name()
) )
class BaseMixin(object): class BaseMixin:
meta = {"collection": lambda c: c.__name__.lower()} meta = {"collection": lambda c: c.__name__.lower()}
class BaseDocument(Document, BaseMixin): class BaseDocument(Document, BaseMixin):
@ -316,8 +311,7 @@ class TestClassMethods(unittest.TestCase):
assert "basedocument" == MyDocument._get_collection_name() assert "basedocument" == MyDocument._get_collection_name()
def test_custom_collection_name_operations(self): def test_custom_collection_name_operations(self):
"""Ensure that a collection with a specified name is used as expected. """Ensure that a collection with a specified name is used as expected."""
"""
collection_name = "personCollTest" collection_name = "personCollTest"
class Person(Document): class Person(Document):
@ -337,8 +331,7 @@ class TestClassMethods(unittest.TestCase):
assert collection_name not in list_collection_names(self.db) assert collection_name not in list_collection_names(self.db)
def test_collection_name_and_primary(self): def test_collection_name_and_primary(self):
"""Ensure that a collection with a specified name may be used. """Ensure that a collection with a specified name may be used."""
"""
class Person(Document): class Person(Document):
name = StringField(primary_key=True) name = StringField(primary_key=True)

7
tests/document/test_delta.py
View File

@ -8,7 +8,7 @@ from tests.utils import MongoDBTestCase
class TestDelta(MongoDBTestCase): class TestDelta(MongoDBTestCase):
def setUp(self): def setUp(self):
super(TestDelta, self).setUp() super().setUp()
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -643,7 +643,10 @@ class TestDelta(MongoDBTestCase):
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
assert doc._delta() == ({}, {},) assert doc._delta() == (
{},
{},
)
del doc.embedded_field.list_field[2].list_field del doc.embedded_field.list_field[2].list_field
assert doc._delta() == ( assert doc._delta() == (
{}, {},

12
tests/document/test_dynamic.py
View File

@ -10,7 +10,7 @@ __all__ = ("TestDynamicDocument",)
class TestDynamicDocument(MongoDBTestCase): class TestDynamicDocument(MongoDBTestCase):
def setUp(self): def setUp(self):
super(TestDynamicDocument, self).setUp() super().setUp()
class Person(DynamicDocument): class Person(DynamicDocument):
name = StringField() name = StringField()
@ -118,17 +118,17 @@ class TestDynamicDocument(MongoDBTestCase):
p.save() p.save()
raw_p = Person.objects.as_pymongo().get(id=p.id) raw_p = Person.objects.as_pymongo().get(id=p.id)
assert raw_p == {"_cls": u"Person", "_id": p.id, "name": u"Dean"} assert raw_p == {"_cls": "Person", "_id": p.id, "name": "Dean"}
p.name = "OldDean" p.name = "OldDean"
p.newattr = "garbage" p.newattr = "garbage"
p.save() p.save()
raw_p = Person.objects.as_pymongo().get(id=p.id) raw_p = Person.objects.as_pymongo().get(id=p.id)
assert raw_p == { assert raw_p == {
"_cls": u"Person", "_cls": "Person",
"_id": p.id, "_id": p.id,
"name": "OldDean", "name": "OldDean",
"newattr": u"garbage", "newattr": "garbage",
} }
def test_fields_containing_underscore(self): def test_fields_containing_underscore(self):
@ -144,14 +144,14 @@ class TestDynamicDocument(MongoDBTestCase):
p.save() p.save()
raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id) raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id)
assert raw_p == {"_id": p.id, "_name": u"Dean", "name": u"Dean"} assert raw_p == {"_id": p.id, "_name": "Dean", "name": "Dean"}
p.name = "OldDean" p.name = "OldDean"
p._name = "NewDean" p._name = "NewDean"
p._newattr1 = "garbage" # Unknown fields won't be added p._newattr1 = "garbage" # Unknown fields won't be added
p.save() p.save()
raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id) raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id)
assert raw_p == {"_id": p.id, "_name": u"NewDean", "name": u"OldDean"} assert raw_p == {"_id": p.id, "_name": "NewDean", "name": "OldDean"}
def test_dynamic_document_queries(self): def test_dynamic_document_queries(self):
"""Ensure we can query dynamic fields""" """Ensure we can query dynamic fields"""

36
tests/document/test_indexes.py
View File

@ -171,8 +171,7 @@ class TestIndexes(unittest.TestCase):
assert MyDoc._meta["index_specs"] == [{"fields": [("keywords", 1)]}] assert MyDoc._meta["index_specs"] == [{"fields": [("keywords", 1)]}]
def test_embedded_document_index_meta(self): def test_embedded_document_index_meta(self):
"""Ensure that embedded document indexes are created explicitly """Ensure that embedded document indexes are created explicitly"""
"""
class Rank(EmbeddedDocument): class Rank(EmbeddedDocument):
title = StringField(required=True) title = StringField(required=True)
@ -194,8 +193,7 @@ class TestIndexes(unittest.TestCase):
assert [("rank.title", 1)] in info assert [("rank.title", 1)] in info
def test_explicit_geo2d_index(self): def test_explicit_geo2d_index(self):
"""Ensure that geo2d indexes work when created via meta[indexes] """Ensure that geo2d indexes work when created via meta[indexes]"""
"""
class Place(Document): class Place(Document):
location = DictField() location = DictField()
@ -209,8 +207,7 @@ class TestIndexes(unittest.TestCase):
assert [("location.point", "2d")] in info assert [("location.point", "2d")] in info
def test_explicit_geo2d_index_embedded(self): def test_explicit_geo2d_index_embedded(self):
"""Ensure that geo2d indexes work when created via meta[indexes] """Ensure that geo2d indexes work when created via meta[indexes]"""
"""
class EmbeddedLocation(EmbeddedDocument): class EmbeddedLocation(EmbeddedDocument):
location = DictField() location = DictField()
@ -229,8 +226,7 @@ class TestIndexes(unittest.TestCase):
assert [("current.location.point", "2d")] in info assert [("current.location.point", "2d")] in info
def test_explicit_geosphere_index(self): def test_explicit_geosphere_index(self):
"""Ensure that geosphere indexes work when created via meta[indexes] """Ensure that geosphere indexes work when created via meta[indexes]"""
"""
class Place(Document): class Place(Document):
location = DictField() location = DictField()
@ -246,8 +242,7 @@ class TestIndexes(unittest.TestCase):
assert [("location.point", "2dsphere")] in info assert [("location.point", "2dsphere")] in info
def test_explicit_geohaystack_index(self): def test_explicit_geohaystack_index(self):
"""Ensure that geohaystack indexes work when created via meta[indexes] """Ensure that geohaystack indexes work when created via meta[indexes]"""
"""
pytest.skip( pytest.skip(
"GeoHaystack index creation is not supported for now" "GeoHaystack index creation is not supported for now"
"from meta, as it requires a bucketSize parameter." "from meta, as it requires a bucketSize parameter."
@ -268,8 +263,7 @@ class TestIndexes(unittest.TestCase):
assert [("location.point", "geoHaystack")] in info assert [("location.point", "geoHaystack")] in info
def test_create_geohaystack_index(self): def test_create_geohaystack_index(self):
"""Ensure that geohaystack indexes can be created """Ensure that geohaystack indexes can be created"""
"""
class Place(Document): class Place(Document):
location = DictField() location = DictField()
@ -364,8 +358,7 @@ class TestIndexes(unittest.TestCase):
assert sorted(info.keys()) == ["_cls_1_user_guid_1", "_id_"] assert sorted(info.keys()) == ["_cls_1_user_guid_1", "_id_"]
def test_embedded_document_index(self): def test_embedded_document_index(self):
"""Tests settings an index on an embedded document """Tests settings an index on an embedded document"""
"""
class Date(EmbeddedDocument): class Date(EmbeddedDocument):
year = IntField(db_field="yr") year = IntField(db_field="yr")
@ -382,8 +375,7 @@ class TestIndexes(unittest.TestCase):
assert sorted(info.keys()) == ["_id_", "date.yr_-1"] assert sorted(info.keys()) == ["_id_", "date.yr_-1"]
def test_list_embedded_document_index(self): def test_list_embedded_document_index(self):
"""Ensure list embedded documents can be indexed """Ensure list embedded documents can be indexed"""
"""
class Tag(EmbeddedDocument): class Tag(EmbeddedDocument):
name = StringField(db_field="tag") name = StringField(db_field="tag")
@ -419,8 +411,7 @@ class TestIndexes(unittest.TestCase):
assert sorted(info.keys()) == ["_cls_1", "_id_"] assert sorted(info.keys()) == ["_cls_1", "_id_"]
def test_covered_index(self): def test_covered_index(self):
"""Ensure that covered indexes can be used """Ensure that covered indexes can be used"""
"""
class Test(Document): class Test(Document):
a = IntField() a = IntField()
@ -558,8 +549,7 @@ class TestIndexes(unittest.TestCase):
assert [x.name for x in query_result] == sorted(names) assert [x.name for x in query_result] == sorted(names)
def test_unique(self): def test_unique(self):
"""Ensure that uniqueness constraints are applied to fields. """Ensure that uniqueness constraints are applied to fields."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -607,8 +597,7 @@ class TestIndexes(unittest.TestCase):
) )
def test_unique_with(self): def test_unique_with(self):
"""Ensure that unique_with constraints are applied to fields. """Ensure that unique_with constraints are applied to fields."""
"""
class Date(EmbeddedDocument): class Date(EmbeddedDocument):
year = IntField(db_field="yr") year = IntField(db_field="yr")
@ -633,8 +622,7 @@ class TestIndexes(unittest.TestCase):
post3.save() post3.save()
def test_unique_embedded_document(self): def test_unique_embedded_document(self):
"""Ensure that uniqueness constraints are applied to fields on embedded documents. """Ensure that uniqueness constraints are applied to fields on embedded documents."""
"""
class SubDocument(EmbeddedDocument): class SubDocument(EmbeddedDocument):
year = IntField(db_field="yr") year = IntField(db_field="yr")

37
tests/document/test_inheritance.py
View File

@ -45,8 +45,7 @@ class TestInheritance(MongoDBTestCase):
test_doc.delete() test_doc.delete()
def test_superclasses(self): def test_superclasses(self):
"""Ensure that the correct list of superclasses is assembled. """Ensure that the correct list of superclasses is assembled."""
"""
class Animal(Document): class Animal(Document):
meta = {"allow_inheritance": True} meta = {"allow_inheritance": True}
@ -216,8 +215,7 @@ class TestInheritance(MongoDBTestCase):
assert Pike._subclasses == ("Animal.Fish.Pike",) assert Pike._subclasses == ("Animal.Fish.Pike",)
def test_inheritance_meta_data(self): def test_inheritance_meta_data(self):
"""Ensure that document may inherit fields from a superclass document. """Ensure that document may inherit fields from a superclass document."""
"""
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -234,8 +232,7 @@ class TestInheritance(MongoDBTestCase):
assert Employee._get_collection_name() == Person._get_collection_name() assert Employee._get_collection_name() == Person._get_collection_name()
def test_inheritance_to_mongo_keys(self): def test_inheritance_to_mongo_keys(self):
"""Ensure that document may inherit fields from a superclass document. """Ensure that document may inherit fields from a superclass document."""
"""
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -259,7 +256,7 @@ class TestInheritance(MongoDBTestCase):
assert Employee._get_collection_name() == Person._get_collection_name() assert Employee._get_collection_name() == Person._get_collection_name()
def test_indexes_and_multiple_inheritance(self): def test_indexes_and_multiple_inheritance(self):
""" Ensure that all of the indexes are created for a document with """Ensure that all of the indexes are created for a document with
multiple inheritance. multiple inheritance.
""" """
@ -283,14 +280,11 @@ class TestInheritance(MongoDBTestCase):
C.ensure_indexes() C.ensure_indexes()
assert sorted( assert sorted(
[idx["key"] for idx in C._get_collection().index_information().values()] idx["key"] for idx in C._get_collection().index_information().values()
) == sorted( ) == sorted([[("_cls", 1), ("b", 1)], [("_id", 1)], [("_cls", 1), ("a", 1)]])
[[(u"_cls", 1), (u"b", 1)], [(u"_id", 1)], [(u"_cls", 1), (u"a", 1)]]
)
def test_polymorphic_queries(self): def test_polymorphic_queries(self):
"""Ensure that the correct subclasses are returned from a query """Ensure that the correct subclasses are returned from a query"""
"""
class Animal(Document): class Animal(Document):
meta = {"allow_inheritance": True} meta = {"allow_inheritance": True}
@ -347,8 +341,7 @@ class TestInheritance(MongoDBTestCase):
assert "_cls" not in obj assert "_cls" not in obj
def test_cant_turn_off_inheritance_on_subclass(self): def test_cant_turn_off_inheritance_on_subclass(self):
"""Ensure if inheritance is on in a subclass you cant turn it off. """Ensure if inheritance is on in a subclass you cant turn it off."""
"""
class Animal(Document): class Animal(Document):
name = StringField() name = StringField()
@ -474,7 +467,7 @@ class TestInheritance(MongoDBTestCase):
assert city.pk is None assert city.pk is None
# TODO: expected error? Shouldn't we create a new error type? # TODO: expected error? Shouldn't we create a new error type?
with pytest.raises(KeyError): with pytest.raises(KeyError):
setattr(city, "pk", 1) city.pk = 1
def test_allow_inheritance_embedded_document(self): def test_allow_inheritance_embedded_document(self):
"""Ensure embedded documents respect inheritance.""" """Ensure embedded documents respect inheritance."""
@ -498,8 +491,7 @@ class TestInheritance(MongoDBTestCase):
assert "_cls" in doc.to_mongo() assert "_cls" in doc.to_mongo()
def test_document_inheritance(self): def test_document_inheritance(self):
"""Ensure mutliple inheritance of abstract documents """Ensure mutliple inheritance of abstract documents"""
"""
class DateCreatedDocument(Document): class DateCreatedDocument(Document):
meta = {"allow_inheritance": True, "abstract": True} meta = {"allow_inheritance": True, "abstract": True}
@ -507,13 +499,8 @@ class TestInheritance(MongoDBTestCase):
class DateUpdatedDocument(Document): class DateUpdatedDocument(Document):
meta = {"allow_inheritance": True, "abstract": True} meta = {"allow_inheritance": True, "abstract": True}
try: class MyDocument(DateCreatedDocument, DateUpdatedDocument):
pass
class MyDocument(DateCreatedDocument, DateUpdatedDocument):
pass
except Exception:
assert False, "Couldn't create MyDocument class"
def test_abstract_documents(self): def test_abstract_documents(self):
"""Ensure that a document superclass can be marked as abstract """Ensure that a document superclass can be marked as abstract

41
tests/document/test_instance.py
View File

@ -160,8 +160,7 @@ class TestDocumentInstance(MongoDBTestCase):
Log.objects Log.objects
def test_repr(self): def test_repr(self):
"""Ensure that unicode representation works """Ensure that unicode representation works"""
"""
class Article(Document): class Article(Document):
title = StringField() title = StringField()
@ -169,7 +168,7 @@ class TestDocumentInstance(MongoDBTestCase):
def __unicode__(self): def __unicode__(self):
return self.title return self.title
doc = Article(title=u"привет мир") doc = Article(title="привет мир")
assert "<Article: привет мир>" == repr(doc) assert "<Article: привет мир>" == repr(doc)
@ -182,7 +181,7 @@ class TestDocumentInstance(MongoDBTestCase):
def __str__(self): def __str__(self):
return None return None
doc = Article(title=u"привет мир") doc = Article(title="привет мир")
assert "<Article: None>" == repr(doc) assert "<Article: None>" == repr(doc)
def test_queryset_resurrects_dropped_collection(self): def test_queryset_resurrects_dropped_collection(self):
@ -522,9 +521,9 @@ class TestDocumentInstance(MongoDBTestCase):
query_op = q.db.system.profile.find({"ns": "mongoenginetest.animal"})[0] query_op = q.db.system.profile.find({"ns": "mongoenginetest.animal"})[0]
assert query_op["op"] == "update" assert query_op["op"] == "update"
if mongo_db <= MONGODB_34: if mongo_db <= MONGODB_34:
assert set(query_op["query"].keys()) == set(["_id", "is_mammal"]) assert set(query_op["query"].keys()) == {"_id", "is_mammal"}
else: else:
assert set(query_op["command"]["q"].keys()) == set(["_id", "is_mammal"]) assert set(query_op["command"]["q"].keys()) == {"_id", "is_mammal"}
Animal.drop_collection() Animal.drop_collection()
@ -547,7 +546,7 @@ class TestDocumentInstance(MongoDBTestCase):
query_op = q.db.system.profile.find({"ns": "mongoenginetest.animal"})[0] query_op = q.db.system.profile.find({"ns": "mongoenginetest.animal"})[0]
assert query_op["op"] == "command" assert query_op["op"] == "command"
assert query_op["command"]["findAndModify"] == "animal" assert query_op["command"]["findAndModify"] == "animal"
assert set(query_op["command"]["query"].keys()) == set(["_id", "is_mammal"]) assert set(query_op["command"]["query"].keys()) == {"_id", "is_mammal"}
Animal.drop_collection() Animal.drop_collection()
@ -1429,11 +1428,11 @@ class TestDocumentInstance(MongoDBTestCase):
coll = self.Person._get_collection() coll = self.Person._get_collection()
doc = self.Person(name="John").save() doc = self.Person(name="John").save()
raw_doc = coll.find_one({"_id": doc.pk}) raw_doc = coll.find_one({"_id": doc.pk})
assert set(raw_doc.keys()) == set(["_id", "_cls", "name"]) assert set(raw_doc.keys()) == {"_id", "_cls", "name"}
doc.update(rename__name="first_name") doc.update(rename__name="first_name")
raw_doc = coll.find_one({"_id": doc.pk}) raw_doc = coll.find_one({"_id": doc.pk})
assert set(raw_doc.keys()) == set(["_id", "_cls", "first_name"]) assert set(raw_doc.keys()) == {"_id", "_cls", "first_name"}
assert raw_doc["first_name"] == "John" assert raw_doc["first_name"] == "John"
def test_inserts_if_you_set_the_pk(self): def test_inserts_if_you_set_the_pk(self):
@ -1553,8 +1552,7 @@ class TestDocumentInstance(MongoDBTestCase):
assert site.page.log_message == "Error: Dummy message" assert site.page.log_message == "Error: Dummy message"
def test_update_list_field(self): def test_update_list_field(self):
"""Test update on `ListField` with $pull + $in. """Test update on `ListField` with $pull + $in."""
"""
class Doc(Document): class Doc(Document):
foo = ListField(StringField()) foo = ListField(StringField())
@ -2043,7 +2041,7 @@ class TestDocumentInstance(MongoDBTestCase):
assert promoted_employee.details is None assert promoted_employee.details is None
def test_object_mixins(self): def test_object_mixins(self):
class NameMixin(object): class NameMixin:
name = StringField() name = StringField()
class Foo(EmbeddedDocument, NameMixin): class Foo(EmbeddedDocument, NameMixin):
@ -2057,7 +2055,7 @@ class TestDocumentInstance(MongoDBTestCase):
assert ["id", "name", "widgets"] == sorted(Bar._fields.keys()) assert ["id", "name", "widgets"] == sorted(Bar._fields.keys())
def test_mixin_inheritance(self): def test_mixin_inheritance(self):
class BaseMixIn(object): class BaseMixIn:
count = IntField() count = IntField()
data = StringField() data = StringField()
@ -2816,15 +2814,13 @@ class TestDocumentInstance(MongoDBTestCase):
register_connection("testdb-2", "mongoenginetest2") register_connection("testdb-2", "mongoenginetest2")
class A(Document): class A(Document):
"""Uses default db_alias """Uses default db_alias"""
"""
name = StringField() name = StringField()
meta = {"allow_inheritance": True} meta = {"allow_inheritance": True}
class B(A): class B(A):
"""Uses testdb-2 db_alias """Uses testdb-2 db_alias"""
"""
meta = {"db_alias": "testdb-2"} meta = {"db_alias": "testdb-2"}
@ -2933,7 +2929,7 @@ class TestDocumentInstance(MongoDBTestCase):
# $Where # $Where
assert ( assert (
u",".join( ",".join(
[ [
str(b) str(b)
for b in Book.objects.filter( for b in Book.objects.filter(
@ -3307,7 +3303,7 @@ class TestDocumentInstance(MongoDBTestCase):
for node_name, node in self.nodes.items(): for node_name, node in self.nodes.items():
node.expand() node.expand()
node.save(*args, **kwargs) node.save(*args, **kwargs)
super(NodesSystem, self).save(*args, **kwargs) super().save(*args, **kwargs)
NodesSystem.drop_collection() NodesSystem.drop_collection()
Node.drop_collection() Node.drop_collection()
@ -3612,8 +3608,7 @@ class TestDocumentInstance(MongoDBTestCase):
assert u_from_db.height is None assert u_from_db.height is None
def test_not_saved_eq(self): def test_not_saved_eq(self):
"""Ensure we can compare documents not saved. """Ensure we can compare documents not saved."""
"""
class Person(Document): class Person(Document):
pass pass
@ -3757,7 +3752,7 @@ class TestDocumentInstance(MongoDBTestCase):
_ = list(Jedi.objects) # Ensure a proper document loads without errors _ = list(Jedi.objects) # Ensure a proper document loads without errors
# Forces a document with a wrong shape (may occur in case of migration) # Forces a document with a wrong shape (may occur in case of migration)
value = u"I_should_be_a_dict" value = "I_should_be_a_dict"
coll.insert_one({"light_saber": value}) coll.insert_one({"light_saber": value})
with pytest.raises(InvalidDocumentError) as exc_info: with pytest.raises(InvalidDocumentError) as exc_info:
@ -3824,7 +3819,7 @@ class ObjectKeyTestCase(MongoDBTestCase):
class DBFieldMappingTest(MongoDBTestCase): class DBFieldMappingTest(MongoDBTestCase):
def setUp(self): def setUp(self):
class Fields(object): class Fields:
w1 = BooleanField(db_field="w2") w1 = BooleanField(db_field="w2")
x1 = BooleanField(db_field="x2") x1 = BooleanField(db_field="x2")

11
tests/document/test_validation.py
View File

@ -9,8 +9,7 @@ from tests.utils import MongoDBTestCase
class TestValidatorError(MongoDBTestCase): class TestValidatorError(MongoDBTestCase):
def test_to_dict(self): def test_to_dict(self):
"""Ensure a ValidationError handles error to_dict correctly. """Ensure a ValidationError handles error to_dict correctly."""
"""
error = ValidationError("root") error = ValidationError("root")
assert error.to_dict() == {} assert error.to_dict() == {}
@ -90,8 +89,7 @@ class TestValidatorError(MongoDBTestCase):
p.validate() p.validate()
def test_embedded_document_validation(self): def test_embedded_document_validation(self):
"""Ensure that embedded documents may be validated. """Ensure that embedded documents may be validated."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
date = DateTimeField() date = DateTimeField()
@ -212,10 +210,7 @@ class TestValidatorError(MongoDBTestCase):
child.reference = parent child.reference = parent
# Saving the child should not raise a ValidationError # Saving the child should not raise a ValidationError
try: child.save()
child.save()
except ValidationError as e:
self.fail("ValidationError raised: %s" % e.message)
if __name__ == "__main__": if __name__ == "__main__":

18
tests/fields/test_binary_field.py
View File

@ -13,14 +13,13 @@ BIN_VALUE = "\xa9\xf3\x8d(\xd7\x03\x84\xb4k[\x0f\xe3\xa2\x19\x85p[J\xa3\xd2>\xde
class TestBinaryField(MongoDBTestCase): class TestBinaryField(MongoDBTestCase):
def test_binary_fields(self): def test_binary_fields(self):
"""Ensure that binary fields can be stored and retrieved. """Ensure that binary fields can be stored and retrieved."""
"""
class Attachment(Document): class Attachment(Document):
content_type = StringField() content_type = StringField()
blob = BinaryField() blob = BinaryField()
BLOB = "\xe6\x00\xc4\xff\x07".encode("latin-1") BLOB = b"\xe6\x00\xc4\xff\x07"
MIME_TYPE = "application/octet-stream" MIME_TYPE = "application/octet-stream"
Attachment.drop_collection() Attachment.drop_collection()
@ -33,8 +32,7 @@ class TestBinaryField(MongoDBTestCase):
assert BLOB == bytes(attachment_1.blob) assert BLOB == bytes(attachment_1.blob)
def test_validation_succeeds(self): def test_validation_succeeds(self):
"""Ensure that valid values can be assigned to binary fields. """Ensure that valid values can be assigned to binary fields."""
"""
class AttachmentRequired(Document): class AttachmentRequired(Document):
blob = BinaryField(required=True) blob = BinaryField(required=True)
@ -45,11 +43,11 @@ class TestBinaryField(MongoDBTestCase):
attachment_required = AttachmentRequired() attachment_required = AttachmentRequired()
with pytest.raises(ValidationError): with pytest.raises(ValidationError):
attachment_required.validate() attachment_required.validate()
attachment_required.blob = Binary("\xe6\x00\xc4\xff\x07".encode("latin-1")) attachment_required.blob = Binary(b"\xe6\x00\xc4\xff\x07")
attachment_required.validate() attachment_required.validate()
_5_BYTES = "\xe6\x00\xc4\xff\x07".encode("latin-1") _5_BYTES = b"\xe6\x00\xc4\xff\x07"
_4_BYTES = "\xe6\x00\xc4\xff".encode("latin-1") _4_BYTES = b"\xe6\x00\xc4\xff"
with pytest.raises(ValidationError): with pytest.raises(ValidationError):
AttachmentSizeLimit(blob=_5_BYTES).validate() AttachmentSizeLimit(blob=_5_BYTES).validate()
AttachmentSizeLimit(blob=_4_BYTES).validate() AttachmentSizeLimit(blob=_4_BYTES).validate()
@ -60,7 +58,7 @@ class TestBinaryField(MongoDBTestCase):
class Attachment(Document): class Attachment(Document):
blob = BinaryField() blob = BinaryField()
for invalid_data in (2, u"Im_a_unicode", ["some_str"]): for invalid_data in (2, "Im_a_unicode", ["some_str"]):
with pytest.raises(ValidationError): with pytest.raises(ValidationError):
Attachment(blob=invalid_data).validate() Attachment(blob=invalid_data).validate()
@ -131,7 +129,7 @@ class TestBinaryField(MongoDBTestCase):
MyDocument.drop_collection() MyDocument.drop_collection()
bin_data = "\xe6\x00\xc4\xff\x07".encode("latin-1") bin_data = b"\xe6\x00\xc4\xff\x07"
doc = MyDocument(bin_field=bin_data).save() doc = MyDocument(bin_field=bin_data).save()
n_updated = MyDocument.objects(bin_field=bin_data).update_one( n_updated = MyDocument.objects(bin_field=bin_data).update_one(

12
tests/fields/test_cached_reference_field.py
View File

@ -190,9 +190,9 @@ class TestCachedReferenceField(MongoDBTestCase):
assert dict(a2.to_mongo()) == { assert dict(a2.to_mongo()) == {
"_id": a2.pk, "_id": a2.pk,
"name": u"Wilson Junior", "name": "Wilson Junior",
"tp": u"pf", "tp": "pf",
"father": {"_id": a1.pk, "tp": u"pj"}, "father": {"_id": a1.pk, "tp": "pj"},
} }
assert Person.objects(father=a1)._query == {"father._id": a1.pk} assert Person.objects(father=a1)._query == {"father._id": a1.pk}
@ -204,9 +204,9 @@ class TestCachedReferenceField(MongoDBTestCase):
a2.reload() a2.reload()
assert dict(a2.to_mongo()) == { assert dict(a2.to_mongo()) == {
"_id": a2.pk, "_id": a2.pk,
"name": u"Wilson Junior", "name": "Wilson Junior",
"tp": u"pf", "tp": "pf",
"father": {"_id": a1.pk, "tp": u"pf"}, "father": {"_id": a1.pk, "tp": "pf"},
} }
def test_cached_reference_fields_on_embedded_documents(self): def test_cached_reference_fields_on_embedded_documents(self):

2
tests/fields/test_complex_datetime_field.py
View File

@ -60,7 +60,7 @@ class ComplexDateTimeFieldTest(MongoDBTestCase):
assert log == log1 assert log == log1
# Test string padding # Test string padding
microsecond = map(int, [math.pow(10, x) for x in range(6)]) microsecond = map(int, (math.pow(10, x) for x in range(6)))
mm = dd = hh = ii = ss = [1, 10] mm = dd = hh = ii = ss = [1, 10]
for values in itertools.product([2014], mm, dd, hh, ii, ss, microsecond): for values in itertools.product([2014], mm, dd, hh, ii, ss, microsecond):

3
tests/fields/test_decimal_field.py
View File

@ -8,8 +8,7 @@ from tests.utils import MongoDBTestCase
class TestDecimalField(MongoDBTestCase): class TestDecimalField(MongoDBTestCase):
def test_validation(self): def test_validation(self):
"""Ensure that invalid values cannot be assigned to decimal fields. """Ensure that invalid values cannot be assigned to decimal fields."""
"""
class Person(Document): class Person(Document):
height = DecimalField(min_value=Decimal("0.1"), max_value=Decimal("3.5")) height = DecimalField(min_value=Decimal("0.1"), max_value=Decimal("3.5"))

12
tests/fields/test_email_field.py
View File

@ -1,8 +1,6 @@
import sys
import pytest import pytest
from mongoengine import * from mongoengine import Document, EmailField, ValidationError
from tests.utils import MongoDBTestCase from tests.utils import MongoDBTestCase
@ -30,11 +28,11 @@ class TestEmailField(MongoDBTestCase):
user.validate() user.validate()
# unicode domain # unicode domain
user = User(email=u"user@пример.рф") user = User(email="user@пример.рф")
user.validate() user.validate()
# invalid unicode domain # invalid unicode domain
user = User(email=u"user@пример") user = User(email="user@пример")
with pytest.raises(ValidationError): with pytest.raises(ValidationError):
user.validate() user.validate()
@ -48,7 +46,7 @@ class TestEmailField(MongoDBTestCase):
email = EmailField() email = EmailField()
# unicode user shouldn't validate by default... # unicode user shouldn't validate by default...
user = User(email=u"Dörte@Sörensen.example.com") user = User(email="Dörte@Sörensen.example.com")
with pytest.raises(ValidationError): with pytest.raises(ValidationError):
user.validate() user.validate()
@ -56,7 +54,7 @@ class TestEmailField(MongoDBTestCase):
class User(Document): class User(Document):
email = EmailField(allow_utf8_user=True) email = EmailField(allow_utf8_user=True)
user = User(email=u"Dörte@Sörensen.example.com") user = User(email="Dörte@Sörensen.example.com")
user.validate() user.validate()
def test_email_field_domain_whitelist(self): def test_email_field_domain_whitelist(self):

8
tests/fields/test_embedded_document_field.py
View File

@ -74,7 +74,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute # Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info: with pytest.raises(InvalidQueryError) as exc_info:
Person.objects(settings__notexist="bar").first() Person.objects(settings__notexist="bar").first()
assert str(exc_info.value) == u'Cannot resolve field "notexist"' assert str(exc_info.value) == 'Cannot resolve field "notexist"'
with pytest.raises(LookUpError): with pytest.raises(LookUpError):
Person.objects.only("settings.notexist") Person.objects.only("settings.notexist")
@ -110,7 +110,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute # Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info: with pytest.raises(InvalidQueryError) as exc_info:
assert Person.objects(settings__notexist="bar").first().id == p.id assert Person.objects(settings__notexist="bar").first().id == p.id
assert str(exc_info.value) == u'Cannot resolve field "notexist"' assert str(exc_info.value) == 'Cannot resolve field "notexist"'
# Test existing attribute # Test existing attribute
assert Person.objects(settings__base_foo="basefoo").first().id == p.id assert Person.objects(settings__base_foo="basefoo").first().id == p.id
@ -318,7 +318,7 @@ class TestGenericEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute # Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info: with pytest.raises(InvalidQueryError) as exc_info:
Person.objects(settings__notexist="bar").first() Person.objects(settings__notexist="bar").first()
assert str(exc_info.value) == u'Cannot resolve field "notexist"' assert str(exc_info.value) == 'Cannot resolve field "notexist"'
with pytest.raises(LookUpError): with pytest.raises(LookUpError):
Person.objects.only("settings.notexist") Person.objects.only("settings.notexist")
@ -346,7 +346,7 @@ class TestGenericEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute # Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info: with pytest.raises(InvalidQueryError) as exc_info:
assert Person.objects(settings__notexist="bar").first().id == p.id assert Person.objects(settings__notexist="bar").first().id == p.id
assert str(exc_info.value) == u'Cannot resolve field "notexist"' assert str(exc_info.value) == 'Cannot resolve field "notexist"'
# Test existing attribute # Test existing attribute
assert Person.objects(settings__base_foo="basefoo").first().id == p.id assert Person.objects(settings__base_foo="basefoo").first().id == p.id

75
tests/fields/test_fields.py
View File

@ -292,7 +292,7 @@ class TestField(MongoDBTestCase):
HandleNoneFields.drop_collection() HandleNoneFields.drop_collection()
doc = HandleNoneFields() doc = HandleNoneFields()
doc.str_fld = u"spam ham egg" doc.str_fld = "spam ham egg"
doc.int_fld = 42 doc.int_fld = 42
doc.flt_fld = 4.2 doc.flt_fld = 4.2
doc.com_dt_fld = datetime.datetime.utcnow() doc.com_dt_fld = datetime.datetime.utcnow()
@ -328,7 +328,7 @@ class TestField(MongoDBTestCase):
HandleNoneFields.drop_collection() HandleNoneFields.drop_collection()
doc = HandleNoneFields() doc = HandleNoneFields()
doc.str_fld = u"spam ham egg" doc.str_fld = "spam ham egg"
doc.int_fld = 42 doc.int_fld = 42
doc.flt_fld = 4.2 doc.flt_fld = 4.2
doc.comp_dt_fld = datetime.datetime.utcnow() doc.comp_dt_fld = datetime.datetime.utcnow()
@ -426,9 +426,9 @@ class TestField(MongoDBTestCase):
def test_list_validation(self): def test_list_validation(self):
"""Ensure that a list field only accepts lists with valid elements.""" """Ensure that a list field only accepts lists with valid elements."""
access_level_choices = ( access_level_choices = (
("a", u"Administration"), ("a", "Administration"),
("b", u"Manager"), ("b", "Manager"),
("c", u"Staff"), ("c", "Staff"),
) )
class User(Document): class User(Document):
@ -476,7 +476,7 @@ class TestField(MongoDBTestCase):
post.access_list = ["a", "b"] post.access_list = ["a", "b"]
post.validate() post.validate()
assert post.get_access_list_display() == u"Administration, Manager" assert post.get_access_list_display() == "Administration, Manager"
post.comments = ["a"] post.comments = ["a"]
with pytest.raises(ValidationError): with pytest.raises(ValidationError):
@ -544,8 +544,7 @@ class TestField(MongoDBTestCase):
post.validate() post.validate()
def test_sorted_list_sorting(self): def test_sorted_list_sorting(self):
"""Ensure that a sorted list field properly sorts values. """Ensure that a sorted list field properly sorts values."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
order = IntField() order = IntField()
@ -661,8 +660,7 @@ class TestField(MongoDBTestCase):
) )
def test_list_field_manipulative_operators(self): def test_list_field_manipulative_operators(self):
"""Ensure that ListField works with standard list operators that manipulate the list. """Ensure that ListField works with standard list operators that manipulate the list."""
"""
class BlogPost(Document): class BlogPost(Document):
ref = StringField() ref = StringField()
@ -1359,9 +1357,9 @@ class TestField(MongoDBTestCase):
foo.delete() foo.delete()
bar = Bar.objects.get() bar = Bar.objects.get()
with pytest.raises(DoesNotExist): with pytest.raises(DoesNotExist):
getattr(bar, "ref") bar.ref
with pytest.raises(DoesNotExist): with pytest.raises(DoesNotExist):
getattr(bar, "generic_ref") bar.generic_ref
# When auto_dereference is disabled, there is no trouble returning DBRef # When auto_dereference is disabled, there is no trouble returning DBRef
bar = Bar.objects.get() bar = Bar.objects.get()
@ -1372,8 +1370,7 @@ class TestField(MongoDBTestCase):
assert bar.generic_ref == {"_ref": expected, "_cls": "Foo"} assert bar.generic_ref == {"_ref": expected, "_cls": "Foo"}
def test_list_item_dereference(self): def test_list_item_dereference(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -1398,8 +1395,7 @@ class TestField(MongoDBTestCase):
assert group_obj.members[1].name == user2.name assert group_obj.members[1].name == user2.name
def test_recursive_reference(self): def test_recursive_reference(self):
"""Ensure that ReferenceFields can reference their own documents. """Ensure that ReferenceFields can reference their own documents."""
"""
class Employee(Document): class Employee(Document):
name = StringField() name = StringField()
@ -1426,8 +1422,7 @@ class TestField(MongoDBTestCase):
assert peter.friends == friends assert peter.friends == friends
def test_recursive_embedding(self): def test_recursive_embedding(self):
"""Ensure that EmbeddedDocumentFields can contain their own documents. """Ensure that EmbeddedDocumentFields can contain their own documents."""
"""
class TreeNode(EmbeddedDocument): class TreeNode(EmbeddedDocument):
name = StringField() name = StringField()
@ -1503,8 +1498,7 @@ class TestField(MongoDBTestCase):
AbstractDoc.drop_collection() AbstractDoc.drop_collection()
def test_reference_class_with_abstract_parent(self): def test_reference_class_with_abstract_parent(self):
"""Ensure that a class with an abstract parent can be referenced. """Ensure that a class with an abstract parent can be referenced."""
"""
class Sibling(Document): class Sibling(Document):
name = StringField() name = StringField()
@ -1574,8 +1568,7 @@ class TestField(MongoDBTestCase):
brother.save() brother.save()
def test_generic_reference(self): def test_generic_reference(self):
"""Ensure that a GenericReferenceField properly dereferences items. """Ensure that a GenericReferenceField properly dereferences items."""
"""
class Link(Document): class Link(Document):
title = StringField() title = StringField()
@ -1614,8 +1607,7 @@ class TestField(MongoDBTestCase):
assert isinstance(bm.bookmark_object, Link) assert isinstance(bm.bookmark_object, Link)
def test_generic_reference_list(self): def test_generic_reference_list(self):
"""Ensure that a ListField properly dereferences generic references. """Ensure that a ListField properly dereferences generic references."""
"""
class Link(Document): class Link(Document):
title = StringField() title = StringField()
@ -1718,8 +1710,7 @@ class TestField(MongoDBTestCase):
assert bm.bookmark_object == post_1 assert bm.bookmark_object == post_1
def test_generic_reference_string_choices(self): def test_generic_reference_string_choices(self):
"""Ensure that a GenericReferenceField can handle choices as strings """Ensure that a GenericReferenceField can handle choices as strings"""
"""
class Link(Document): class Link(Document):
title = StringField() title = StringField()
@ -1811,8 +1802,7 @@ class TestField(MongoDBTestCase):
assert user.bookmarks == [post_1] assert user.bookmarks == [post_1]
def test_generic_reference_list_item_modification(self): def test_generic_reference_list_item_modification(self):
"""Ensure that modifications of related documents (through generic reference) don't influence on querying """Ensure that modifications of related documents (through generic reference) don't influence on querying"""
"""
class Post(Document): class Post(Document):
title = StringField() title = StringField()
@ -1900,8 +1890,7 @@ class TestField(MongoDBTestCase):
assert doc == doc2 assert doc == doc2
def test_choices_allow_using_sets_as_choices(self): def test_choices_allow_using_sets_as_choices(self):
"""Ensure that sets can be used when setting choices """Ensure that sets can be used when setting choices"""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(choices={"M", "L"}) size = StringField(choices={"M", "L"})
@ -1920,8 +1909,7 @@ class TestField(MongoDBTestCase):
shirt.validate() shirt.validate()
def test_choices_validation_accept_possible_value(self): def test_choices_validation_accept_possible_value(self):
"""Ensure that value is in a container of allowed values. """Ensure that value is in a container of allowed values."""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(choices=("S", "M")) size = StringField(choices=("S", "M"))
@ -1930,8 +1918,7 @@ class TestField(MongoDBTestCase):
shirt.validate() shirt.validate()
def test_choices_validation_reject_unknown_value(self): def test_choices_validation_reject_unknown_value(self):
"""Ensure that unallowed value are rejected upon validation """Ensure that unallowed value are rejected upon validation"""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(choices=("S", "M")) size = StringField(choices=("S", "M"))
@ -1989,8 +1976,7 @@ class TestField(MongoDBTestCase):
shirt1.validate() shirt1.validate()
def test_simple_choices_validation(self): def test_simple_choices_validation(self):
"""Ensure that value is in a container of allowed values. """Ensure that value is in a container of allowed values."""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(max_length=3, choices=("S", "M", "L", "XL", "XXL")) size = StringField(max_length=3, choices=("S", "M", "L", "XL", "XXL"))
@ -2039,12 +2025,11 @@ class TestField(MongoDBTestCase):
shirt.validate() shirt.validate()
def test_simple_choices_validation_invalid_value(self): def test_simple_choices_validation_invalid_value(self):
"""Ensure that error messages are correct. """Ensure that error messages are correct."""
"""
SIZES = ("S", "M", "L", "XL", "XXL") SIZES = ("S", "M", "L", "XL", "XXL")
COLORS = (("R", "Red"), ("B", "Blue")) COLORS = (("R", "Red"), ("B", "Blue"))
SIZE_MESSAGE = u"Value must be one of ('S', 'M', 'L', 'XL', 'XXL')" SIZE_MESSAGE = "Value must be one of ('S', 'M', 'L', 'XL', 'XXL')"
COLOR_MESSAGE = u"Value must be one of ['R', 'B']" COLOR_MESSAGE = "Value must be one of ['R', 'B']"
class Shirt(Document): class Shirt(Document):
size = StringField(max_length=3, choices=SIZES) size = StringField(max_length=3, choices=SIZES)
@ -2107,7 +2092,7 @@ class TestField(MongoDBTestCase):
assert "comments" in error_dict assert "comments" in error_dict
assert 1 in error_dict["comments"] assert 1 in error_dict["comments"]
assert "content" in error_dict["comments"][1] assert "content" in error_dict["comments"][1]
assert error_dict["comments"][1]["content"] == u"Field is required" assert error_dict["comments"][1]["content"] == "Field is required"
post.comments[1].content = "here we go" post.comments[1].content = "here we go"
post.validate() post.validate()
@ -2119,7 +2104,7 @@ class TestField(MongoDBTestCase):
class EnumField(BaseField): class EnumField(BaseField):
def __init__(self, **kwargs): def __init__(self, **kwargs):
super(EnumField, self).__init__(**kwargs) super().__init__(**kwargs)
def to_mongo(self, value): def to_mongo(self, value):
return value return value
@ -2621,11 +2606,11 @@ class TestEmbeddedDocumentListField(MongoDBTestCase):
""" """
post = self.BlogPost( post = self.BlogPost(
comments=[ comments=[
self.Comments(author="user1", message=u"сообщение"), self.Comments(author="user1", message="сообщение"),
self.Comments(author="user2", message=u"хабарлама"), self.Comments(author="user2", message="хабарлама"),
] ]
).save() ).save()
assert post.comments.get(message=u"сообщение").author == "user1" assert post.comments.get(message="сообщение").author == "user1"
def test_save(self): def test_save(self):
""" """

54
tests/fields/test_file_field.py
View File

@ -11,7 +11,7 @@ from mongoengine import *
from mongoengine.connection import get_db from mongoengine.connection import get_db
try: try:
from PIL import Image from PIL import Image # noqa: F401
HAS_PIL = True HAS_PIL = True
except ImportError: except ImportError:
@ -48,15 +48,14 @@ class TestFileField(MongoDBTestCase):
DemoFile.objects.create() DemoFile.objects.create()
def test_file_fields(self): def test_file_fields(self):
"""Ensure that file fields can be written to and their data retrieved """Ensure that file fields can be written to and their data retrieved"""
"""
class PutFile(Document): class PutFile(Document):
the_file = FileField() the_file = FileField()
PutFile.drop_collection() PutFile.drop_collection()
text = "Hello, World!".encode("latin-1") text = b"Hello, World!"
content_type = "text/plain" content_type = "text/plain"
putfile = PutFile() putfile = PutFile()
@ -91,16 +90,15 @@ class TestFileField(MongoDBTestCase):
result.the_file.delete() result.the_file.delete()
def test_file_fields_stream(self): def test_file_fields_stream(self):
"""Ensure that file fields can be written to and their data retrieved """Ensure that file fields can be written to and their data retrieved"""
"""
class StreamFile(Document): class StreamFile(Document):
the_file = FileField() the_file = FileField()
StreamFile.drop_collection() StreamFile.drop_collection()
text = "Hello, World!".encode("latin-1") text = b"Hello, World!"
more_text = "Foo Bar".encode("latin-1") more_text = b"Foo Bar"
content_type = "text/plain" content_type = "text/plain"
streamfile = StreamFile() streamfile = StreamFile()
@ -135,8 +133,8 @@ class TestFileField(MongoDBTestCase):
StreamFile.drop_collection() StreamFile.drop_collection()
text = "Hello, World!".encode("latin-1") text = b"Hello, World!"
more_text = "Foo Bar".encode("latin-1") more_text = b"Foo Bar"
streamfile = StreamFile() streamfile = StreamFile()
streamfile.save() streamfile.save()
@ -165,8 +163,8 @@ class TestFileField(MongoDBTestCase):
class SetFile(Document): class SetFile(Document):
the_file = FileField() the_file = FileField()
text = "Hello, World!".encode("latin-1") text = b"Hello, World!"
more_text = "Foo Bar".encode("latin-1") more_text = b"Foo Bar"
SetFile.drop_collection() SetFile.drop_collection()
@ -194,7 +192,7 @@ class TestFileField(MongoDBTestCase):
GridDocument.drop_collection() GridDocument.drop_collection()
with tempfile.TemporaryFile() as f: with tempfile.TemporaryFile() as f:
f.write("Hello World!".encode("latin-1")) f.write(b"Hello World!")
f.flush() f.flush()
# Test without default # Test without default
@ -211,7 +209,7 @@ class TestFileField(MongoDBTestCase):
assert doc_b.the_file.grid_id == doc_c.the_file.grid_id assert doc_b.the_file.grid_id == doc_c.the_file.grid_id
# Test with default # Test with default
doc_d = GridDocument(the_file="".encode("latin-1")) doc_d = GridDocument(the_file=b"")
doc_d.save() doc_d.save()
doc_e = GridDocument.objects.with_id(doc_d.id) doc_e = GridDocument.objects.with_id(doc_d.id)
@ -228,8 +226,7 @@ class TestFileField(MongoDBTestCase):
assert ["doc_b", "doc_e"] == grid_fs.list() assert ["doc_b", "doc_e"] == grid_fs.list()
def test_file_uniqueness(self): def test_file_uniqueness(self):
"""Ensure that each instance of a FileField is unique """Ensure that each instance of a FileField is unique"""
"""
class TestFile(Document): class TestFile(Document):
name = StringField() name = StringField()
@ -238,7 +235,7 @@ class TestFileField(MongoDBTestCase):
# First instance # First instance
test_file = TestFile() test_file = TestFile()
test_file.name = "Hello, World!" test_file.name = "Hello, World!"
test_file.the_file.put("Hello, World!".encode("latin-1")) test_file.the_file.put(b"Hello, World!")
test_file.save() test_file.save()
# Second instance # Second instance
@ -285,8 +282,7 @@ class TestFileField(MongoDBTestCase):
assert test_file.the_file.get().length == 4971 assert test_file.the_file.get().length == 4971
def test_file_boolean(self): def test_file_boolean(self):
"""Ensure that a boolean test of a FileField indicates its presence """Ensure that a boolean test of a FileField indicates its presence"""
"""
class TestFile(Document): class TestFile(Document):
the_file = FileField() the_file = FileField()
@ -295,9 +291,7 @@ class TestFileField(MongoDBTestCase):
test_file = TestFile() test_file = TestFile()
assert not bool(test_file.the_file) assert not bool(test_file.the_file)
test_file.the_file.put( test_file.the_file.put(b"Hello, World!", content_type="text/plain")
"Hello, World!".encode("latin-1"), content_type="text/plain"
)
test_file.save() test_file.save()
assert bool(test_file.the_file) assert bool(test_file.the_file)
@ -319,7 +313,7 @@ class TestFileField(MongoDBTestCase):
class TestFile(Document): class TestFile(Document):
the_file = FileField() the_file = FileField()
text = "Hello, World!".encode("latin-1") text = b"Hello, World!"
content_type = "text/plain" content_type = "text/plain"
testfile = TestFile() testfile = TestFile()
@ -363,7 +357,7 @@ class TestFileField(MongoDBTestCase):
testfile.the_file.put(text, content_type=content_type, filename="hello") testfile.the_file.put(text, content_type=content_type, filename="hello")
testfile.save() testfile.save()
text = "Bonjour, World!".encode("latin-1") text = b"Bonjour, World!"
testfile.the_file.replace(text, content_type=content_type, filename="hello") testfile.the_file.replace(text, content_type=content_type, filename="hello")
testfile.save() testfile.save()
@ -387,7 +381,7 @@ class TestFileField(MongoDBTestCase):
TestImage.drop_collection() TestImage.drop_collection()
with tempfile.TemporaryFile() as f: with tempfile.TemporaryFile() as f:
f.write("Hello World!".encode("latin-1")) f.write(b"Hello World!")
f.flush() f.flush()
t = TestImage() t = TestImage()
@ -503,21 +497,21 @@ class TestFileField(MongoDBTestCase):
# First instance # First instance
test_file = TestFile() test_file = TestFile()
test_file.name = "Hello, World!" test_file.name = "Hello, World!"
test_file.the_file.put("Hello, World!".encode("latin-1"), name="hello.txt") test_file.the_file.put(b"Hello, World!", name="hello.txt")
test_file.save() test_file.save()
data = get_db("test_files").macumba.files.find_one() data = get_db("test_files").macumba.files.find_one()
assert data.get("name") == "hello.txt" assert data.get("name") == "hello.txt"
test_file = TestFile.objects.first() test_file = TestFile.objects.first()
assert test_file.the_file.read() == "Hello, World!".encode("latin-1") assert test_file.the_file.read() == b"Hello, World!"
test_file = TestFile.objects.first() test_file = TestFile.objects.first()
test_file.the_file = "Hello, World!".encode("latin-1") test_file.the_file = b"Hello, World!"
test_file.save() test_file.save()
test_file = TestFile.objects.first() test_file = TestFile.objects.first()
assert test_file.the_file.read() == "Hello, World!".encode("latin-1") assert test_file.the_file.read() == b"Hello, World!"
def test_copyable(self): def test_copyable(self):
class PutFile(Document): class PutFile(Document):
@ -525,7 +519,7 @@ class TestFileField(MongoDBTestCase):
PutFile.drop_collection() PutFile.drop_collection()
text = "Hello, World!".encode("latin-1") text = b"Hello, World!"
content_type = "text/plain" content_type = "text/plain"
putfile = PutFile() putfile = PutFile()

3
tests/fields/test_float_field.py
View File

@ -19,8 +19,7 @@ class TestFloatField(MongoDBTestCase):
assert 1 == TestDocument.objects(float_fld__ne=1).count() assert 1 == TestDocument.objects(float_fld__ne=1).count()
def test_validation(self): def test_validation(self):
"""Ensure that invalid values cannot be assigned to float fields. """Ensure that invalid values cannot be assigned to float fields."""
"""
class Person(Document): class Person(Document):
height = FloatField(min_value=0.1, max_value=3.5) height = FloatField(min_value=0.1, max_value=3.5)

11
tests/fields/test_geo_fields.py
View File

@ -8,7 +8,7 @@ class TestGeoField(MongoDBTestCase):
def _test_for_expected_error(self, Cls, loc, expected): def _test_for_expected_error(self, Cls, loc, expected):
try: try:
Cls(loc=loc).validate() Cls(loc=loc).validate()
self.fail("Should not validate the location {0}".format(loc)) self.fail(f"Should not validate the location {loc}")
except ValidationError as e: except ValidationError as e:
assert expected == e.to_dict()["loc"] assert expected == e.to_dict()["loc"]
@ -290,8 +290,7 @@ class TestGeoField(MongoDBTestCase):
Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate() Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate()
def test_indexes_geopoint(self): def test_indexes_geopoint(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields."""
"""
class Event(Document): class Event(Document):
title = StringField() title = StringField()
@ -317,8 +316,7 @@ class TestGeoField(MongoDBTestCase):
assert geo_indicies == [{"fields": [("venue.location", "2d")]}] assert geo_indicies == [{"fields": [("venue.location", "2d")]}]
def test_indexes_2dsphere(self): def test_indexes_2dsphere(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields."""
"""
class Event(Document): class Event(Document):
title = StringField() title = StringField()
@ -332,8 +330,7 @@ class TestGeoField(MongoDBTestCase):
assert {"fields": [("point", "2dsphere")]} in geo_indicies assert {"fields": [("point", "2dsphere")]} in geo_indicies
def test_indexes_2dsphere_embedded(self): def test_indexes_2dsphere_embedded(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields."""
"""
class Venue(EmbeddedDocument): class Venue(EmbeddedDocument):
name = StringField() name = StringField()

3
tests/fields/test_int_field.py
View File

@ -7,8 +7,7 @@ from tests.utils import MongoDBTestCase
class TestIntField(MongoDBTestCase): class TestIntField(MongoDBTestCase):
def test_int_validation(self): def test_int_validation(self):
"""Ensure that invalid values cannot be assigned to int fields. """Ensure that invalid values cannot be assigned to int fields."""
"""
class Person(Document): class Person(Document):
age = IntField(min_value=0, max_value=110) age = IntField(min_value=0, max_value=110)

3
tests/fields/test_long_field.py
View File

@ -25,8 +25,7 @@ class TestLongField(MongoDBTestCase):
assert isinstance(doc.some_long, int) assert isinstance(doc.some_long, int)
def test_long_validation(self): def test_long_validation(self):
"""Ensure that invalid values cannot be assigned to long fields. """Ensure that invalid values cannot be assigned to long fields."""
"""
class TestDocument(Document): class TestDocument(Document):
value = LongField(min_value=0, max_value=110) value = LongField(min_value=0, max_value=110)

6
tests/fields/test_map_field.py
View File

@ -135,11 +135,11 @@ class TestMapField(MongoDBTestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
tree = BlogPost(info_dict={u"éééé": {"description": u"VALUE: éééé"}}) tree = BlogPost(info_dict={"éééé": {"description": "VALUE: éééé"}})
tree.save() tree.save()
assert ( assert (
BlogPost.objects.get(id=tree.id).info_dict[u"éééé"].description BlogPost.objects.get(id=tree.id).info_dict["éééé"].description
== u"VALUE: éééé" == "VALUE: éééé"
) )

5
tests/fields/test_reference_field.py
View File

@ -87,7 +87,7 @@ class TestReferenceField(MongoDBTestCase):
parent = ReferenceField("self", dbref=False) parent = ReferenceField("self", dbref=False)
p = Person(name="Steve", parent=DBRef("person", "abcdefghijklmnop")) p = Person(name="Steve", parent=DBRef("person", "abcdefghijklmnop"))
assert p.to_mongo() == SON([("name", u"Steve"), ("parent", "abcdefghijklmnop")]) assert p.to_mongo() == SON([("name", "Steve"), ("parent", "abcdefghijklmnop")])
def test_objectid_reference_fields(self): def test_objectid_reference_fields(self):
class Person(Document): class Person(Document):
@ -107,8 +107,7 @@ class TestReferenceField(MongoDBTestCase):
assert p.parent == p1 assert p.parent == p1
def test_undefined_reference(self): def test_undefined_reference(self):
"""Ensure that ReferenceFields may reference undefined Documents. """Ensure that ReferenceFields may reference undefined Documents."""
"""
class Product(Document): class Product(Document):
name = StringField() name = StringField()

4
tests/fields/test_sequence_field.py
View File

@ -166,8 +166,8 @@ class TestSequenceField(MongoDBTestCase):
ids = [i.id for i in Person.objects] ids = [i.id for i in Person.objects]
assert ids == list(range(1, 11)) assert ids == list(range(1, 11))
id = [i.id for i in Animal.objects] _id = [i.id for i in Animal.objects]
assert id == list(range(1, 11)) assert _id == list(range(1, 11))
c = self.db["mongoengine.counters"].find_one({"_id": "person.id"}) c = self.db["mongoengine.counters"].find_one({"_id": "person.id"})
assert c["next"] == 10 assert c["next"] == 10

7
tests/fields/test_url_field.py
View File

@ -26,7 +26,7 @@ class TestURLField(MongoDBTestCase):
url = URLField() url = URLField()
link = Link() link = Link()
link.url = u"http://привет.com" link.url = "http://привет.com"
# TODO fix URL validation - this *IS* a valid URL # TODO fix URL validation - this *IS* a valid URL
# For now we just want to make sure that the error message is correct # For now we just want to make sure that the error message is correct
@ -34,12 +34,11 @@ class TestURLField(MongoDBTestCase):
link.validate() link.validate()
assert ( assert (
str(exc_info.value) str(exc_info.value)
== u"ValidationError (Link:None) (Invalid URL: http://\u043f\u0440\u0438\u0432\u0435\u0442.com: ['url'])" == "ValidationError (Link:None) (Invalid URL: http://\u043f\u0440\u0438\u0432\u0435\u0442.com: ['url'])"
) )
def test_url_scheme_validation(self): def test_url_scheme_validation(self):
"""Ensure that URLFields validate urls with specific schemes properly. """Ensure that URLFields validate urls with specific schemes properly."""
"""
class Link(Document): class Link(Document):
url = URLField() url = URLField()

3
tests/fields/test_uuid_field.py
View File

@ -17,8 +17,7 @@ class TestUUIDField(MongoDBTestCase):
assert get_as_pymongo(person) == {"_id": person.id, "api_key": str(uid)} assert get_as_pymongo(person) == {"_id": person.id, "api_key": str(uid)}
def test_field_string(self): def test_field_string(self):
"""Test UUID fields storing as String """Test UUID fields storing as String"""
"""
Person.drop_collection() Person.drop_collection()
uu = uuid.uuid4() uu = uuid.uuid4()

2
tests/fixtures.py
View File

@ -53,7 +53,7 @@ signals.post_save.connect(PickleSignalsTest.post_save, sender=PickleSignalsTest)
signals.post_delete.connect(PickleSignalsTest.post_delete, sender=PickleSignalsTest) signals.post_delete.connect(PickleSignalsTest.post_delete, sender=PickleSignalsTest)
class Mixin(object): class Mixin:
name = StringField() name = StringField()

9
tests/queryset/test_field_list.py
View File

@ -148,8 +148,7 @@ class TestOnlyExcludeAll(unittest.TestCase):
assert qs._loaded_fields.as_dict() == {"c": {"$slice": 2}, "a": 1} assert qs._loaded_fields.as_dict() == {"c": {"$slice": 2}, "a": 1}
def test_only(self): def test_only(self):
"""Ensure that QuerySet.only only returns the requested fields. """Ensure that QuerySet.only only returns the requested fields."""
"""
person = self.Person(name="test", age=25) person = self.Person(name="test", age=25)
person.save() person.save()
@ -365,8 +364,7 @@ class TestOnlyExcludeAll(unittest.TestCase):
Email.drop_collection() Email.drop_collection()
def test_slicing_fields(self): def test_slicing_fields(self):
"""Ensure that query slicing an array works. """Ensure that query slicing an array works."""
"""
class Numbers(Document): class Numbers(Document):
n = ListField(IntField()) n = ListField(IntField())
@ -401,8 +399,7 @@ class TestOnlyExcludeAll(unittest.TestCase):
assert numbers.n == [-5, -4, -3, -2, -1] assert numbers.n == [-5, -4, -3, -2, -1]
def test_slicing_nested_fields(self): def test_slicing_nested_fields(self):
"""Ensure that query slicing an embedded array works. """Ensure that query slicing an embedded array works."""
"""
class EmbeddedNumber(EmbeddedDocument): class EmbeddedNumber(EmbeddedDocument):
n = ListField(IntField()) n = ListField(IntField())

4
tests/queryset/test_geo.py
View File

@ -496,8 +496,8 @@ class TestGeoQueries(MongoDBTestCase):
p.save() p.save()
qs = Place.objects().only("location") qs = Place.objects().only("location")
assert qs.as_pymongo()[0]["location"] == { assert qs.as_pymongo()[0]["location"] == {
u"type": u"Point", "type": "Point",
u"coordinates": [24.946861267089844, 60.16311983618494], "coordinates": [24.946861267089844, 60.16311983618494],
} }
def test_2dsphere_point_sets_correctly(self): def test_2dsphere_point_sets_correctly(self):

7
tests/queryset/test_pickable.py
View File

@ -1,8 +1,6 @@
import pickle import pickle
import unittest
from mongoengine import Document, IntField, StringField from mongoengine import Document, IntField, StringField
from mongoengine.connection import connect
from tests.utils import MongoDBTestCase from tests.utils import MongoDBTestCase
@ -18,18 +16,15 @@ class TestQuerysetPickable(MongoDBTestCase):
""" """
def setUp(self): def setUp(self):
super(TestQuerysetPickable, self).setUp() super().setUp()
self.john = Person.objects.create(name="John", age=21) self.john = Person.objects.create(name="John", age=21)
def test_picke_simple_qs(self): def test_picke_simple_qs(self):
qs = Person.objects.all() qs = Person.objects.all()
pickle.dumps(qs) pickle.dumps(qs)
def _get_loaded(self, qs): def _get_loaded(self, qs):
s = pickle.dumps(qs) s = pickle.dumps(qs)
return pickle.loads(s) return pickle.loads(s)
def test_unpickle(self): def test_unpickle(self):

290
tests/queryset/test_queryset.py
View File

@ -5,7 +5,6 @@ from decimal import Decimal
from bson import DBRef, ObjectId from bson import DBRef, ObjectId
import pymongo import pymongo
from pymongo.read_concern import ReadConcern
from pymongo.read_preferences import ReadPreference from pymongo.read_preferences import ReadPreference
from pymongo.results import UpdateResult from pymongo.results import UpdateResult
import pytest import pytest
@ -60,8 +59,7 @@ class TestQueryset(unittest.TestCase):
self.mongodb_version = get_mongodb_version() self.mongodb_version = get_mongodb_version()
def test_initialisation(self): def test_initialisation(self):
"""Ensure that a QuerySet is correctly initialised by QuerySetManager. """Ensure that a QuerySet is correctly initialised by QuerySetManager."""
"""
assert isinstance(self.Person.objects, QuerySet) assert isinstance(self.Person.objects, QuerySet)
assert ( assert (
self.Person.objects._collection.name == self.Person._get_collection_name() self.Person.objects._collection.name == self.Person._get_collection_name()
@ -114,7 +112,7 @@ class TestQueryset(unittest.TestCase):
def test_slicing_sets_empty_limit_skip(self): def test_slicing_sets_empty_limit_skip(self):
self.Person.objects.insert( self.Person.objects.insert(
[self.Person(name="User {}".format(i), age=i) for i in range(5)], [self.Person(name=f"User {i}", age=i) for i in range(5)],
load_bulk=False, load_bulk=False,
) )
@ -271,8 +269,7 @@ class TestQueryset(unittest.TestCase):
) )
def test_find_one(self): def test_find_one(self):
"""Ensure that a query using find_one returns a valid result. """Ensure that a query using find_one returns a valid result."""
"""
person1 = self.Person(name="User A", age=20) person1 = self.Person(name="User A", age=20)
person1.save() person1.save()
person2 = self.Person(name="User B", age=30) person2 = self.Person(name="User B", age=30)
@ -317,8 +314,7 @@ class TestQueryset(unittest.TestCase):
self.Person.objects.get() self.Person.objects.get()
def test_get_multiple_match_raises_multipleobjectsreturned(self): def test_get_multiple_match_raises_multipleobjectsreturned(self):
"""Ensure that a query using ``get`` returns at most one result. """Ensure that a query using ``get`` returns at most one result."""
"""
assert self.Person.objects().count() == 0 assert self.Person.objects().count() == 0
person1 = self.Person(name="User A", age=20) person1 = self.Person(name="User A", age=20)
@ -351,8 +347,7 @@ class TestQueryset(unittest.TestCase):
assert person == person3 assert person == person3
def test_find_array_position(self): def test_find_array_position(self):
"""Ensure that query by array position works. """Ensure that query by array position works."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
name = StringField() name = StringField()
@ -453,7 +448,7 @@ class TestQueryset(unittest.TestCase):
# test iterating over the result set # test iterating over the result set
cnt = 0 cnt = 0
for a in A.objects.batch_size(10): for _ in A.objects.batch_size(10):
cnt += 1 cnt += 1
assert cnt == 100 assert cnt == 100
@ -461,7 +456,7 @@ class TestQueryset(unittest.TestCase):
qs = A.objects.all() qs = A.objects.all()
qs = qs.limit(10).batch_size(20).skip(91) qs = qs.limit(10).batch_size(20).skip(91)
cnt = 0 cnt = 0
for a in qs: for _ in qs:
cnt += 1 cnt += 1
assert cnt == 9 assert cnt == 9
@ -1141,8 +1136,7 @@ class TestQueryset(unittest.TestCase):
assert q == 2 assert q == 2
def test_repeated_iteration(self): def test_repeated_iteration(self):
"""Ensure that QuerySet rewinds itself one iteration finishes. """Ensure that QuerySet rewinds itself one iteration finishes."""
"""
self.Person(name="Person 1").save() self.Person(name="Person 1").save()
self.Person(name="Person 2").save() self.Person(name="Person 2").save()
@ -1151,7 +1145,7 @@ class TestQueryset(unittest.TestCase):
people2 = [person for person in queryset] people2 = [person for person in queryset]
# Check that it still works even if iteration is interrupted. # Check that it still works even if iteration is interrupted.
for person in queryset: for _person in queryset:
break break
people3 = [person for person in queryset] people3 = [person for person in queryset]
@ -1187,12 +1181,11 @@ class TestQueryset(unittest.TestCase):
assert "[<Doc: 1>, <Doc: 2>, <Doc: 3>]" == "%s" % docs assert "[<Doc: 1>, <Doc: 2>, <Doc: 3>]" == "%s" % docs
assert docs.count(with_limit_and_skip=True) == 3 assert docs.count(with_limit_and_skip=True) == 3
for doc in docs: for _ in docs:
assert ".. queryset mid-iteration .." == repr(docs) assert ".. queryset mid-iteration .." == repr(docs)
def test_regex_query_shortcuts(self): def test_regex_query_shortcuts(self):
"""Ensure that contains, startswith, endswith, etc work. """Ensure that contains, startswith, endswith, etc work."""
"""
person = self.Person(name="Guido van Rossum") person = self.Person(name="Guido van Rossum")
person.save() person.save()
@ -1248,8 +1241,7 @@ class TestQueryset(unittest.TestCase):
assert obj == person assert obj == person
def test_not(self): def test_not(self):
"""Ensure that the __not operator works as expected. """Ensure that the __not operator works as expected."""
"""
alice = self.Person(name="Alice", age=25) alice = self.Person(name="Alice", age=25)
alice.save() alice.save()
@ -1260,8 +1252,7 @@ class TestQueryset(unittest.TestCase):
assert obj is None assert obj is None
def test_filter_chaining(self): def test_filter_chaining(self):
"""Ensure filters can be chained together. """Ensure filters can be chained together."""
"""
class Blog(Document): class Blog(Document):
id = StringField(primary_key=True) id = StringField(primary_key=True)
@ -1337,8 +1328,7 @@ class TestQueryset(unittest.TestCase):
assert qs[i] == expected[i] assert qs[i] == expected[i]
def test_ordering(self): def test_ordering(self):
"""Ensure default ordering is applied and can be overridden. """Ensure default ordering is applied and can be overridden."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -1408,8 +1398,7 @@ class TestQueryset(unittest.TestCase):
assert ORDER_BY_KEY not in q.get_ops()[0][CMD_QUERY_KEY] assert ORDER_BY_KEY not in q.get_ops()[0][CMD_QUERY_KEY]
def test_no_ordering_for_get(self): def test_no_ordering_for_get(self):
""" Ensure that Doc.objects.get doesn't use any ordering. """Ensure that Doc.objects.get doesn't use any ordering."""
"""
ORDER_BY_KEY, CMD_QUERY_KEY = get_key_compat(self.mongodb_version) ORDER_BY_KEY, CMD_QUERY_KEY = get_key_compat(self.mongodb_version)
class BlogPost(Document): class BlogPost(Document):
@ -1485,8 +1474,7 @@ class TestQueryset(unittest.TestCase):
assert result.author is None assert result.author is None
def test_find_dict_item(self): def test_find_dict_item(self):
"""Ensure that DictField items may be found. """Ensure that DictField items may be found."""
"""
class BlogPost(Document): class BlogPost(Document):
info = DictField() info = DictField()
@ -1502,8 +1490,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_exec_js_query(self): def test_exec_js_query(self):
"""Ensure that queries are properly formed for use in exec_js. """Ensure that queries are properly formed for use in exec_js."""
"""
class BlogPost(Document): class BlogPost(Document):
hits = IntField() hits = IntField()
@ -1540,8 +1527,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_exec_js_field_sub(self): def test_exec_js_field_sub(self):
"""Ensure that field substitutions occur properly in exec_js functions. """Ensure that field substitutions occur properly in exec_js functions."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
content = StringField(db_field="body") content = StringField(db_field="body")
@ -1583,9 +1569,9 @@ class TestQueryset(unittest.TestCase):
results = BlogPost.objects.exec_js(code) results = BlogPost.objects.exec_js(code)
expected_results = [ expected_results = [
{u"comment": u"cool", u"document": u"post1"}, {"comment": "cool", "document": "post1"},
{u"comment": u"yay", u"document": u"post1"}, {"comment": "yay", "document": "post1"},
{u"comment": u"nice stuff", u"document": u"post2"}, {"comment": "nice stuff", "document": "post2"},
] ]
assert results == expected_results assert results == expected_results
@ -1597,8 +1583,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_delete(self): def test_delete(self):
"""Ensure that documents are properly deleted from the database. """Ensure that documents are properly deleted from the database."""
"""
self.Person(name="User A", age=20).save() self.Person(name="User A", age=20).save()
self.Person(name="User B", age=30).save() self.Person(name="User B", age=30).save()
self.Person(name="User C", age=40).save() self.Person(name="User C", age=40).save()
@ -1612,8 +1597,7 @@ class TestQueryset(unittest.TestCase):
assert self.Person.objects.count() == 0 assert self.Person.objects.count() == 0
def test_reverse_delete_rule_cascade(self): def test_reverse_delete_rule_cascade(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1745,8 +1729,7 @@ class TestQueryset(unittest.TestCase):
assert 0 == Category.objects.count() assert 0 == Category.objects.count()
def test_reverse_delete_rule_nullify(self): def test_reverse_delete_rule_nullify(self):
"""Ensure nullification of references to deleted documents. """Ensure nullification of references to deleted documents."""
"""
class Category(Document): class Category(Document):
name = StringField() name = StringField()
@ -1842,8 +1825,7 @@ class TestQueryset(unittest.TestCase):
self.Person.objects.delete() self.Person.objects.delete()
def test_reverse_delete_rule_pull(self): def test_reverse_delete_rule_pull(self):
"""Ensure pulling of references to deleted documents. """Ensure pulling of references to deleted documents."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1918,8 +1900,7 @@ class TestQueryset(unittest.TestCase):
assert 8 == Log.objects.count() assert 8 == Log.objects.count()
def test_delete_with_limit_handles_delete_rules(self): def test_delete_with_limit_handles_delete_rules(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1951,8 +1932,7 @@ class TestQueryset(unittest.TestCase):
assert del_result is None assert del_result is None
def test_reference_field_find(self): def test_reference_field_find(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1973,8 +1953,7 @@ class TestQueryset(unittest.TestCase):
assert 1 == BlogPost.objects(author__in=["%s" % me.pk]).count() assert 1 == BlogPost.objects(author__in=["%s" % me.pk]).count()
def test_reference_field_find_dbref(self): def test_reference_field_find_dbref(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -2058,8 +2037,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.objects.update_one(inc__review=0.1) # test with floats BlogPost.objects.update_one(inc__review=0.1) # test with floats
def test_update_listfield_operator(self): def test_update_listfield_operator(self):
"""Ensure that atomic updates work properly. """Ensure that atomic updates work properly."""
"""
class BlogPost(Document): class BlogPost(Document):
tags = ListField(StringField()) tags = ListField(StringField())
@ -2107,8 +2085,7 @@ class TestQueryset(unittest.TestCase):
assert "title" not in pymongo_doc assert "title" not in pymongo_doc
def test_update_push_with_position(self): def test_update_push_with_position(self):
"""Ensure that the 'push' update with position works properly. """Ensure that the 'push' update with position works properly."""
"""
class BlogPost(Document): class BlogPost(Document):
slug = StringField() slug = StringField()
@ -2133,8 +2110,7 @@ class TestQueryset(unittest.TestCase):
assert post.tags == ["scala", "mongodb", "python", "java"] assert post.tags == ["scala", "mongodb", "python", "java"]
def test_update_push_list_of_list(self): def test_update_push_list_of_list(self):
"""Ensure that the 'push' update operation works in the list of list """Ensure that the 'push' update operation works in the list of list"""
"""
class BlogPost(Document): class BlogPost(Document):
slug = StringField() slug = StringField()
@ -2149,8 +2125,7 @@ class TestQueryset(unittest.TestCase):
assert post.tags == [["value1", 123]] assert post.tags == [["value1", 123]]
def test_update_push_and_pull_add_to_set(self): def test_update_push_and_pull_add_to_set(self):
"""Ensure that the 'pull' update operation works correctly. """Ensure that the 'pull' update operation works correctly."""
"""
class BlogPost(Document): class BlogPost(Document):
slug = StringField() slug = StringField()
@ -2259,8 +2234,7 @@ class TestQueryset(unittest.TestCase):
) )
def test_pull_from_nested_embedded_using_in_nin(self): def test_pull_from_nested_embedded_using_in_nin(self):
"""Ensure that the 'pull' update operation works on embedded documents using 'in' and 'nin' operators. """Ensure that the 'pull' update operation works on embedded documents using 'in' and 'nin' operators."""
"""
class User(EmbeddedDocument): class User(EmbeddedDocument):
name = StringField() name = StringField()
@ -2491,8 +2465,7 @@ class TestQueryset(unittest.TestCase):
assert doc.pk == doc.embedded[0]._instance.pk assert doc.pk == doc.embedded[0]._instance.pk
def test_order_by(self): def test_order_by(self):
"""Ensure that QuerySets may be ordered. """Ensure that QuerySets may be ordered."""
"""
self.Person(name="User B", age=40).save() self.Person(name="User B", age=40).save()
self.Person(name="User A", age=20).save() self.Person(name="User A", age=20).save()
self.Person(name="User C", age=30).save() self.Person(name="User C", age=30).save()
@ -2560,8 +2533,7 @@ class TestQueryset(unittest.TestCase):
self.assertSequence(qs, expected) self.assertSequence(qs, expected)
def test_order_by_chaining(self): def test_order_by_chaining(self):
"""Ensure that an order_by query chains properly and allows .only() """Ensure that an order_by query chains properly and allows .only()"""
"""
self.Person(name="User B", age=40).save() self.Person(name="User B", age=40).save()
self.Person(name="User A", age=20).save() self.Person(name="User A", age=20).save()
self.Person(name="User C", age=30).save() self.Person(name="User C", age=30).save()
@ -2635,8 +2607,7 @@ class TestQueryset(unittest.TestCase):
assert op[CMD_QUERY_KEY][COMMENT_KEY] == "looking for an adult" assert op[CMD_QUERY_KEY][COMMENT_KEY] == "looking for an adult"
def test_map_reduce(self): def test_map_reduce(self):
"""Ensure map/reduce is both mapping and reducing. """Ensure map/reduce is both mapping and reducing."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -2749,10 +2720,10 @@ class TestQueryset(unittest.TestCase):
f1.save() f1.save()
# persons of first family # persons of first family
Person(id=1, family=f1, name=u"Wilson Jr", age=21).save() Person(id=1, family=f1, name="Wilson Jr", age=21).save()
Person(id=2, family=f1, name=u"Wilson Father", age=45).save() Person(id=2, family=f1, name="Wilson Father", age=45).save()
Person(id=3, family=f1, name=u"Eliana Costa", age=40).save() Person(id=3, family=f1, name="Eliana Costa", age=40).save()
Person(id=4, family=f1, name=u"Tayza Mariana", age=17).save() Person(id=4, family=f1, name="Tayza Mariana", age=17).save()
# creating second family # creating second family
f2 = Family(id=2, log="Av prof frasc brunno") f2 = Family(id=2, log="Av prof frasc brunno")
@ -2830,10 +2801,10 @@ class TestQueryset(unittest.TestCase):
"_id": 1, "_id": 1,
"value": { "value": {
"persons": [ "persons": [
{"age": 21, "name": u"Wilson Jr"}, {"age": 21, "name": "Wilson Jr"},
{"age": 45, "name": u"Wilson Father"}, {"age": 45, "name": "Wilson Father"},
{"age": 40, "name": u"Eliana Costa"}, {"age": 40, "name": "Eliana Costa"},
{"age": 17, "name": u"Tayza Mariana"}, {"age": 17, "name": "Tayza Mariana"},
], ],
"totalAge": 123, "totalAge": 123,
}, },
@ -2843,9 +2814,9 @@ class TestQueryset(unittest.TestCase):
"_id": 2, "_id": 2,
"value": { "value": {
"persons": [ "persons": [
{"age": 16, "name": u"Isabella Luanna"}, {"age": 16, "name": "Isabella Luanna"},
{"age": 36, "name": u"Sandra Mara"}, {"age": 36, "name": "Sandra Mara"},
{"age": 10, "name": u"Igor Gabriel"}, {"age": 10, "name": "Igor Gabriel"},
], ],
"totalAge": 62, "totalAge": 62,
}, },
@ -2855,8 +2826,8 @@ class TestQueryset(unittest.TestCase):
"_id": 3, "_id": 3,
"value": { "value": {
"persons": [ "persons": [
{"age": 30, "name": u"Arthur WA"}, {"age": 30, "name": "Arthur WA"},
{"age": 25, "name": u"Paula Leonel"}, {"age": 25, "name": "Paula Leonel"},
], ],
"totalAge": 55, "totalAge": 55,
}, },
@ -2988,8 +2959,7 @@ class TestQueryset(unittest.TestCase):
Link.drop_collection() Link.drop_collection()
def test_item_frequencies(self): def test_item_frequencies(self):
"""Ensure that item frequencies are properly generated from lists. """Ensure that item frequencies are properly generated from lists."""
"""
class BlogPost(Document): class BlogPost(Document):
hits = IntField() hits = IntField()
@ -3003,7 +2973,7 @@ class TestQueryset(unittest.TestCase):
def test_assertions(f): def test_assertions(f):
f = {key: int(val) for key, val in f.items()} f = {key: int(val) for key, val in f.items()}
assert set(["music", "film", "actors", "watch"]) == set(f.keys()) assert {"music", "film", "actors", "watch"} == set(f.keys())
assert f["music"] == 3 assert f["music"] == 3
assert f["actors"] == 2 assert f["actors"] == 2
assert f["watch"] == 2 assert f["watch"] == 2
@ -3017,7 +2987,7 @@ class TestQueryset(unittest.TestCase):
# Ensure query is taken into account # Ensure query is taken into account
def test_assertions(f): def test_assertions(f):
f = {key: int(val) for key, val in f.items()} f = {key: int(val) for key, val in f.items()}
assert set(["music", "actors", "watch"]) == set(f.keys()) assert {"music", "actors", "watch"} == set(f.keys())
assert f["music"] == 2 assert f["music"] == 2
assert f["actors"] == 1 assert f["actors"] == 1
assert f["watch"] == 1 assert f["watch"] == 1
@ -3045,7 +3015,7 @@ class TestQueryset(unittest.TestCase):
# Check item_frequencies works for non-list fields # Check item_frequencies works for non-list fields
def test_assertions(f): def test_assertions(f):
assert set([1, 2]) == set(f.keys()) assert {1, 2} == set(f.keys())
assert f[1] == 1 assert f[1] == 1
assert f[2] == 2 assert f[2] == 2
@ -3057,8 +3027,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_item_frequencies_on_embedded(self): def test_item_frequencies_on_embedded(self):
"""Ensure that item frequencies are properly generated from lists. """Ensure that item frequencies are properly generated from lists."""
"""
class Phone(EmbeddedDocument): class Phone(EmbeddedDocument):
number = StringField() number = StringField()
@ -3083,7 +3052,7 @@ class TestQueryset(unittest.TestCase):
def test_assertions(f): def test_assertions(f):
f = {key: int(val) for key, val in f.items()} f = {key: int(val) for key, val in f.items()}
assert set(["62-3331-1656", "62-3332-1656"]) == set(f.keys()) assert {"62-3331-1656", "62-3332-1656"} == set(f.keys())
assert f["62-3331-1656"] == 2 assert f["62-3331-1656"] == 2
assert f["62-3332-1656"] == 1 assert f["62-3332-1656"] == 1
@ -3095,7 +3064,7 @@ class TestQueryset(unittest.TestCase):
# Ensure query is taken into account # Ensure query is taken into account
def test_assertions(f): def test_assertions(f):
f = {key: int(val) for key, val in f.items()} f = {key: int(val) for key, val in f.items()}
assert set(["62-3331-1656"]) == set(f.keys()) assert {"62-3331-1656"} == set(f.keys())
assert f["62-3331-1656"] == 2 assert f["62-3331-1656"] == 2
exec_js = Person.objects(phone__number="62-3331-1656").item_frequencies( exec_js = Person.objects(phone__number="62-3331-1656").item_frequencies(
@ -3162,10 +3131,10 @@ class TestQueryset(unittest.TestCase):
p.save() p.save()
ot = Person.objects.item_frequencies("extra.tag", map_reduce=False) ot = Person.objects.item_frequencies("extra.tag", map_reduce=False)
assert ot == {None: 1.0, u"friend": 1.0} assert ot == {None: 1.0, "friend": 1.0}
ot = Person.objects.item_frequencies("extra.tag", map_reduce=True) ot = Person.objects.item_frequencies("extra.tag", map_reduce=True)
assert ot == {None: 1.0, u"friend": 1.0} assert ot == {None: 1.0, "friend": 1.0}
def test_item_frequencies_with_0_values(self): def test_item_frequencies_with_0_values(self):
class Test(Document): class Test(Document):
@ -3201,10 +3170,10 @@ class TestQueryset(unittest.TestCase):
Test.drop_collection() Test.drop_collection()
for i in range(50): for _ in range(50):
Test(val=1).save() Test(val=1).save()
for i in range(20): for _ in range(20):
Test(val=2).save() Test(val=2).save()
freqs = Test.objects.item_frequencies("val", map_reduce=False, normalize=True) freqs = Test.objects.item_frequencies("val", map_reduce=False, normalize=True)
@ -3214,8 +3183,7 @@ class TestQueryset(unittest.TestCase):
assert freqs == {1: 50.0 / 70, 2: 20.0 / 70} assert freqs == {1: 50.0 / 70, 2: 20.0 / 70}
def test_average(self): def test_average(self):
"""Ensure that field can be averaged correctly. """Ensure that field can be averaged correctly."""
"""
self.Person(name="person", age=0).save() self.Person(name="person", age=0).save()
assert int(self.Person.objects.average("age")) == 0 assert int(self.Person.objects.average("age")) == 0
@ -3238,7 +3206,7 @@ class TestQueryset(unittest.TestCase):
for i, weight in enumerate(ages): for i, weight in enumerate(ages):
self.Person( self.Person(
name="test meta%i", person_meta=self.PersonMeta(weight=weight) name=f"test meta{i}", person_meta=self.PersonMeta(weight=weight)
).save() ).save()
assert ( assert (
@ -3255,8 +3223,7 @@ class TestQueryset(unittest.TestCase):
assert self.Person.objects.filter(age__gte=50).average("age") == avg assert self.Person.objects.filter(age__gte=50).average("age") == avg
def test_sum(self): def test_sum(self):
"""Ensure that field can be summed over correctly. """Ensure that field can be summed over correctly."""
"""
ages = [23, 54, 12, 94, 27] ages = [23, 54, 12, 94, 27]
for i, age in enumerate(ages): for i, age in enumerate(ages):
self.Person(name="test%s" % i, age=age).save() self.Person(name="test%s" % i, age=age).save()
@ -3278,7 +3245,7 @@ class TestQueryset(unittest.TestCase):
# test summing over a filtered queryset # test summing over a filtered queryset
assert self.Person.objects.filter(age__gte=50).sum("age") == sum( assert self.Person.objects.filter(age__gte=50).sum("age") == sum(
[a for a in ages if a >= 50] a for a in ages if a >= 50
) )
def test_sum_over_db_field(self): def test_sum_over_db_field(self):
@ -3406,19 +3373,21 @@ class TestQueryset(unittest.TestCase):
assert Doc.objects.sum("values") == 1360 assert Doc.objects.sum("values") == 1360
def test_distinct(self): def test_distinct(self):
"""Ensure that the QuerySet.distinct method works. """Ensure that the QuerySet.distinct method works."""
"""
self.Person(name="Mr Orange", age=20).save() self.Person(name="Mr Orange", age=20).save()
self.Person(name="Mr White", age=20).save() self.Person(name="Mr White", age=20).save()
self.Person(name="Mr Orange", age=30).save() self.Person(name="Mr Orange", age=30).save()
self.Person(name="Mr Pink", age=30).save() self.Person(name="Mr Pink", age=30).save()
assert set(self.Person.objects.distinct("name")) == set( assert set(self.Person.objects.distinct("name")) == {
["Mr Orange", "Mr White", "Mr Pink"] "Mr Orange",
) "Mr White",
assert set(self.Person.objects.distinct("age")) == set([20, 30]) "Mr Pink",
assert set(self.Person.objects(age=30).distinct("name")) == set( }
["Mr Orange", "Mr Pink"] assert set(self.Person.objects.distinct("age")) == {20, 30}
) assert set(self.Person.objects(age=30).distinct("name")) == {
"Mr Orange",
"Mr Pink",
}
def test_distinct_handles_references(self): def test_distinct_handles_references(self):
class Foo(Document): class Foo(Document):
@ -3479,8 +3448,8 @@ class TestQueryset(unittest.TestCase):
assert count == 1 assert count == 1
News( News(
title=u"As eleições no Brasil já estão em planejamento", title="As eleições no Brasil já estão em planejamento",
content=u"A candidata dilma roussef já começa o teu planejamento", content="A candidata dilma roussef já começa o teu planejamento",
is_active=False, is_active=False,
).save() ).save()
@ -3547,8 +3516,7 @@ class TestQueryset(unittest.TestCase):
assert Foo.objects.distinct("bar") == [bar] assert Foo.objects.distinct("bar") == [bar]
def test_distinct_handles_db_field(self): def test_distinct_handles_db_field(self):
"""Ensure that distinct resolves field name to db_field as expected. """Ensure that distinct resolves field name to db_field as expected."""
"""
class Product(Document): class Product(Document):
product_id = IntField(db_field="pid") product_id = IntField(db_field="pid")
@ -3559,8 +3527,8 @@ class TestQueryset(unittest.TestCase):
Product(product_id=2).save() Product(product_id=2).save()
Product(product_id=1).save() Product(product_id=1).save()
assert set(Product.objects.distinct("product_id")) == set([1, 2]) assert set(Product.objects.distinct("product_id")) == {1, 2}
assert set(Product.objects.distinct("pid")) == set([1, 2]) assert set(Product.objects.distinct("pid")) == {1, 2}
Product.drop_collection() Product.drop_collection()
@ -3644,8 +3612,7 @@ class TestQueryset(unittest.TestCase):
assert Foo.objects.distinct("bar_lst") == [bar_1, bar_2] assert Foo.objects.distinct("bar_lst") == [bar_1, bar_2]
def test_custom_manager(self): def test_custom_manager(self):
"""Ensure that custom QuerySetManager instances work as expected. """Ensure that custom QuerySetManager instances work as expected."""
"""
class BlogPost(Document): class BlogPost(Document):
tags = ListField(StringField()) tags = ListField(StringField())
@ -3746,8 +3713,7 @@ class TestQueryset(unittest.TestCase):
assert 1 == Bar.objects.count() assert 1 == Bar.objects.count()
def test_query_value_conversion(self): def test_query_value_conversion(self):
"""Ensure that query values are properly converted when necessary. """Ensure that query values are properly converted when necessary."""
"""
class BlogPost(Document): class BlogPost(Document):
author = ReferenceField(self.Person) author = ReferenceField(self.Person)
@ -3773,8 +3739,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_update_value_conversion(self): def test_update_value_conversion(self):
"""Ensure that values used in updates are converted before use. """Ensure that values used in updates are converted before use."""
"""
class Group(Document): class Group(Document):
members = ListField(ReferenceField(self.Person)) members = ListField(ReferenceField(self.Person))
@ -3799,8 +3764,7 @@ class TestQueryset(unittest.TestCase):
Group.drop_collection() Group.drop_collection()
def test_bulk(self): def test_bulk(self):
"""Ensure bulk querying by object id returns a proper dict. """Ensure bulk querying by object id returns a proper dict."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -3838,8 +3802,7 @@ class TestQueryset(unittest.TestCase):
self.Person.drop_collection() self.Person.drop_collection()
def test_custom_querysets(self): def test_custom_querysets(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3859,8 +3822,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_set_manager_directly(self): def test_custom_querysets_set_manager_directly(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3883,8 +3845,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_managers_directly(self): def test_custom_querysets_managers_directly(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySetManager(QuerySetManager): class CustomQuerySetManager(QuerySetManager):
@staticmethod @staticmethod
@ -3905,8 +3866,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_inherited(self): def test_custom_querysets_inherited(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3928,8 +3888,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_inherited_direct(self): def test_custom_querysets_inherited_direct(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3990,8 +3949,7 @@ class TestQueryset(unittest.TestCase):
assert A.objects(b=[{"c": "c"}]).count() == 0 assert A.objects(b=[{"c": "c"}]).count() == 0
def test_call_after_limits_set(self): def test_call_after_limits_set(self):
"""Ensure that re-filtering after slicing works """Ensure that re-filtering after slicing works"""
"""
class Post(Document): class Post(Document):
title = StringField() title = StringField()
@ -4007,8 +3965,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_order_then_filter(self): def test_order_then_filter(self):
"""Ensure that ordering still works after filtering. """Ensure that ordering still works after filtering."""
"""
class Number(Document): class Number(Document):
n = IntField() n = IntField()
@ -4025,8 +3982,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_clone(self): def test_clone(self):
"""Ensure that cloning clones complex querysets """Ensure that cloning clones complex querysets"""
"""
class Number(Document): class Number(Document):
n = IntField() n = IntField()
@ -4055,8 +4011,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_clone_retains_settings(self): def test_clone_retains_settings(self):
"""Ensure that cloning retains the read_preference and read_concern """Ensure that cloning retains the read_preference and read_concern"""
"""
class Number(Document): class Number(Document):
n = IntField() n = IntField()
@ -4081,8 +4036,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_using(self): def test_using(self):
"""Ensure that switching databases for a queryset is possible """Ensure that switching databases for a queryset is possible"""
"""
class Number2(Document): class Number2(Document):
n = IntField() n = IntField()
@ -4134,8 +4088,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_order_works_with_primary(self): def test_order_works_with_primary(self):
"""Ensure that order_by and primary work. """Ensure that order_by and primary work."""
"""
class Number(Document): class Number(Document):
n = IntField(primary_key=True) n = IntField(primary_key=True)
@ -4154,8 +4107,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_ensure_index(self): def test_ensure_index(self):
"""Ensure that manual creation of indexes works. """Ensure that manual creation of indexes works."""
"""
class Comment(Document): class Comment(Document):
message = StringField() message = StringField()
@ -4171,8 +4123,7 @@ class TestQueryset(unittest.TestCase):
assert ([("_cls", 1), ("message", 1)], False, False) in info assert ([("_cls", 1), ("message", 1)], False, False) in info
def test_where(self): def test_where(self):
"""Ensure that where clauses work. """Ensure that where clauses work."""
"""
class IntPair(Document): class IntPair(Document):
fielda = IntField() fielda = IntField()
@ -4273,15 +4224,15 @@ class TestQueryset(unittest.TestCase):
ulist = list(UserDoc.objects.scalar("name", "age")) ulist = list(UserDoc.objects.scalar("name", "age"))
assert ulist == [ assert ulist == [
(u"Wilson Jr", 19), ("Wilson Jr", 19),
(u"Wilson", 43), ("Wilson", 43),
(u"Eliana", 37), ("Eliana", 37),
(u"Tayza", 15), ("Tayza", 15),
] ]
ulist = list(UserDoc.objects.scalar("name").order_by("age")) ulist = list(UserDoc.objects.scalar("name").order_by("age"))
assert ulist == [(u"Tayza"), (u"Wilson Jr"), (u"Eliana"), (u"Wilson")] assert ulist == [("Tayza"), ("Wilson Jr"), ("Eliana"), ("Wilson")]
def test_scalar_embedded(self): def test_scalar_embedded(self):
class Profile(EmbeddedDocument): class Profile(EmbeddedDocument):
@ -4320,7 +4271,7 @@ class TestQueryset(unittest.TestCase):
assert list( assert list(
Person.objects.order_by("profile__age").scalar("profile__name") Person.objects.order_by("profile__age").scalar("profile__name")
) == [u"Wilson Jr", u"Gabriel Falcao", u"Lincoln de souza", u"Walter cruz"] ) == ["Wilson Jr", "Gabriel Falcao", "Lincoln de souza", "Walter cruz"]
ulist = list( ulist = list(
Person.objects.order_by("locale.city").scalar( Person.objects.order_by("locale.city").scalar(
@ -4328,10 +4279,10 @@ class TestQueryset(unittest.TestCase):
) )
) )
assert ulist == [ assert ulist == [
(u"Lincoln de souza", 28, u"Belo Horizonte"), ("Lincoln de souza", 28, "Belo Horizonte"),
(u"Walter cruz", 30, u"Brasilia"), ("Walter cruz", 30, "Brasilia"),
(u"Wilson Jr", 19, u"Corumba-GO"), ("Wilson Jr", 19, "Corumba-GO"),
(u"Gabriel Falcao", 23, u"New York"), ("Gabriel Falcao", 23, "New York"),
] ]
def test_scalar_decimal(self): def test_scalar_decimal(self):
@ -4345,7 +4296,7 @@ class TestQueryset(unittest.TestCase):
Person(name="Wilson Jr", rating=Decimal("1.0")).save() Person(name="Wilson Jr", rating=Decimal("1.0")).save()
ulist = list(Person.objects.scalar("name", "rating")) ulist = list(Person.objects.scalar("name", "rating"))
assert ulist == [(u"Wilson Jr", Decimal("1.0"))] assert ulist == [("Wilson Jr", Decimal("1.0"))]
def test_scalar_reference_field(self): def test_scalar_reference_field(self):
class State(Document): class State(Document):
@ -4364,7 +4315,7 @@ class TestQueryset(unittest.TestCase):
Person(name="Wilson JR", state=s1).save() Person(name="Wilson JR", state=s1).save()
plist = list(Person.objects.scalar("name", "state")) plist = list(Person.objects.scalar("name", "state"))
assert plist == [(u"Wilson JR", s1)] assert plist == [("Wilson JR", s1)]
def test_scalar_generic_reference_field(self): def test_scalar_generic_reference_field(self):
class State(Document): class State(Document):
@ -4383,7 +4334,7 @@ class TestQueryset(unittest.TestCase):
Person(name="Wilson JR", state=s1).save() Person(name="Wilson JR", state=s1).save()
plist = list(Person.objects.scalar("name", "state")) plist = list(Person.objects.scalar("name", "state"))
assert plist == [(u"Wilson JR", s1)] assert plist == [("Wilson JR", s1)]
def test_generic_reference_field_with_only_and_as_pymongo(self): def test_generic_reference_field_with_only_and_as_pymongo(self):
class TestPerson(Document): class TestPerson(Document):
@ -4451,8 +4402,7 @@ class TestQueryset(unittest.TestCase):
assert list(val) == [("test", "test value")] assert list(val) == [("test", "test value")]
def test_scalar_cursor_behaviour(self): def test_scalar_cursor_behaviour(self):
"""Ensure that a query returns a valid set of results. """Ensure that a query returns a valid set of results."""
"""
person1 = self.Person(name="User A", age=20) person1 = self.Person(name="User A", age=20)
person1.save() person1.save()
person2 = self.Person(name="User B", age=30) person2 = self.Person(name="User B", age=30)
@ -4669,8 +4619,7 @@ class TestQueryset(unittest.TestCase):
assert [b3] == ak assert [b3] == ak
def test_upsert_includes_cls(self): def test_upsert_includes_cls(self):
"""Upserts should include _cls information for inheritable classes """Upserts should include _cls information for inheritable classes"""
"""
class Test(Document): class Test(Document):
test = StringField() test = StringField()
@ -4916,13 +4865,11 @@ class TestQueryset(unittest.TestCase):
) )
results = User.objects.as_pymongo() results = User.objects.as_pymongo()
assert set(results[0].keys()) == set(["_id", "name", "age", "price"]) assert set(results[0].keys()) == {"_id", "name", "age", "price"}
assert set(results[1].keys()) == set( assert set(results[1].keys()) == {"_id", "name", "age", "price", "last_login"}
["_id", "name", "age", "price", "last_login"]
)
results = User.objects.only("id", "name").as_pymongo() results = User.objects.only("id", "name").as_pymongo()
assert set(results[0].keys()) == set(["_id", "name"]) assert set(results[0].keys()) == {"_id", "name"}
users = User.objects.only("name", "price").as_pymongo() users = User.objects.only("name", "price").as_pymongo()
results = list(users) results = list(users)
@ -5366,8 +5313,7 @@ class TestQueryset(unittest.TestCase):
assert obj.__class__ == C assert obj.__class__ == C
def test_query_generic_embedded_document(self): def test_query_generic_embedded_document(self):
"""Ensure that querying sub field on generic_embedded_field works """Ensure that querying sub field on generic_embedded_field works"""
"""
class A(EmbeddedDocument): class A(EmbeddedDocument):
a_name = StringField() a_name = StringField()
@ -5555,12 +5501,12 @@ class TestQueryset(unittest.TestCase):
assert Person.objects._has_data(), "Cursor has data and returned False" assert Person.objects._has_data(), "Cursor has data and returned False"
def test_delete_count(self): def test_delete_count(self):
[self.Person(name="User {0}".format(i), age=i * 10).save() for i in range(1, 4)] [self.Person(name=f"User {i}", age=i * 10).save() for i in range(1, 4)]
assert ( assert (
self.Person.objects().delete() == 3 self.Person.objects().delete() == 3
) # test ordinary QuerySey delete count ) # test ordinary QuerySey delete count
[self.Person(name="User {0}".format(i), age=i * 10).save() for i in range(1, 4)] [self.Person(name=f"User {i}", age=i * 10).save() for i in range(1, 4)]
assert ( assert (
self.Person.objects().skip(1).delete() == 2 self.Person.objects().skip(1).delete() == 2

2
tests/queryset/test_queryset_aggregation.py
View File

@ -64,7 +64,7 @@ class TestQuerysetAggregate(MongoDBTestCase):
pipeline = [{"$match": {"name": "Isabella Luanna"}}] pipeline = [{"$match": {"name": "Isabella Luanna"}}]
data = Person.objects().aggregate(pipeline) data = Person.objects().aggregate(pipeline)
assert list(data) == [{u"_id": p1.pk, u"age": 16, u"name": u"Isabella Luanna"}] assert list(data) == [{"_id": p1.pk, "age": 16, "name": "Isabella Luanna"}]
def test_queryset_aggregation_with_skip(self): def test_queryset_aggregation_with_skip(self):
class Person(Document): class Person(Document):

8
tests/queryset/test_transform.py
View File

@ -12,8 +12,7 @@ class TestTransform(unittest.TestCase):
connect(db="mongoenginetest") connect(db="mongoenginetest")
def test_transform_query(self): def test_transform_query(self):
"""Ensure that the _transform_query function operates correctly. """Ensure that the _transform_query function operates correctly."""
"""
assert transform.query(name="test", age=30) == {"name": "test", "age": 30} assert transform.query(name="test", age=30) == {"name": "test", "age": 30}
assert transform.query(age__lt=30) == {"age": {"$lt": 30}} assert transform.query(age__lt=30) == {"age": {"$lt": 30}}
assert transform.query(age__gt=20, age__lt=50) == { assert transform.query(age__gt=20, age__lt=50) == {
@ -88,8 +87,7 @@ class TestTransform(unittest.TestCase):
assert update == {"$set": {"tags": ["mongo", "db"]}} assert update == {"$set": {"tags": ["mongo", "db"]}}
def test_query_field_name(self): def test_query_field_name(self):
"""Ensure that the correct field name is used when querying. """Ensure that the correct field name is used when querying."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
content = StringField(db_field="commentContent") content = StringField(db_field="commentContent")
@ -330,7 +328,7 @@ class TestTransform(unittest.TestCase):
word = Word(word="abc", index=1) word = Word(word="abc", index=1)
update = transform.update(MainDoc, pull__content__text=word) update = transform.update(MainDoc, pull__content__text=word)
assert update == { assert update == {
"$pull": {"content.text": SON([("word", u"abc"), ("index", 1)])} "$pull": {"content.text": SON([("word", "abc"), ("index", 1)])}
} }
update = transform.update(MainDoc, pull__content__heading="xyz") update = transform.update(MainDoc, pull__content__heading="xyz")

24
tests/queryset/test_visitor.py
View File

@ -23,8 +23,7 @@ class TestQ(unittest.TestCase):
self.Person = Person self.Person = Person
def test_empty_q(self): def test_empty_q(self):
"""Ensure that empty Q objects won't hurt. """Ensure that empty Q objects won't hurt."""
"""
q1 = Q() q1 = Q()
q2 = Q(age__gte=18) q2 = Q(age__gte=18)
q3 = Q() q3 = Q()
@ -58,8 +57,7 @@ class TestQ(unittest.TestCase):
assert Post.objects.filter(Q(created_user=user)).count() == 1 assert Post.objects.filter(Q(created_user=user)).count() == 1
def test_and_combination(self): def test_and_combination(self):
"""Ensure that Q-objects correctly AND together. """Ensure that Q-objects correctly AND together."""
"""
class TestDoc(Document): class TestDoc(Document):
x = IntField() x = IntField()
@ -89,8 +87,7 @@ class TestQ(unittest.TestCase):
assert query.to_query(TestDoc) == mongo_query assert query.to_query(TestDoc) == mongo_query
def test_or_combination(self): def test_or_combination(self):
"""Ensure that Q-objects correctly OR together. """Ensure that Q-objects correctly OR together."""
"""
class TestDoc(Document): class TestDoc(Document):
x = IntField() x = IntField()
@ -101,8 +98,7 @@ class TestQ(unittest.TestCase):
assert query == {"$or": [{"x": {"$lt": 3}}, {"x": {"$gt": 7}}]} assert query == {"$or": [{"x": {"$lt": 3}}, {"x": {"$gt": 7}}]}
def test_and_or_combination(self): def test_and_or_combination(self):
"""Ensure that Q-objects handle ANDing ORed components. """Ensure that Q-objects handle ANDing ORed components."""
"""
class TestDoc(Document): class TestDoc(Document):
x = IntField() x = IntField()
@ -136,8 +132,7 @@ class TestQ(unittest.TestCase):
assert 2 == TestDoc.objects(q1 & q2).count() assert 2 == TestDoc.objects(q1 & q2).count()
def test_or_and_or_combination(self): def test_or_and_or_combination(self):
"""Ensure that Q-objects handle ORing ANDed ORed components. :) """Ensure that Q-objects handle ORing ANDed ORed components. :)"""
"""
class TestDoc(Document): class TestDoc(Document):
x = IntField() x = IntField()
@ -208,8 +203,7 @@ class TestQ(unittest.TestCase):
assert test.count() == 3 assert test.count() == 3
def test_q(self): def test_q(self):
"""Ensure that Q objects may be used to query for documents. """Ensure that Q objects may be used to query for documents."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -286,8 +280,7 @@ class TestQ(unittest.TestCase):
self.Person.objects.filter("user1") self.Person.objects.filter("user1")
def test_q_regex(self): def test_q_regex(self):
"""Ensure that Q objects can be queried using regexes. """Ensure that Q objects can be queried using regexes."""
"""
person = self.Person(name="Guido van Rossum") person = self.Person(name="Guido van Rossum")
person.save() person.save()
@ -320,8 +313,7 @@ class TestQ(unittest.TestCase):
) )
def test_q_lists(self): def test_q_lists(self):
"""Ensure that Q objects query ListFields correctly. """Ensure that Q objects query ListFields correctly."""
"""
class BlogPost(Document): class BlogPost(Document):
tags = ListField(StringField()) tags = ListField(StringField())

2
tests/test_common.py
View File

@ -1,5 +1,3 @@
import unittest
import pytest import pytest
from mongoengine import Document from mongoengine import Document

24
tests/test_connection.py
View File

@ -194,14 +194,12 @@ class ConnectionTest(unittest.TestCase):
assert len(mongoengine.connection._connections) == 3 assert len(mongoengine.connection._connections) == 3
def test_connect_with_invalid_db_name(self): def test_connect_with_invalid_db_name(self):
"""Ensure that connect() method fails fast if db name is invalid """Ensure that connect() method fails fast if db name is invalid"""
"""
with pytest.raises(InvalidName): with pytest.raises(InvalidName):
connect("mongomock://localhost") connect("mongomock://localhost")
def test_connect_with_db_name_external(self): def test_connect_with_db_name_external(self):
"""Ensure that connect() works if db name is $external """Ensure that connect() works if db name is $external"""
"""
"""Ensure that the connect() method works properly.""" """Ensure that the connect() method works properly."""
connect("$external") connect("$external")
@ -217,16 +215,14 @@ class ConnectionTest(unittest.TestCase):
assert isinstance(conn, pymongo.mongo_client.MongoClient) assert isinstance(conn, pymongo.mongo_client.MongoClient)
def test_connect_with_invalid_db_name_type(self): def test_connect_with_invalid_db_name_type(self):
"""Ensure that connect() method fails fast if db name has invalid type """Ensure that connect() method fails fast if db name has invalid type"""
"""
with pytest.raises(TypeError): with pytest.raises(TypeError):
non_string_db_name = ["e. g. list instead of a string"] non_string_db_name = ["e. g. list instead of a string"]
connect(non_string_db_name) connect(non_string_db_name)
@require_mongomock @require_mongomock
def test_connect_in_mocking(self): def test_connect_in_mocking(self):
"""Ensure that the connect() method works properly in mocking. """Ensure that the connect() method works properly in mocking."""
"""
connect("mongoenginetest", host="mongomock://localhost") connect("mongoenginetest", host="mongomock://localhost")
conn = get_connection() conn = get_connection()
assert isinstance(conn, mongomock.MongoClient) assert isinstance(conn, mongomock.MongoClient)
@ -270,8 +266,7 @@ class ConnectionTest(unittest.TestCase):
@require_mongomock @require_mongomock
def test_default_database_with_mocking(self): def test_default_database_with_mocking(self):
"""Ensure that the default database is correctly set when using mongomock. """Ensure that the default database is correctly set when using mongomock."""
"""
disconnect_all() disconnect_all()
class SomeDocument(Document): class SomeDocument(Document):
@ -452,8 +447,7 @@ class ConnectionTest(unittest.TestCase):
disconnect_all() disconnect_all()
def test_sharing_connections(self): def test_sharing_connections(self):
"""Ensure that connections are shared when the connection settings are exactly the same """Ensure that connections are shared when the connection settings are exactly the same"""
"""
connect("mongoenginetests", alias="testdb1") connect("mongoenginetests", alias="testdb1")
expected_connection = get_connection("testdb1") expected_connection = get_connection("testdb1")
@ -564,8 +558,7 @@ class ConnectionTest(unittest.TestCase):
authd_conn.admin.system.users.delete_many({}) authd_conn.admin.system.users.delete_many({})
def test_register_connection(self): def test_register_connection(self):
"""Ensure that connections with different aliases may be registered. """Ensure that connections with different aliases may be registered."""
"""
register_connection("testdb", "mongoenginetest2") register_connection("testdb", "mongoenginetest2")
with pytest.raises(ConnectionFailure): with pytest.raises(ConnectionFailure):
@ -578,8 +571,7 @@ class ConnectionTest(unittest.TestCase):
assert db.name == "mongoenginetest2" assert db.name == "mongoenginetest2"
def test_register_connection_defaults(self): def test_register_connection_defaults(self):
"""Ensure that defaults are used when the host and port are None. """Ensure that defaults are used when the host and port are None."""
"""
register_connection("testdb", "mongoenginetest", host=None, port=None) register_connection("testdb", "mongoenginetest", host=None, port=None)
conn = get_connection("testdb") conn = get_connection("testdb")

10
tests/test_context_managers.py
View File

@ -117,8 +117,7 @@ class TestContextManagers:
assert 1 == Group.objects.count() assert 1 == Group.objects.count()
def test_no_dereference_context_manager_object_id(self): def test_no_dereference_context_manager_object_id(self):
"""Ensure that DBRef items in ListFields aren't dereferenced. """Ensure that DBRef items in ListFields aren't dereferenced."""
"""
connect("mongoenginetest") connect("mongoenginetest")
class User(Document): class User(Document):
@ -155,8 +154,7 @@ class TestContextManagers:
assert isinstance(group.generic, User) assert isinstance(group.generic, User)
def test_no_dereference_context_manager_dbref(self): def test_no_dereference_context_manager_dbref(self):
"""Ensure that DBRef items in ListFields aren't dereferenced. """Ensure that DBRef items in ListFields aren't dereferenced."""
"""
connect("mongoenginetest") connect("mongoenginetest")
class User(Document): class User(Document):
@ -182,11 +180,11 @@ class TestContextManagers:
with no_dereference(Group) as Group: with no_dereference(Group) as Group:
group = Group.objects.first() group = Group.objects.first()
assert all([not isinstance(m, User) for m in group.members]) assert all(not isinstance(m, User) for m in group.members)
assert not isinstance(group.ref, User) assert not isinstance(group.ref, User)
assert not isinstance(group.generic, User) assert not isinstance(group.generic, User)
assert all([isinstance(m, User) for m in group.members]) assert all(isinstance(m, User) for m in group.members)
assert isinstance(group.ref, User) assert isinstance(group.ref, User)
assert isinstance(group.generic, User) assert isinstance(group.generic, User)

4
tests/test_datastructures.py
View File

@ -6,7 +6,7 @@ from mongoengine import Document
from mongoengine.base.datastructures import BaseDict, BaseList, StrictDict from mongoengine.base.datastructures import BaseDict, BaseList, StrictDict
class DocumentStub(object): class DocumentStub:
def __init__(self): def __init__(self):
self._changed_fields = [] self._changed_fields = []
self._unset_fields = [] self._unset_fields = []
@ -421,7 +421,7 @@ class TestStrictDict(unittest.TestCase):
d.a = 1 d.a = 1
assert d.a == 1 assert d.a == 1
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
getattr(d, "b") d.b
def test_setattr_raises_on_nonexisting_attr(self): def test_setattr_raises_on_nonexisting_attr(self):
d = self.dtype() d = self.dtype()

143
tests/test_dereference.py
View File

@ -16,8 +16,7 @@ class FieldTest(unittest.TestCase):
cls.db.drop_database("mongoenginetest") cls.db.drop_database("mongoenginetest")
def test_list_item_dereference(self): def test_list_item_dereference(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -50,7 +49,7 @@ class FieldTest(unittest.TestCase):
len(group_obj.members) len(group_obj.members)
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
# Document select_related # Document select_related
@ -59,7 +58,7 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
# Queryset select_related # Queryset select_related
@ -68,15 +67,14 @@ class FieldTest(unittest.TestCase):
group_objs = Group.objects.select_related() group_objs = Group.objects.select_related()
assert q == 2 assert q == 2
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
User.drop_collection() User.drop_collection()
Group.drop_collection() Group.drop_collection()
def test_list_item_dereference_dref_false(self): def test_list_item_dereference_dref_false(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -101,14 +99,14 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
assert group_obj._data["members"]._dereferenced assert group_obj._data["members"]._dereferenced
# verifies that no additional queries gets executed # verifies that no additional queries gets executed
# if we re-iterate over the ListField once it is # if we re-iterate over the ListField once it is
# dereferenced # dereferenced
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
assert group_obj._data["members"]._dereferenced assert group_obj._data["members"]._dereferenced
@ -119,7 +117,7 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
# Queryset select_related # Queryset select_related
@ -128,12 +126,11 @@ class FieldTest(unittest.TestCase):
group_objs = Group.objects.select_related() group_objs = Group.objects.select_related()
assert q == 2 assert q == 2
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
def test_list_item_dereference_orphan_dbref(self): def test_list_item_dereference_orphan_dbref(self):
"""Ensure that orphan DBRef items in ListFields are dereferenced. """Ensure that orphan DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -161,14 +158,14 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
assert group_obj._data["members"]._dereferenced assert group_obj._data["members"]._dereferenced
# verifies that no additional queries gets executed # verifies that no additional queries gets executed
# if we re-iterate over the ListField once it is # if we re-iterate over the ListField once it is
# dereferenced # dereferenced
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
assert group_obj._data["members"]._dereferenced assert group_obj._data["members"]._dereferenced
@ -176,8 +173,7 @@ class FieldTest(unittest.TestCase):
Group.drop_collection() Group.drop_collection()
def test_list_item_dereference_dref_false_stores_as_type(self): def test_list_item_dereference_dref_false_stores_as_type(self):
"""Ensure that DBRef items are stored as their type """Ensure that DBRef items are stored as their type"""
"""
class User(Document): class User(Document):
my_id = IntField(primary_key=True) my_id = IntField(primary_key=True)
@ -198,8 +194,7 @@ class FieldTest(unittest.TestCase):
assert group.members == [user] assert group.members == [user]
def test_handle_old_style_references(self): def test_handle_old_style_references(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -232,8 +227,7 @@ class FieldTest(unittest.TestCase):
assert group.members[-1].name == "String!" assert group.members[-1].name == "String!"
def test_migrate_references(self): def test_migrate_references(self):
"""Example of migrating ReferenceField storage """Example of migrating ReferenceField storage"""
"""
# Create some sample data # Create some sample data
class User(Document): class User(Document):
@ -278,8 +272,7 @@ class FieldTest(unittest.TestCase):
assert isinstance(raw_data["members"][0], ObjectId) assert isinstance(raw_data["members"][0], ObjectId)
def test_recursive_reference(self): def test_recursive_reference(self):
"""Ensure that ReferenceFields can reference their own documents. """Ensure that ReferenceFields can reference their own documents."""
"""
class Employee(Document): class Employee(Document):
name = StringField() name = StringField()
@ -402,8 +395,7 @@ class FieldTest(unittest.TestCase):
assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects() assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects()
def test_circular_reference_on_self(self): def test_circular_reference_on_self(self):
"""Ensure you can handle circular references """Ensure you can handle circular references"""
"""
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -430,8 +422,7 @@ class FieldTest(unittest.TestCase):
assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects() assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects()
def test_circular_tree_reference(self): def test_circular_tree_reference(self):
"""Ensure you can handle circular references with more than one level """Ensure you can handle circular references with more than one level"""
"""
class Other(EmbeddedDocument): class Other(EmbeddedDocument):
name = StringField() name = StringField()
@ -514,10 +505,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for m in group_obj.members: for m in group_obj.members:
@ -530,10 +521,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for m in group_obj.members: for m in group_obj.members:
@ -547,18 +538,17 @@ class FieldTest(unittest.TestCase):
assert q == 4 assert q == 4
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for m in group_obj.members: for m in group_obj.members:
assert "User" in m.__class__.__name__ assert "User" in m.__class__.__name__
def test_generic_reference_orphan_dbref(self): def test_generic_reference_orphan_dbref(self):
"""Ensure that generic orphan DBRef items in ListFields are dereferenced. """Ensure that generic orphan DBRef items in ListFields are dereferenced."""
"""
class UserA(Document): class UserA(Document):
name = StringField() name = StringField()
@ -602,11 +592,11 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
assert group_obj._data["members"]._dereferenced assert group_obj._data["members"]._dereferenced
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
assert group_obj._data["members"]._dereferenced assert group_obj._data["members"]._dereferenced
@ -658,10 +648,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for m in group_obj.members: for m in group_obj.members:
@ -674,10 +664,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for m in group_obj.members: for m in group_obj.members:
@ -691,10 +681,10 @@ class FieldTest(unittest.TestCase):
assert q == 4 assert q == 4
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for m in group_obj.members: for m in group_obj.members:
@ -733,10 +723,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
for k, m in group_obj.members.items(): for _, m in group_obj.members.items():
assert isinstance(m, User) assert isinstance(m, User)
# Document select_related # Document select_related
@ -746,7 +736,7 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -760,7 +750,7 @@ class FieldTest(unittest.TestCase):
assert q == 2 assert q == 2
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -811,10 +801,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -827,10 +817,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -844,10 +834,10 @@ class FieldTest(unittest.TestCase):
assert q == 4 assert q == 4
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -862,7 +852,7 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 1 assert q == 1
assert group_obj.members == {} assert group_obj.members == {}
@ -901,10 +891,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -917,10 +907,10 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
for k, m in group_obj.members.items(): for k, m in group_obj.members.items():
@ -934,13 +924,13 @@ class FieldTest(unittest.TestCase):
assert q == 2 assert q == 2
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 2 assert q == 2
for k, m in group_obj.members.items(): for _, m in group_obj.members.items():
assert isinstance(m, UserA) assert isinstance(m, UserA)
UserA.drop_collection() UserA.drop_collection()
@ -988,13 +978,13 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for k, m in group_obj.members.items(): for _, m in group_obj.members.items():
assert "User" in m.__class__.__name__ assert "User" in m.__class__.__name__
# Document select_related # Document select_related
@ -1004,13 +994,13 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first().select_related() group_obj = Group.objects.first().select_related()
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for k, m in group_obj.members.items(): for _, m in group_obj.members.items():
assert "User" in m.__class__.__name__ assert "User" in m.__class__.__name__
# Queryset select_related # Queryset select_related
@ -1021,13 +1011,13 @@ class FieldTest(unittest.TestCase):
assert q == 4 assert q == 4
for group_obj in group_objs: for group_obj in group_objs:
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 4 assert q == 4
for k, m in group_obj.members.items(): for _, m in group_obj.members.items():
assert "User" in m.__class__.__name__ assert "User" in m.__class__.__name__
Group.objects.delete() Group.objects.delete()
@ -1039,7 +1029,7 @@ class FieldTest(unittest.TestCase):
group_obj = Group.objects.first() group_obj = Group.objects.first()
assert q == 1 assert q == 1
[m for m in group_obj.members] _ = [m for m in group_obj.members]
assert q == 1 assert q == 1
UserA.drop_collection() UserA.drop_collection()
@ -1168,8 +1158,7 @@ class FieldTest(unittest.TestCase):
assert msg.author.name == "new-name" assert msg.author.name == "new-name"
def test_list_lookup_not_checked_in_map(self): def test_list_lookup_not_checked_in_map(self):
"""Ensure we dereference list data correctly """Ensure we dereference list data correctly"""
"""
class Comment(Document): class Comment(Document):
id = IntField(primary_key=True) id = IntField(primary_key=True)
@ -1191,8 +1180,7 @@ class FieldTest(unittest.TestCase):
assert 1 == msg.comments[1].id assert 1 == msg.comments[1].id
def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self): def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -1221,8 +1209,7 @@ class FieldTest(unittest.TestCase):
assert q == 2 assert q == 2
def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self): def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -1334,7 +1321,7 @@ class FieldTest(unittest.TestCase):
BrandGroup.drop_collection() BrandGroup.drop_collection()
brand1 = Brand(title="Moschino").save() brand1 = Brand(title="Moschino").save()
brand2 = Brand(title=u"Денис Симачёв").save() brand2 = Brand(title="Денис Симачёв").save()
BrandGroup(title="top_brands", brands=[brand1, brand2]).save() BrandGroup(title="top_brands", brands=[brand1, brand2]).save()
brand_groups = BrandGroup.objects().all() brand_groups = BrandGroup.objects().all()

3
tests/test_replicaset_connection.py
View File

@ -22,8 +22,7 @@ class ConnectionTest(unittest.TestCase):
mongoengine.connection._dbs = {} mongoengine.connection._dbs = {}
def test_replicaset_uri_passes_read_preference(self): def test_replicaset_uri_passes_read_preference(self):
"""Requires a replica set called "rs" on port 27017 """Requires a replica set called "rs" on port 27017"""
"""
try: try:
conn = mongoengine.connect( conn = mongoengine.connect(
db="mongoenginetest", db="mongoenginetest",

7
tests/test_utils.py
View File

@ -1,5 +1,4 @@
import re import re
import unittest
import pytest import pytest
@ -10,7 +9,7 @@ signal_output = []
class TestLazyRegexCompiler: class TestLazyRegexCompiler:
def test_lazy_regex_compiler_verify_laziness_of_descriptor(self): def test_lazy_regex_compiler_verify_laziness_of_descriptor(self):
class UserEmail(object): class UserEmail:
EMAIL_REGEX = LazyRegexCompiler("@", flags=32) EMAIL_REGEX = LazyRegexCompiler("@", flags=32)
descriptor = UserEmail.__dict__["EMAIL_REGEX"] descriptor = UserEmail.__dict__["EMAIL_REGEX"]
@ -24,7 +23,7 @@ class TestLazyRegexCompiler:
assert user_email.EMAIL_REGEX is UserEmail.EMAIL_REGEX assert user_email.EMAIL_REGEX is UserEmail.EMAIL_REGEX
def test_lazy_regex_compiler_verify_cannot_set_descriptor_on_instance(self): def test_lazy_regex_compiler_verify_cannot_set_descriptor_on_instance(self):
class UserEmail(object): class UserEmail:
EMAIL_REGEX = LazyRegexCompiler("@") EMAIL_REGEX = LazyRegexCompiler("@")
user_email = UserEmail() user_email = UserEmail()
@ -32,7 +31,7 @@ class TestLazyRegexCompiler:
user_email.EMAIL_REGEX = re.compile("@") user_email.EMAIL_REGEX = re.compile("@")
def test_lazy_regex_compiler_verify_can_override_class_attr(self): def test_lazy_regex_compiler_verify_can_override_class_attr(self):
class UserEmail(object): class UserEmail:
EMAIL_REGEX = LazyRegexCompiler("@") EMAIL_REGEX = LazyRegexCompiler("@")
UserEmail.EMAIL_REGEX = re.compile("cookies") UserEmail.EMAIL_REGEX = re.compile("cookies")

2
tests/utils.py
View File

@ -59,7 +59,7 @@ def _decorated_with_ver_requirement(func, mongo_version_req, oper):
return func(*args, **kwargs) return func(*args, **kwargs)
pretty_version = ".".join(str(n) for n in mongo_version_req) pretty_version = ".".join(str(n) for n in mongo_version_req)
pytest.skip("Needs MongoDB v{}+".format(pretty_version)) pytest.skip(f"Needs MongoDB v{pretty_version}+")
_inner.__name__ = func.__name__ _inner.__name__ = func.__name__
_inner.__doc__ = func.__doc__ _inner.__doc__ = func.__doc__