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

9
.pre-commit-config.yaml
View File

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

10
.travis.yml
View File

@ -16,11 +16,11 @@
language: python
dist: xenial
python:
- 3.6
- 3.7
- 3.8
- 3.9
- pypy3
- 3.6
- 3.7
- 3.8
- 3.9
- pypy3
env:
global:

2
benchmarks/test_basic_doc_ops.py
View File

@ -45,7 +45,7 @@ def test_basic():
print(
"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))

4
docs/conf.py
View File

@ -41,8 +41,8 @@ source_suffix = ".rst"
master_doc = "index"
# General information about the project.
project = u"MongoEngine"
copyright = u"2009, MongoEngine Authors"
project = "MongoEngine"
copyright = "2009, MongoEngine Authors" # noqa: A001
# The version info for the project you're documenting, acts as replacement for
# |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`,
# users can simply use `from mongoengine import connect`, or even
# `from mongoengine import *` and then `connect('testdb')`.
from mongoengine.connection import *
from mongoengine.document import *
from mongoengine.errors import *
from mongoengine.fields import *
from mongoengine.queryset import *
from mongoengine.signals import *
from mongoengine.connection import * # noqa: F401
from mongoengine.document import * # noqa: F401
from mongoengine.errors import * # noqa: F401
from mongoengine.fields import * # noqa: F401
from mongoengine.queryset import * # noqa: F401
from mongoengine.signals import * # noqa: F401
__all__ = (

18
mongoengine/base/datastructures.py
View File

@ -67,11 +67,11 @@ class BaseDict(dict):
if isinstance(value, EmbeddedDocument) and value._instance is None:
value._instance = self._instance
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)
value._instance = self._instance
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)
value._instance = self._instance
return value
@ -97,7 +97,7 @@ class BaseDict(dict):
def _mark_as_changed(self, key=None):
if hasattr(self._instance, "_mark_as_changed"):
if key:
self._instance._mark_as_changed("{}.{}".format(self._name, key))
self._instance._mark_as_changed(f"{self._name}.{key}")
else:
self._instance._mark_as_changed(self._name)
@ -133,12 +133,12 @@ class BaseList(list):
value._instance = self._instance
elif isinstance(value, dict) and not isinstance(value, 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)
value._instance = self._instance
elif isinstance(value, list) and not isinstance(value, 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)
value._instance = self._instance
return value
@ -180,9 +180,7 @@ class BaseList(list):
def _mark_as_changed(self, key=None):
if hasattr(self._instance, "_mark_as_changed"):
if key is not None:
self._instance._mark_as_changed(
"{}.{}".format(self._name, key % len(self))
)
self._instance._mark_as_changed(f"{self._name}.{key % len(self)}")
else:
self._instance._mark_as_changed(self._name)
@ -429,7 +427,7 @@ class StrictDict:
def __repr__(self):
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
@ -472,4 +470,4 @@ class LazyReference(DBRef):
raise AttributeError()
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"]
)
if _undefined_fields:
msg = ('The fields "{}" do not exist on the document "{}"').format(
_undefined_fields, self._class_name
)
msg = f'The fields "{_undefined_fields}" do not exist on the document "{self._class_name}"'
raise FieldDoesNotExist(msg)
if self.STRICT and not self._dynamic:
@ -231,10 +229,10 @@ class BaseDocument:
setattr(self, k, data[k])
if "_fields_ordered" in data:
if self._dynamic:
setattr(self, "_fields_ordered", data["_fields_ordered"])
self._fields_ordered = data["_fields_ordered"]
else:
_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()
for k in dynamic_fields.keys():
@ -244,8 +242,7 @@ class BaseDocument:
return iter(self._fields_ordered)
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:
if name in self._fields_ordered:
return getattr(self, name)
@ -254,8 +251,7 @@ class BaseDocument:
raise KeyError(name)
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
if not self._dynamic and name not in self._fields:
raise KeyError(name)
@ -277,7 +273,7 @@ class BaseDocument:
except (UnicodeEncodeError, UnicodeDecodeError):
u = "[Bad Unicode data]"
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):
# TODO this could be simpler?
@ -433,7 +429,7 @@ class BaseDocument:
pk = self.pk
elif self._instance and hasattr(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)
def to_json(self, *args, **kwargs):
@ -506,7 +502,7 @@ class BaseDocument:
if "." in key:
key, rest = key.split(".", 1)
key = self._db_field_map.get(key, key)
key = "{}.{}".format(key, rest)
key = f"{key}.{rest}"
else:
key = self._db_field_map.get(key, key)
@ -578,7 +574,7 @@ class BaseDocument:
else:
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(
value, Document
): # don't follow references
@ -602,7 +598,7 @@ class BaseDocument:
iterator = data.items()
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
# as changed.
if item_key[:-1] in changed_fields:
@ -610,15 +606,14 @@ class BaseDocument:
if hasattr(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)):
BaseDocument._nestable_types_changed_fields(
changed_fields, item_key, value
)
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")
ReferenceField = _import_class("ReferenceField")
GenericReferenceField = _import_class("GenericReferenceField")
@ -643,7 +638,7 @@ class BaseDocument:
if isinstance(data, EmbeddedDocument):
# Find all embedded fields that have been changed
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)):
if hasattr(field, "field") and isinstance(
field.field, (ReferenceField, GenericReferenceField)
@ -750,8 +745,7 @@ class BaseDocument:
@classmethod
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):
raise ValueError(
"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
if errors_dict:
errors = "\n".join(
["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()]
)
errors = "\n".join([f"Field '{k}' - {v}" for k, v in errors_dict.items()])
msg = "Invalid data to create a `{}` instance.\n{}".format(
cls._class_name, errors,
cls._class_name,
errors,
)
raise InvalidDocumentError(msg)
@ -968,10 +961,7 @@ class BaseDocument:
unique_fields += unique_with
# Add the new index to the list
fields = [
("{}{}".format(namespace, f), pymongo.ASCENDING)
for f in unique_fields
]
fields = [(f"{namespace}{f}", pymongo.ASCENDING) for f in unique_fields]
index = {"fields": fields, "unique": True, "sparse": sparse}
unique_indexes.append(index)
@ -1007,9 +997,7 @@ class BaseDocument:
"PolygonField",
)
geo_field_types = tuple(
[_import_class(field) for field in geo_field_type_names]
)
geo_field_types = tuple(_import_class(field) for field in geo_field_type_names)
for field in cls._fields.values():
if not isinstance(field, geo_field_types):
@ -1027,7 +1015,7 @@ class BaseDocument:
elif field._geo_index:
field_name = field.db_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)]})
return geo_indices
@ -1165,8 +1153,7 @@ class BaseDocument:
@classmethod
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 = [f.db_field for f in cls._lookup_field(parts)]
return ".".join(parts)

14
mongoengine/base/fields.py
View File

@ -40,7 +40,7 @@ class BaseField:
choices=None,
null=False,
sparse=False,
**kwargs
**kwargs,
):
"""
:param db_field: The database field to store this field in
@ -117,8 +117,7 @@ class BaseField:
BaseField.creation_counter += 1
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:
# Document class being used rather than a document object
return self
@ -466,9 +465,7 @@ class ComplexBaseField(BaseField):
if errors:
field_class = self.field.__class__.__name__
self.error(
"Invalid {} item ({})".format(field_class, value), errors=errors
)
self.error(f"Invalid {field_class} item ({value})", errors=errors)
# Don't allow empty values if required
if self.required and not value:
self.error("Field is required and cannot be empty")
@ -517,8 +514,7 @@ class ObjectIdField(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
_type = "GeoBase"
@ -538,7 +534,7 @@ class GeoJsonBaseField(BaseField):
if isinstance(value, dict):
if set(value.keys()) == {"type", "coordinates"}:
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"])
else:
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,
# none of its subclasses can override allow_inheritance to False.
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 (
not simple_class
@ -439,8 +439,8 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0)
for i in itertools.count():
id_name = "{}_{}".format(id_basename, i)
id_db_name = "{}_{}".format(id_db_basename, i)
id_name = f"{id_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:
return id_name, id_db_name

8
mongoengine/connection.py
View File

@ -54,7 +54,7 @@ def _get_connection_settings(
password=None,
authentication_source=None,
authentication_mechanism=None,
**kwargs
**kwargs,
):
"""Get the connection settings as a dict
@ -177,7 +177,7 @@ def register_connection(
password=None,
authentication_source=None,
authentication_mechanism=None,
**kwargs
**kwargs,
):
"""Register the connection settings.
@ -210,7 +210,7 @@ def register_connection(
password=password,
authentication_source=authentication_source,
authentication_mechanism=authentication_mechanism,
**kwargs
**kwargs,
)
_connection_settings[alias] = conn_settings
@ -313,7 +313,7 @@ def _create_connection(alias, connection_class, **connection_settings):
try:
return connection_class(**connection_settings)
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):

3
mongoengine/context_managers.py
View File

@ -184,8 +184,7 @@ class query_counter:
"""
def __init__(self, alias=DEFAULT_CONNECTION_NAME):
"""Construct the query_counter
"""
"""Construct the query_counter"""
self.db = get_db(alias=alias)
self.initial_profiling_level = None
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
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
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
elif not field.dbref:
@ -157,8 +157,7 @@ class DeReference:
return reference_map
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 = {}
for collection, dbrefs in self.reference_map.items():
@ -272,12 +271,12 @@ class DeReference:
(v["_ref"].collection, v["_ref"].id), v
)
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(
v, depth, instance=instance, name=item_name
)
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(
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)
def __repr__(self):
return "{}({},)".format(self.__class__.__name__, self.message)
return f"{self.__class__.__name__}({self.message},)"
def __getattribute__(self, name):
message = super().__getattribute__(name)
@ -102,7 +102,7 @@ class ValidationError(AssertionError):
if self.field_name:
message = "%s" % message
if self.errors:
message = "{}({})".format(message, self._format_errors())
message = f"{message}({self._format_errors()})"
return message
def _get_message(self):
@ -147,13 +147,13 @@ class ValidationError(AssertionError):
elif isinstance(value, dict):
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
error_dict = defaultdict(list)
for k, v in self.to_dict().items():
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):

42
mongoengine/fields.py
View File

@ -189,17 +189,15 @@ class URLField(StringField):
# Check first if the scheme is valid
scheme = value.split("://")[0].lower()
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
if not self.url_regex.match(value):
self.error("Invalid URL: {}".format(value))
self.error(f"Invalid URL: {value}")
class EmailField(StringField):
"""A field that validates input as an email address.
"""
"""A field that validates input as an email address."""
USER_REGEX = LazyRegexCompiler(
# `dot-atom` defined in RFC 5322 Section 3.2.3.
@ -233,7 +231,7 @@ class EmailField(StringField):
allow_utf8_user=False,
allow_ip_domain=False,
*args,
**kwargs
**kwargs,
):
"""
:param domain_whitelist: (optional) list of valid domain names applied during validation
@ -440,7 +438,7 @@ class DecimalField(BaseField):
force_string=False,
precision=2,
rounding=decimal.ROUND_HALF_UP,
**kwargs
**kwargs,
):
"""
:param min_value: (optional) A min value that will be applied during validation
@ -1299,8 +1297,7 @@ class ReferenceField(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):
"""Initialises the Cached Reference Field.
@ -1337,7 +1334,7 @@ class CachedReferenceField(BaseField):
return None
update_kwargs = {
"set__{}__{}".format(self.name, key): val
f"set__{self.name}__{key}": val
for key, val in document._delta()[0].items()
if key in self.fields
}
@ -1680,8 +1677,7 @@ class GridFSError(Exception):
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
@ -1739,12 +1735,12 @@ class GridFSProxy:
return self.__copy__()
def __repr__(self):
return "<{}: {}>".format(self.__class__.__name__, self.grid_id)
return f"<{self.__class__.__name__}: {self.grid_id}>"
def __str__(self):
gridout = self.get()
filename = getattr(gridout, "filename") if gridout else "<no file>"
return "<{}: {} ({})>".format(self.__class__.__name__, filename, self.grid_id)
filename = gridout.filename if gridout else "<no file>"
return f"<{self.__class__.__name__}: {filename} ({self.grid_id})>"
def __eq__(self, other):
if isinstance(other, GridFSProxy):
@ -1843,8 +1839,7 @@ class GridFSProxy:
class FileField(BaseField):
"""A GridFS storage field.
"""
"""A GridFS storage field."""
proxy_class = GridFSProxy
@ -2120,7 +2115,7 @@ class SequenceField(BaseField):
sequence_name=None,
value_decorator=None,
*args,
**kwargs
**kwargs,
):
self.collection_name = collection_name or self.COLLECTION_NAME
self.db_alias = db_alias or DEFAULT_CONNECTION_NAME
@ -2135,7 +2130,7 @@ class SequenceField(BaseField):
Generate and Increment the counter
"""
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]
counter = collection.find_one_and_update(
@ -2149,7 +2144,7 @@ class SequenceField(BaseField):
def set_next_value(self, value):
"""Helper method to set the next sequence value"""
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]
counter = collection.find_one_and_update(
filter={"_id": sequence_id},
@ -2166,7 +2161,7 @@ class SequenceField(BaseField):
as it is only fixed on set.
"""
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]
data = collection.find_one({"_id": sequence_id})
@ -2219,8 +2214,7 @@ class SequenceField(BaseField):
class UUIDField(BaseField):
"""A UUID field.
"""
"""A UUID field."""
_binary = None
@ -2427,7 +2421,7 @@ class LazyReferenceField(BaseField):
passthrough=False,
dbref=False,
reverse_delete_rule=DO_NOTHING,
**kwargs
**kwargs,
):
"""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(
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:
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:
return queryset._get_scalar(
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._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")
@ -279,8 +281,7 @@ class BaseQuerySet:
)
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)
def first(self):
@ -420,7 +421,7 @@ class BaseQuerySet:
count = count_documents(
collection=self._cursor.collection,
filter=self._cursor._Cursor__spec,
**kwargs
**kwargs,
)
self._cursor_obj = None
@ -524,7 +525,7 @@ class BaseQuerySet:
write_concern=None,
read_concern=None,
full_result=False,
**update
**update,
):
"""Perform an atomic update on the fields matched by the query.
@ -601,7 +602,7 @@ class BaseQuerySet:
write_concern=write_concern,
read_concern=read_concern,
full_result=True,
**update
**update,
)
if atomic_update.raw_result["updatedExisting"]:
@ -632,7 +633,7 @@ class BaseQuerySet:
multi=False,
write_concern=write_concern,
full_result=full_result,
**update
**update,
)
def modify(
@ -690,7 +691,7 @@ class BaseQuerySet:
upsert=upsert,
sort=sort,
return_document=return_doc,
**self._cursor_args
**self._cursor_args,
)
except pymongo.errors.DuplicateKeyError as err:
raise NotUniqueError("Update failed (%s)" % err)
@ -720,7 +721,7 @@ class BaseQuerySet:
return queryset.filter(pk=object_id).first()
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
:rtype: dict of ObjectId's as keys and collection-specific
@ -738,7 +739,8 @@ class BaseQuerySet:
else:
for doc in docs:
doc_map[doc["_id"]] = self._document._from_son(
doc, _auto_dereference=self._auto_dereference,
doc,
_auto_dereference=self._auto_dereference,
)
return doc_map
@ -1191,7 +1193,7 @@ class BaseQuerySet:
preference.
"""
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._read_concern = (
@ -1556,8 +1558,7 @@ class BaseQuerySet:
# Iterator helpers
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:
raise StopIteration
@ -1567,7 +1568,8 @@ class BaseQuerySet:
return raw_doc
doc = self._document._from_son(
raw_doc, _auto_dereference=self._auto_dereference,
raw_doc,
_auto_dereference=self._auto_dereference,
)
if self._scalar:
@ -1576,8 +1578,7 @@ class BaseQuerySet:
return doc
def rewind(self):
"""Rewind the cursor to its unevaluated state.
"""
"""Rewind the cursor to its unevaluated state."""
self._iter = False
self._cursor.rewind()

9
mongoengine/queryset/queryset.py
View File

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

12
mongoengine/queryset/visitor.py
View File

@ -13,17 +13,14 @@ def warn_empty_is_deprecated():
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):
"""Called by QCombination objects.
"""
"""Called by QCombination objects."""
return combination
def visit_query(self, query):
"""Called by (New)Q objects.
"""
"""Called by (New)Q objects."""
return query
@ -49,8 +46,7 @@ class SimplificationVisitor(QNodeVisitor):
return combination
def _query_conjunction(self, queries):
"""Merges query dicts - effectively &ing them together.
"""
"""Merges query dicts - effectively &ing them together."""
query_ops = set()
combined_query = {}
for query in queries:

2
setup.cfg
View File

@ -1,5 +1,5 @@
[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
max-complexity=47
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
try:
import multiprocessing
import multiprocessing # noqa: F401
except ImportError:
pass

37
tests/document/test_class_methods.py
View File

@ -26,16 +26,14 @@ class TestClassMethods(unittest.TestCase):
self.db.drop_collection(collection)
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 ["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):
"""Ensure that get_db returns the expected db.
"""
"""Ensure that get_db returns the expected db."""
db = self.Person._get_db()
assert self.db == db
@ -47,15 +45,13 @@ class TestClassMethods(unittest.TestCase):
assert collection_name == self.Person._get_collection_name()
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 = self.Person._get_collection()
assert self.db[collection_name] == collection
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"
self.Person(name="Test").save()
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}
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
"""
@ -110,7 +106,7 @@ class TestClassMethods(unittest.TestCase):
}
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
documents (_cls included)
"""
@ -150,7 +146,7 @@ class TestClassMethods(unittest.TestCase):
}
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
"""
@ -203,7 +199,7 @@ class TestClassMethods(unittest.TestCase):
assert actual == expected
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
"""
@ -235,7 +231,7 @@ class TestClassMethods(unittest.TestCase):
assert BlogPost.list_indexes() == [
[("_cls", 1), ("author", 1), ("tags", 1)],
[("_cls", 1), ("author", 1), ("tags", 1), ("extra_text", 1)],
[(u"_id", 1)],
[("_id", 1)],
[("_cls", 1)],
]
@ -260,8 +256,7 @@ class TestClassMethods(unittest.TestCase):
assert Vaccine._meta["delete_rules"][(Cat, "vaccine_made")] == PULL
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):
pass
@ -293,7 +288,7 @@ class TestClassMethods(unittest.TestCase):
assert "wibble" == InheritedAbstractNamingTest._get_collection_name()
# Mixin tests
class BaseMixin(object):
class BaseMixin:
meta = {"collection": lambda c: c.__name__.lower()}
class OldMixinNamingConvention(Document, BaseMixin):
@ -304,7 +299,7 @@ class TestClassMethods(unittest.TestCase):
== OldMixinNamingConvention._get_collection_name()
)
class BaseMixin(object):
class BaseMixin:
meta = {"collection": lambda c: c.__name__.lower()}
class BaseDocument(Document, BaseMixin):
@ -316,8 +311,7 @@ class TestClassMethods(unittest.TestCase):
assert "basedocument" == MyDocument._get_collection_name()
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"
class Person(Document):
@ -337,8 +331,7 @@ class TestClassMethods(unittest.TestCase):
assert collection_name not in list_collection_names(self.db)
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):
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):
def setUp(self):
super(TestDelta, self).setUp()
super().setUp()
class Person(Document):
name = StringField()
@ -643,7 +643,10 @@ class TestDelta(MongoDBTestCase):
doc.save()
doc = doc.reload(10)
assert doc._delta() == ({}, {},)
assert doc._delta() == (
{},
{},
)
del doc.embedded_field.list_field[2].list_field
assert doc._delta() == (
{},

12
tests/document/test_dynamic.py
View File

@ -10,7 +10,7 @@ __all__ = ("TestDynamicDocument",)
class TestDynamicDocument(MongoDBTestCase):
def setUp(self):
super(TestDynamicDocument, self).setUp()
super().setUp()
class Person(DynamicDocument):
name = StringField()
@ -118,17 +118,17 @@ class TestDynamicDocument(MongoDBTestCase):
p.save()
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.newattr = "garbage"
p.save()
raw_p = Person.objects.as_pymongo().get(id=p.id)
assert raw_p == {
"_cls": u"Person",
"_cls": "Person",
"_id": p.id,
"name": "OldDean",
"newattr": u"garbage",
"newattr": "garbage",
}
def test_fields_containing_underscore(self):
@ -144,14 +144,14 @@ class TestDynamicDocument(MongoDBTestCase):
p.save()
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 = "NewDean"
p._newattr1 = "garbage" # Unknown fields won't be added
p.save()
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):
"""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)]}]
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):
title = StringField(required=True)
@ -194,8 +193,7 @@ class TestIndexes(unittest.TestCase):
assert [("rank.title", 1)] in info
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):
location = DictField()
@ -209,8 +207,7 @@ class TestIndexes(unittest.TestCase):
assert [("location.point", "2d")] in info
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):
location = DictField()
@ -229,8 +226,7 @@ class TestIndexes(unittest.TestCase):
assert [("current.location.point", "2d")] in info
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):
location = DictField()
@ -246,8 +242,7 @@ class TestIndexes(unittest.TestCase):
assert [("location.point", "2dsphere")] in info
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(
"GeoHaystack index creation is not supported for now"
"from meta, as it requires a bucketSize parameter."
@ -268,8 +263,7 @@ class TestIndexes(unittest.TestCase):
assert [("location.point", "geoHaystack")] in info
def test_create_geohaystack_index(self):
"""Ensure that geohaystack indexes can be created
"""
"""Ensure that geohaystack indexes can be created"""
class Place(Document):
location = DictField()
@ -364,8 +358,7 @@ class TestIndexes(unittest.TestCase):
assert sorted(info.keys()) == ["_cls_1_user_guid_1", "_id_"]
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):
year = IntField(db_field="yr")
@ -382,8 +375,7 @@ class TestIndexes(unittest.TestCase):
assert sorted(info.keys()) == ["_id_", "date.yr_-1"]
def test_list_embedded_document_index(self):
"""Ensure list embedded documents can be indexed
"""
"""Ensure list embedded documents can be indexed"""
class Tag(EmbeddedDocument):
name = StringField(db_field="tag")
@ -419,8 +411,7 @@ class TestIndexes(unittest.TestCase):
assert sorted(info.keys()) == ["_cls_1", "_id_"]
def test_covered_index(self):
"""Ensure that covered indexes can be used
"""
"""Ensure that covered indexes can be used"""
class Test(Document):
a = IntField()
@ -558,8 +549,7 @@ class TestIndexes(unittest.TestCase):
assert [x.name for x in query_result] == sorted(names)
def test_unique(self):
"""Ensure that uniqueness constraints are applied to fields.
"""
"""Ensure that uniqueness constraints are applied to fields."""
class BlogPost(Document):
title = StringField()
@ -607,8 +597,7 @@ class TestIndexes(unittest.TestCase):
)
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):
year = IntField(db_field="yr")
@ -633,8 +622,7 @@ class TestIndexes(unittest.TestCase):
post3.save()
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):
year = IntField(db_field="yr")

33
tests/document/test_inheritance.py
View File

@ -45,8 +45,7 @@ class TestInheritance(MongoDBTestCase):
test_doc.delete()
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):
meta = {"allow_inheritance": True}
@ -216,8 +215,7 @@ class TestInheritance(MongoDBTestCase):
assert Pike._subclasses == ("Animal.Fish.Pike",)
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):
name = StringField()
@ -234,8 +232,7 @@ class TestInheritance(MongoDBTestCase):
assert Employee._get_collection_name() == Person._get_collection_name()
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):
name = StringField()
@ -259,7 +256,7 @@ class TestInheritance(MongoDBTestCase):
assert Employee._get_collection_name() == Person._get_collection_name()
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.
"""
@ -283,14 +280,11 @@ class TestInheritance(MongoDBTestCase):
C.ensure_indexes()
assert sorted(
[idx["key"] for idx in C._get_collection().index_information().values()]
) == sorted(
[[(u"_cls", 1), (u"b", 1)], [(u"_id", 1)], [(u"_cls", 1), (u"a", 1)]]
)
idx["key"] for idx in C._get_collection().index_information().values()
) == sorted([[("_cls", 1), ("b", 1)], [("_id", 1)], [("_cls", 1), ("a", 1)]])
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):
meta = {"allow_inheritance": True}
@ -347,8 +341,7 @@ class TestInheritance(MongoDBTestCase):
assert "_cls" not in obj
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):
name = StringField()
@ -474,7 +467,7 @@ class TestInheritance(MongoDBTestCase):
assert city.pk is None
# TODO: expected error? Shouldn't we create a new error type?
with pytest.raises(KeyError):
setattr(city, "pk", 1)
city.pk = 1
def test_allow_inheritance_embedded_document(self):
"""Ensure embedded documents respect inheritance."""
@ -498,8 +491,7 @@ class TestInheritance(MongoDBTestCase):
assert "_cls" in doc.to_mongo()
def test_document_inheritance(self):
"""Ensure mutliple inheritance of abstract documents
"""
"""Ensure mutliple inheritance of abstract documents"""
class DateCreatedDocument(Document):
meta = {"allow_inheritance": True, "abstract": True}
@ -507,14 +499,9 @@ class TestInheritance(MongoDBTestCase):
class DateUpdatedDocument(Document):
meta = {"allow_inheritance": True, "abstract": True}
try:
class MyDocument(DateCreatedDocument, DateUpdatedDocument):
pass
except Exception:
assert False, "Couldn't create MyDocument class"
def test_abstract_documents(self):
"""Ensure that a document superclass can be marked as abstract
thereby not using it as the name for the collection."""

41
tests/document/test_instance.py
View File

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

9
tests/document/test_validation.py
View File

@ -9,8 +9,7 @@ from tests.utils import MongoDBTestCase
class TestValidatorError(MongoDBTestCase):
def test_to_dict(self):
"""Ensure a ValidationError handles error to_dict correctly.
"""
"""Ensure a ValidationError handles error to_dict correctly."""
error = ValidationError("root")
assert error.to_dict() == {}
@ -90,8 +89,7 @@ class TestValidatorError(MongoDBTestCase):
p.validate()
def test_embedded_document_validation(self):
"""Ensure that embedded documents may be validated.
"""
"""Ensure that embedded documents may be validated."""
class Comment(EmbeddedDocument):
date = DateTimeField()
@ -212,10 +210,7 @@ class TestValidatorError(MongoDBTestCase):
child.reference = parent
# Saving the child should not raise a ValidationError
try:
child.save()
except ValidationError as e:
self.fail("ValidationError raised: %s" % e.message)
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):
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):
content_type = StringField()
blob = BinaryField()
BLOB = "\xe6\x00\xc4\xff\x07".encode("latin-1")
BLOB = b"\xe6\x00\xc4\xff\x07"
MIME_TYPE = "application/octet-stream"
Attachment.drop_collection()
@ -33,8 +32,7 @@ class TestBinaryField(MongoDBTestCase):
assert BLOB == bytes(attachment_1.blob)
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):
blob = BinaryField(required=True)
@ -45,11 +43,11 @@ class TestBinaryField(MongoDBTestCase):
attachment_required = AttachmentRequired()
with pytest.raises(ValidationError):
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()
_5_BYTES = "\xe6\x00\xc4\xff\x07".encode("latin-1")
_4_BYTES = "\xe6\x00\xc4\xff".encode("latin-1")
_5_BYTES = b"\xe6\x00\xc4\xff\x07"
_4_BYTES = b"\xe6\x00\xc4\xff"
with pytest.raises(ValidationError):
AttachmentSizeLimit(blob=_5_BYTES).validate()
AttachmentSizeLimit(blob=_4_BYTES).validate()
@ -60,7 +58,7 @@ class TestBinaryField(MongoDBTestCase):
class Attachment(Document):
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):
Attachment(blob=invalid_data).validate()
@ -131,7 +129,7 @@ class TestBinaryField(MongoDBTestCase):
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()
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()) == {
"_id": a2.pk,
"name": u"Wilson Junior",
"tp": u"pf",
"father": {"_id": a1.pk, "tp": u"pj"},
"name": "Wilson Junior",
"tp": "pf",
"father": {"_id": a1.pk, "tp": "pj"},
}
assert Person.objects(father=a1)._query == {"father._id": a1.pk}
@ -204,9 +204,9 @@ class TestCachedReferenceField(MongoDBTestCase):
a2.reload()
assert dict(a2.to_mongo()) == {
"_id": a2.pk,
"name": u"Wilson Junior",
"tp": u"pf",
"father": {"_id": a1.pk, "tp": u"pf"},
"name": "Wilson Junior",
"tp": "pf",
"father": {"_id": a1.pk, "tp": "pf"},
}
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
# 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]
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):
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):
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
from mongoengine import *
from mongoengine import Document, EmailField, ValidationError
from tests.utils import MongoDBTestCase
@ -30,11 +28,11 @@ class TestEmailField(MongoDBTestCase):
user.validate()
# unicode domain
user = User(email=u"user@пример.рф")
user = User(email="user@пример.рф")
user.validate()
# invalid unicode domain
user = User(email=u"user@пример")
user = User(email="user@пример")
with pytest.raises(ValidationError):
user.validate()
@ -48,7 +46,7 @@ class TestEmailField(MongoDBTestCase):
email = EmailField()
# 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):
user.validate()
@ -56,7 +54,7 @@ class TestEmailField(MongoDBTestCase):
class User(Document):
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()
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
with pytest.raises(InvalidQueryError) as exc_info:
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):
Person.objects.only("settings.notexist")
@ -110,7 +110,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info:
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
assert Person.objects(settings__base_foo="basefoo").first().id == p.id
@ -318,7 +318,7 @@ class TestGenericEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info:
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):
Person.objects.only("settings.notexist")
@ -346,7 +346,7 @@ class TestGenericEmbeddedDocumentField(MongoDBTestCase):
# Test non exiting attribute
with pytest.raises(InvalidQueryError) as exc_info:
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
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()
doc = HandleNoneFields()
doc.str_fld = u"spam ham egg"
doc.str_fld = "spam ham egg"
doc.int_fld = 42
doc.flt_fld = 4.2
doc.com_dt_fld = datetime.datetime.utcnow()
@ -328,7 +328,7 @@ class TestField(MongoDBTestCase):
HandleNoneFields.drop_collection()
doc = HandleNoneFields()
doc.str_fld = u"spam ham egg"
doc.str_fld = "spam ham egg"
doc.int_fld = 42
doc.flt_fld = 4.2
doc.comp_dt_fld = datetime.datetime.utcnow()
@ -426,9 +426,9 @@ class TestField(MongoDBTestCase):
def test_list_validation(self):
"""Ensure that a list field only accepts lists with valid elements."""
access_level_choices = (
("a", u"Administration"),
("b", u"Manager"),
("c", u"Staff"),
("a", "Administration"),
("b", "Manager"),
("c", "Staff"),
)
class User(Document):
@ -476,7 +476,7 @@ class TestField(MongoDBTestCase):
post.access_list = ["a", "b"]
post.validate()
assert post.get_access_list_display() == u"Administration, Manager"
assert post.get_access_list_display() == "Administration, Manager"
post.comments = ["a"]
with pytest.raises(ValidationError):
@ -544,8 +544,7 @@ class TestField(MongoDBTestCase):
post.validate()
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):
order = IntField()
@ -661,8 +660,7 @@ class TestField(MongoDBTestCase):
)
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):
ref = StringField()
@ -1359,9 +1357,9 @@ class TestField(MongoDBTestCase):
foo.delete()
bar = Bar.objects.get()
with pytest.raises(DoesNotExist):
getattr(bar, "ref")
bar.ref
with pytest.raises(DoesNotExist):
getattr(bar, "generic_ref")
bar.generic_ref
# When auto_dereference is disabled, there is no trouble returning DBRef
bar = Bar.objects.get()
@ -1372,8 +1370,7 @@ class TestField(MongoDBTestCase):
assert bar.generic_ref == {"_ref": expected, "_cls": "Foo"}
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):
name = StringField()
@ -1398,8 +1395,7 @@ class TestField(MongoDBTestCase):
assert group_obj.members[1].name == user2.name
def test_recursive_reference(self):
"""Ensure that ReferenceFields can reference their own documents.
"""
"""Ensure that ReferenceFields can reference their own documents."""
class Employee(Document):
name = StringField()
@ -1426,8 +1422,7 @@ class TestField(MongoDBTestCase):
assert peter.friends == friends
def test_recursive_embedding(self):
"""Ensure that EmbeddedDocumentFields can contain their own documents.
"""
"""Ensure that EmbeddedDocumentFields can contain their own documents."""
class TreeNode(EmbeddedDocument):
name = StringField()
@ -1503,8 +1498,7 @@ class TestField(MongoDBTestCase):
AbstractDoc.drop_collection()
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):
name = StringField()
@ -1574,8 +1568,7 @@ class TestField(MongoDBTestCase):
brother.save()
def test_generic_reference(self):
"""Ensure that a GenericReferenceField properly dereferences items.
"""
"""Ensure that a GenericReferenceField properly dereferences items."""
class Link(Document):
title = StringField()
@ -1614,8 +1607,7 @@ class TestField(MongoDBTestCase):
assert isinstance(bm.bookmark_object, Link)
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):
title = StringField()
@ -1718,8 +1710,7 @@ class TestField(MongoDBTestCase):
assert bm.bookmark_object == post_1
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):
title = StringField()
@ -1811,8 +1802,7 @@ class TestField(MongoDBTestCase):
assert user.bookmarks == [post_1]
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):
title = StringField()
@ -1900,8 +1890,7 @@ class TestField(MongoDBTestCase):
assert doc == doc2
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):
size = StringField(choices={"M", "L"})
@ -1920,8 +1909,7 @@ class TestField(MongoDBTestCase):
shirt.validate()
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):
size = StringField(choices=("S", "M"))
@ -1930,8 +1918,7 @@ class TestField(MongoDBTestCase):
shirt.validate()
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):
size = StringField(choices=("S", "M"))
@ -1989,8 +1976,7 @@ class TestField(MongoDBTestCase):
shirt1.validate()
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):
size = StringField(max_length=3, choices=("S", "M", "L", "XL", "XXL"))
@ -2039,12 +2025,11 @@ class TestField(MongoDBTestCase):
shirt.validate()
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")
COLORS = (("R", "Red"), ("B", "Blue"))
SIZE_MESSAGE = u"Value must be one of ('S', 'M', 'L', 'XL', 'XXL')"
COLOR_MESSAGE = u"Value must be one of ['R', 'B']"
SIZE_MESSAGE = "Value must be one of ('S', 'M', 'L', 'XL', 'XXL')"
COLOR_MESSAGE = "Value must be one of ['R', 'B']"
class Shirt(Document):
size = StringField(max_length=3, choices=SIZES)
@ -2107,7 +2092,7 @@ class TestField(MongoDBTestCase):
assert "comments" in error_dict
assert 1 in error_dict["comments"]
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.validate()
@ -2119,7 +2104,7 @@ class TestField(MongoDBTestCase):
class EnumField(BaseField):
def __init__(self, **kwargs):
super(EnumField, self).__init__(**kwargs)
super().__init__(**kwargs)
def to_mongo(self, value):
return value
@ -2621,11 +2606,11 @@ class TestEmbeddedDocumentListField(MongoDBTestCase):
"""
post = self.BlogPost(
comments=[
self.Comments(author="user1", message=u"сообщение"),
self.Comments(author="user2", message=u"хабарлама"),
self.Comments(author="user1", message="сообщение"),
self.Comments(author="user2", message="хабарлама"),
]
).save()
assert post.comments.get(message=u"сообщение").author == "user1"
assert post.comments.get(message="сообщение").author == "user1"
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
try:
from PIL import Image
from PIL import Image # noqa: F401
HAS_PIL = True
except ImportError:
@ -48,15 +48,14 @@ class TestFileField(MongoDBTestCase):
DemoFile.objects.create()
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):
the_file = FileField()
PutFile.drop_collection()
text = "Hello, World!".encode("latin-1")
text = b"Hello, World!"
content_type = "text/plain"
putfile = PutFile()
@ -91,16 +90,15 @@ class TestFileField(MongoDBTestCase):
result.the_file.delete()
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):
the_file = FileField()
StreamFile.drop_collection()
text = "Hello, World!".encode("latin-1")
more_text = "Foo Bar".encode("latin-1")
text = b"Hello, World!"
more_text = b"Foo Bar"
content_type = "text/plain"
streamfile = StreamFile()
@ -135,8 +133,8 @@ class TestFileField(MongoDBTestCase):
StreamFile.drop_collection()
text = "Hello, World!".encode("latin-1")
more_text = "Foo Bar".encode("latin-1")
text = b"Hello, World!"
more_text = b"Foo Bar"
streamfile = StreamFile()
streamfile.save()
@ -165,8 +163,8 @@ class TestFileField(MongoDBTestCase):
class SetFile(Document):
the_file = FileField()
text = "Hello, World!".encode("latin-1")
more_text = "Foo Bar".encode("latin-1")
text = b"Hello, World!"
more_text = b"Foo Bar"
SetFile.drop_collection()
@ -194,7 +192,7 @@ class TestFileField(MongoDBTestCase):
GridDocument.drop_collection()
with tempfile.TemporaryFile() as f:
f.write("Hello World!".encode("latin-1"))
f.write(b"Hello World!")
f.flush()
# Test without default
@ -211,7 +209,7 @@ class TestFileField(MongoDBTestCase):
assert doc_b.the_file.grid_id == doc_c.the_file.grid_id
# Test with default
doc_d = GridDocument(the_file="".encode("latin-1"))
doc_d = GridDocument(the_file=b"")
doc_d.save()
doc_e = GridDocument.objects.with_id(doc_d.id)
@ -228,8 +226,7 @@ class TestFileField(MongoDBTestCase):
assert ["doc_b", "doc_e"] == grid_fs.list()
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):
name = StringField()
@ -238,7 +235,7 @@ class TestFileField(MongoDBTestCase):
# First instance
test_file = TestFile()
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()
# Second instance
@ -285,8 +282,7 @@ class TestFileField(MongoDBTestCase):
assert test_file.the_file.get().length == 4971
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):
the_file = FileField()
@ -295,9 +291,7 @@ class TestFileField(MongoDBTestCase):
test_file = TestFile()
assert not bool(test_file.the_file)
test_file.the_file.put(
"Hello, World!".encode("latin-1"), content_type="text/plain"
)
test_file.the_file.put(b"Hello, World!", content_type="text/plain")
test_file.save()
assert bool(test_file.the_file)
@ -319,7 +313,7 @@ class TestFileField(MongoDBTestCase):
class TestFile(Document):
the_file = FileField()
text = "Hello, World!".encode("latin-1")
text = b"Hello, World!"
content_type = "text/plain"
testfile = TestFile()
@ -363,7 +357,7 @@ class TestFileField(MongoDBTestCase):
testfile.the_file.put(text, content_type=content_type, filename="hello")
testfile.save()
text = "Bonjour, World!".encode("latin-1")
text = b"Bonjour, World!"
testfile.the_file.replace(text, content_type=content_type, filename="hello")
testfile.save()
@ -387,7 +381,7 @@ class TestFileField(MongoDBTestCase):
TestImage.drop_collection()
with tempfile.TemporaryFile() as f:
f.write("Hello World!".encode("latin-1"))
f.write(b"Hello World!")
f.flush()
t = TestImage()
@ -503,21 +497,21 @@ class TestFileField(MongoDBTestCase):
# First instance
test_file = TestFile()
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()
data = get_db("test_files").macumba.files.find_one()
assert data.get("name") == "hello.txt"
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.the_file = "Hello, World!".encode("latin-1")
test_file.the_file = b"Hello, World!"
test_file.save()
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):
class PutFile(Document):
@ -525,7 +519,7 @@ class TestFileField(MongoDBTestCase):
PutFile.drop_collection()
text = "Hello, World!".encode("latin-1")
text = b"Hello, World!"
content_type = "text/plain"
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()
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):
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):
try:
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:
assert expected == e.to_dict()["loc"]
@ -290,8 +290,7 @@ class TestGeoField(MongoDBTestCase):
Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate()
def test_indexes_geopoint(self):
"""Ensure that indexes are created automatically for GeoPointFields.
"""
"""Ensure that indexes are created automatically for GeoPointFields."""
class Event(Document):
title = StringField()
@ -317,8 +316,7 @@ class TestGeoField(MongoDBTestCase):
assert geo_indicies == [{"fields": [("venue.location", "2d")]}]
def test_indexes_2dsphere(self):
"""Ensure that indexes are created automatically for GeoPointFields.
"""
"""Ensure that indexes are created automatically for GeoPointFields."""
class Event(Document):
title = StringField()
@ -332,8 +330,7 @@ class TestGeoField(MongoDBTestCase):
assert {"fields": [("point", "2dsphere")]} in geo_indicies
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):
name = StringField()

3
tests/fields/test_int_field.py
View File

@ -7,8 +7,7 @@ from tests.utils import MongoDBTestCase
class TestIntField(MongoDBTestCase):
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):
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)
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):
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()
tree = BlogPost(info_dict={u"éééé": {"description": u"VALUE: éééé"}})
tree = BlogPost(info_dict={"éééé": {"description": "VALUE: éééé"}})
tree.save()
assert (
BlogPost.objects.get(id=tree.id).info_dict[u"éééé"].description
== u"VALUE: éééé"
BlogPost.objects.get(id=tree.id).info_dict["éééé"].description
== "VALUE: éééé"
)

5
tests/fields/test_reference_field.py
View File

@ -87,7 +87,7 @@ class TestReferenceField(MongoDBTestCase):
parent = ReferenceField("self", dbref=False)
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):
class Person(Document):
@ -107,8 +107,7 @@ class TestReferenceField(MongoDBTestCase):
assert p.parent == p1
def test_undefined_reference(self):
"""Ensure that ReferenceFields may reference undefined Documents.
"""
"""Ensure that ReferenceFields may reference undefined Documents."""
class Product(Document):
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]
assert ids == list(range(1, 11))
id = [i.id for i in Animal.objects]
assert id == list(range(1, 11))
_id = [i.id for i in Animal.objects]
assert _id == list(range(1, 11))
c = self.db["mongoengine.counters"].find_one({"_id": "person.id"})
assert c["next"] == 10

7
tests/fields/test_url_field.py
View File

@ -26,7 +26,7 @@ class TestURLField(MongoDBTestCase):
url = URLField()
link = Link()
link.url = u"http://привет.com"
link.url = "http://привет.com"
# TODO fix URL validation - this *IS* a valid URL
# For now we just want to make sure that the error message is correct
@ -34,12 +34,11 @@ class TestURLField(MongoDBTestCase):
link.validate()
assert (
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):
"""Ensure that URLFields validate urls with specific schemes properly.
"""
"""Ensure that URLFields validate urls with specific schemes properly."""
class Link(Document):
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)}
def test_field_string(self):
"""Test UUID fields storing as String
"""
"""Test UUID fields storing as String"""
Person.drop_collection()
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)
class Mixin(object):
class Mixin:
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}
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.save()
@ -365,8 +364,7 @@ class TestOnlyExcludeAll(unittest.TestCase):
Email.drop_collection()
def test_slicing_fields(self):
"""Ensure that query slicing an array works.
"""
"""Ensure that query slicing an array works."""
class Numbers(Document):
n = ListField(IntField())
@ -401,8 +399,7 @@ class TestOnlyExcludeAll(unittest.TestCase):
assert numbers.n == [-5, -4, -3, -2, -1]
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):
n = ListField(IntField())

4
tests/queryset/test_geo.py
View File

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

7
tests/queryset/test_pickable.py
View File

@ -1,8 +1,6 @@
import pickle
import unittest
from mongoengine import Document, IntField, StringField
from mongoengine.connection import connect
from tests.utils import MongoDBTestCase
@ -18,18 +16,15 @@ class TestQuerysetPickable(MongoDBTestCase):
"""
def setUp(self):
super(TestQuerysetPickable, self).setUp()
super().setUp()
self.john = Person.objects.create(name="John", age=21)
def test_picke_simple_qs(self):
qs = Person.objects.all()
pickle.dumps(qs)
def _get_loaded(self, qs):
s = pickle.dumps(qs)
return pickle.loads(s)
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
import pymongo
from pymongo.read_concern import ReadConcern
from pymongo.read_preferences import ReadPreference
from pymongo.results import UpdateResult
import pytest
@ -60,8 +59,7 @@ class TestQueryset(unittest.TestCase):
self.mongodb_version = get_mongodb_version()
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 (
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):
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,
)
@ -271,8 +269,7 @@ class TestQueryset(unittest.TestCase):
)
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.save()
person2 = self.Person(name="User B", age=30)
@ -317,8 +314,7 @@ class TestQueryset(unittest.TestCase):
self.Person.objects.get()
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
person1 = self.Person(name="User A", age=20)
@ -351,8 +347,7 @@ class TestQueryset(unittest.TestCase):
assert person == person3
def test_find_array_position(self):
"""Ensure that query by array position works.
"""
"""Ensure that query by array position works."""
class Comment(EmbeddedDocument):
name = StringField()
@ -453,7 +448,7 @@ class TestQueryset(unittest.TestCase):
# test iterating over the result set
cnt = 0
for a in A.objects.batch_size(10):
for _ in A.objects.batch_size(10):
cnt += 1
assert cnt == 100
@ -461,7 +456,7 @@ class TestQueryset(unittest.TestCase):
qs = A.objects.all()
qs = qs.limit(10).batch_size(20).skip(91)
cnt = 0
for a in qs:
for _ in qs:
cnt += 1
assert cnt == 9
@ -1141,8 +1136,7 @@ class TestQueryset(unittest.TestCase):
assert q == 2
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 2").save()
@ -1151,7 +1145,7 @@ class TestQueryset(unittest.TestCase):
people2 = [person for person in queryset]
# Check that it still works even if iteration is interrupted.
for person in queryset:
for _person in queryset:
break
people3 = [person for person in queryset]
@ -1187,12 +1181,11 @@ class TestQueryset(unittest.TestCase):
assert "[<Doc: 1>, <Doc: 2>, <Doc: 3>]" == "%s" % docs
assert docs.count(with_limit_and_skip=True) == 3
for doc in docs:
for _ in docs:
assert ".. queryset mid-iteration .." == repr(docs)
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.save()
@ -1248,8 +1241,7 @@ class TestQueryset(unittest.TestCase):
assert obj == person
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.save()
@ -1260,8 +1252,7 @@ class TestQueryset(unittest.TestCase):
assert obj is None
def test_filter_chaining(self):
"""Ensure filters can be chained together.
"""
"""Ensure filters can be chained together."""
class Blog(Document):
id = StringField(primary_key=True)
@ -1337,8 +1328,7 @@ class TestQueryset(unittest.TestCase):
assert qs[i] == expected[i]
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):
title = StringField()
@ -1408,8 +1398,7 @@ class TestQueryset(unittest.TestCase):
assert ORDER_BY_KEY not in q.get_ops()[0][CMD_QUERY_KEY]
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)
class BlogPost(Document):
@ -1485,8 +1474,7 @@ class TestQueryset(unittest.TestCase):
assert result.author is None
def test_find_dict_item(self):
"""Ensure that DictField items may be found.
"""
"""Ensure that DictField items may be found."""
class BlogPost(Document):
info = DictField()
@ -1502,8 +1490,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection()
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):
hits = IntField()
@ -1540,8 +1527,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection()
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):
content = StringField(db_field="body")
@ -1583,9 +1569,9 @@ class TestQueryset(unittest.TestCase):
results = BlogPost.objects.exec_js(code)
expected_results = [
{u"comment": u"cool", u"document": u"post1"},
{u"comment": u"yay", u"document": u"post1"},
{u"comment": u"nice stuff", u"document": u"post2"},
{"comment": "cool", "document": "post1"},
{"comment": "yay", "document": "post1"},
{"comment": "nice stuff", "document": "post2"},
]
assert results == expected_results
@ -1597,8 +1583,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection()
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 B", age=30).save()
self.Person(name="User C", age=40).save()
@ -1612,8 +1597,7 @@ class TestQueryset(unittest.TestCase):
assert self.Person.objects.count() == 0
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):
content = StringField()
@ -1745,8 +1729,7 @@ class TestQueryset(unittest.TestCase):
assert 0 == Category.objects.count()
def test_reverse_delete_rule_nullify(self):
"""Ensure nullification of references to deleted documents.
"""
"""Ensure nullification of references to deleted documents."""
class Category(Document):
name = StringField()
@ -1842,8 +1825,7 @@ class TestQueryset(unittest.TestCase):
self.Person.objects.delete()
def test_reverse_delete_rule_pull(self):
"""Ensure pulling of references to deleted documents.
"""
"""Ensure pulling of references to deleted documents."""
class BlogPost(Document):
content = StringField()
@ -1918,8 +1900,7 @@ class TestQueryset(unittest.TestCase):
assert 8 == Log.objects.count()
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):
content = StringField()
@ -1951,8 +1932,7 @@ class TestQueryset(unittest.TestCase):
assert del_result is None
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):
content = StringField()
@ -1973,8 +1953,7 @@ class TestQueryset(unittest.TestCase):
assert 1 == BlogPost.objects(author__in=["%s" % me.pk]).count()
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):
content = StringField()
@ -2058,8 +2037,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.objects.update_one(inc__review=0.1) # test with floats
def test_update_listfield_operator(self):
"""Ensure that atomic updates work properly.
"""
"""Ensure that atomic updates work properly."""
class BlogPost(Document):
tags = ListField(StringField())
@ -2107,8 +2085,7 @@ class TestQueryset(unittest.TestCase):
assert "title" not in pymongo_doc
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):
slug = StringField()
@ -2133,8 +2110,7 @@ class TestQueryset(unittest.TestCase):
assert post.tags == ["scala", "mongodb", "python", "java"]
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):
slug = StringField()
@ -2149,8 +2125,7 @@ class TestQueryset(unittest.TestCase):
assert post.tags == [["value1", 123]]
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):
slug = StringField()
@ -2259,8 +2234,7 @@ class TestQueryset(unittest.TestCase):
)
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):
name = StringField()
@ -2491,8 +2465,7 @@ class TestQueryset(unittest.TestCase):
assert doc.pk == doc.embedded[0]._instance.pk
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 A", age=20).save()
self.Person(name="User C", age=30).save()
@ -2560,8 +2533,7 @@ class TestQueryset(unittest.TestCase):
self.assertSequence(qs, expected)
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 A", age=20).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"
def test_map_reduce(self):
"""Ensure map/reduce is both mapping and reducing.
"""
"""Ensure map/reduce is both mapping and reducing."""
class BlogPost(Document):
title = StringField()
@ -2749,10 +2720,10 @@ class TestQueryset(unittest.TestCase):
f1.save()
# persons of first family
Person(id=1, family=f1, name=u"Wilson Jr", age=21).save()
Person(id=2, family=f1, name=u"Wilson Father", age=45).save()
Person(id=3, family=f1, name=u"Eliana Costa", age=40).save()
Person(id=4, family=f1, name=u"Tayza Mariana", age=17).save()
Person(id=1, family=f1, name="Wilson Jr", age=21).save()
Person(id=2, family=f1, name="Wilson Father", age=45).save()
Person(id=3, family=f1, name="Eliana Costa", age=40).save()
Person(id=4, family=f1, name="Tayza Mariana", age=17).save()
# creating second family
f2 = Family(id=2, log="Av prof frasc brunno")
@ -2830,10 +2801,10 @@ class TestQueryset(unittest.TestCase):
"_id": 1,
"value": {
"persons": [
{"age": 21, "name": u"Wilson Jr"},
{"age": 45, "name": u"Wilson Father"},
{"age": 40, "name": u"Eliana Costa"},
{"age": 17, "name": u"Tayza Mariana"},
{"age": 21, "name": "Wilson Jr"},
{"age": 45, "name": "Wilson Father"},
{"age": 40, "name": "Eliana Costa"},
{"age": 17, "name": "Tayza Mariana"},
],
"totalAge": 123,
},
@ -2843,9 +2814,9 @@ class TestQueryset(unittest.TestCase):
"_id": 2,
"value": {
"persons": [
{"age": 16, "name": u"Isabella Luanna"},
{"age": 36, "name": u"Sandra Mara"},
{"age": 10, "name": u"Igor Gabriel"},
{"age": 16, "name": "Isabella Luanna"},
{"age": 36, "name": "Sandra Mara"},
{"age": 10, "name": "Igor Gabriel"},
],
"totalAge": 62,
},
@ -2855,8 +2826,8 @@ class TestQueryset(unittest.TestCase):
"_id": 3,
"value": {
"persons": [
{"age": 30, "name": u"Arthur WA"},
{"age": 25, "name": u"Paula Leonel"},
{"age": 30, "name": "Arthur WA"},
{"age": 25, "name": "Paula Leonel"},
],
"totalAge": 55,
},
@ -2988,8 +2959,7 @@ class TestQueryset(unittest.TestCase):
Link.drop_collection()
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):
hits = IntField()
@ -3003,7 +2973,7 @@ class TestQueryset(unittest.TestCase):
def test_assertions(f):
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["actors"] == 2
assert f["watch"] == 2
@ -3017,7 +2987,7 @@ class TestQueryset(unittest.TestCase):
# Ensure query is taken into account
def test_assertions(f):
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["actors"] == 1
assert f["watch"] == 1
@ -3045,7 +3015,7 @@ class TestQueryset(unittest.TestCase):
# Check item_frequencies works for non-list fields
def test_assertions(f):
assert set([1, 2]) == set(f.keys())
assert {1, 2} == set(f.keys())
assert f[1] == 1
assert f[2] == 2
@ -3057,8 +3027,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection()
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):
number = StringField()
@ -3083,7 +3052,7 @@ class TestQueryset(unittest.TestCase):
def test_assertions(f):
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-3332-1656"] == 1
@ -3095,7 +3064,7 @@ class TestQueryset(unittest.TestCase):
# Ensure query is taken into account
def test_assertions(f):
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
exec_js = Person.objects(phone__number="62-3331-1656").item_frequencies(
@ -3162,10 +3131,10 @@ class TestQueryset(unittest.TestCase):
p.save()
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)
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):
class Test(Document):
@ -3201,10 +3170,10 @@ class TestQueryset(unittest.TestCase):
Test.drop_collection()
for i in range(50):
for _ in range(50):
Test(val=1).save()
for i in range(20):
for _ in range(20):
Test(val=2).save()
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}
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()
assert int(self.Person.objects.average("age")) == 0
@ -3238,7 +3206,7 @@ class TestQueryset(unittest.TestCase):
for i, weight in enumerate(ages):
self.Person(
name="test meta%i", person_meta=self.PersonMeta(weight=weight)
name=f"test meta{i}", person_meta=self.PersonMeta(weight=weight)
).save()
assert (
@ -3255,8 +3223,7 @@ class TestQueryset(unittest.TestCase):
assert self.Person.objects.filter(age__gte=50).average("age") == avg
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]
for i, age in enumerate(ages):
self.Person(name="test%s" % i, age=age).save()
@ -3278,7 +3245,7 @@ class TestQueryset(unittest.TestCase):
# test summing over a filtered queryset
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):
@ -3406,19 +3373,21 @@ class TestQueryset(unittest.TestCase):
assert Doc.objects.sum("values") == 1360
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 White", age=20).save()
self.Person(name="Mr Orange", age=30).save()
self.Person(name="Mr Pink", age=30).save()
assert set(self.Person.objects.distinct("name")) == set(
["Mr Orange", "Mr White", "Mr Pink"]
)
assert set(self.Person.objects.distinct("age")) == set([20, 30])
assert set(self.Person.objects(age=30).distinct("name")) == set(
["Mr Orange", "Mr Pink"]
)
assert set(self.Person.objects.distinct("name")) == {
"Mr Orange",
"Mr White",
"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):
class Foo(Document):
@ -3479,8 +3448,8 @@ class TestQueryset(unittest.TestCase):
assert count == 1
News(
title=u"As eleições no Brasil já estão em planejamento",
content=u"A candidata dilma roussef já começa o teu planejamento",
title="As eleições no Brasil já estão em planejamento",
content="A candidata dilma roussef já começa o teu planejamento",
is_active=False,
).save()
@ -3547,8 +3516,7 @@ class TestQueryset(unittest.TestCase):
assert Foo.objects.distinct("bar") == [bar]
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):
product_id = IntField(db_field="pid")
@ -3559,8 +3527,8 @@ class TestQueryset(unittest.TestCase):
Product(product_id=2).save()
Product(product_id=1).save()
assert set(Product.objects.distinct("product_id")) == set([1, 2])
assert set(Product.objects.distinct("pid")) == set([1, 2])
assert set(Product.objects.distinct("product_id")) == {1, 2}
assert set(Product.objects.distinct("pid")) == {1, 2}
Product.drop_collection()
@ -3644,8 +3612,7 @@ class TestQueryset(unittest.TestCase):
assert Foo.objects.distinct("bar_lst") == [bar_1, bar_2]
def test_custom_manager(self):
"""Ensure that custom QuerySetManager instances work as expected.
"""
"""Ensure that custom QuerySetManager instances work as expected."""
class BlogPost(Document):
tags = ListField(StringField())
@ -3746,8 +3713,7 @@ class TestQueryset(unittest.TestCase):
assert 1 == Bar.objects.count()
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):
author = ReferenceField(self.Person)
@ -3773,8 +3739,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection()
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):
members = ListField(ReferenceField(self.Person))
@ -3799,8 +3764,7 @@ class TestQueryset(unittest.TestCase):
Group.drop_collection()
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):
title = StringField()
@ -3838,8 +3802,7 @@ class TestQueryset(unittest.TestCase):
self.Person.drop_collection()
def test_custom_querysets(self):
"""Ensure that custom QuerySet classes may be used.
"""
"""Ensure that custom QuerySet classes may be used."""
class CustomQuerySet(QuerySet):
def not_empty(self):
@ -3859,8 +3822,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection()
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):
def not_empty(self):
@ -3883,8 +3845,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection()
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):
@staticmethod
@ -3905,8 +3866,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection()
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):
def not_empty(self):
@ -3928,8 +3888,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection()
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):
def not_empty(self):
@ -3990,8 +3949,7 @@ class TestQueryset(unittest.TestCase):
assert A.objects(b=[{"c": "c"}]).count() == 0
def test_call_after_limits_set(self):
"""Ensure that re-filtering after slicing works
"""
"""Ensure that re-filtering after slicing works"""
class Post(Document):
title = StringField()
@ -4007,8 +3965,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection()
def test_order_then_filter(self):
"""Ensure that ordering still works after filtering.
"""
"""Ensure that ordering still works after filtering."""
class Number(Document):
n = IntField()
@ -4025,8 +3982,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection()
def test_clone(self):
"""Ensure that cloning clones complex querysets
"""
"""Ensure that cloning clones complex querysets"""
class Number(Document):
n = IntField()
@ -4055,8 +4011,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection()
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):
n = IntField()
@ -4081,8 +4036,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection()
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):
n = IntField()
@ -4134,8 +4088,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection()
def test_order_works_with_primary(self):
"""Ensure that order_by and primary work.
"""
"""Ensure that order_by and primary work."""
class Number(Document):
n = IntField(primary_key=True)
@ -4154,8 +4107,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection()
def test_ensure_index(self):
"""Ensure that manual creation of indexes works.
"""
"""Ensure that manual creation of indexes works."""
class Comment(Document):
message = StringField()
@ -4171,8 +4123,7 @@ class TestQueryset(unittest.TestCase):
assert ([("_cls", 1), ("message", 1)], False, False) in info
def test_where(self):
"""Ensure that where clauses work.
"""
"""Ensure that where clauses work."""
class IntPair(Document):
fielda = IntField()
@ -4273,15 +4224,15 @@ class TestQueryset(unittest.TestCase):
ulist = list(UserDoc.objects.scalar("name", "age"))
assert ulist == [
(u"Wilson Jr", 19),
(u"Wilson", 43),
(u"Eliana", 37),
(u"Tayza", 15),
("Wilson Jr", 19),
("Wilson", 43),
("Eliana", 37),
("Tayza", 15),
]
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):
class Profile(EmbeddedDocument):
@ -4320,7 +4271,7 @@ class TestQueryset(unittest.TestCase):
assert list(
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(
Person.objects.order_by("locale.city").scalar(
@ -4328,10 +4279,10 @@ class TestQueryset(unittest.TestCase):
)
)
assert ulist == [
(u"Lincoln de souza", 28, u"Belo Horizonte"),
(u"Walter cruz", 30, u"Brasilia"),
(u"Wilson Jr", 19, u"Corumba-GO"),
(u"Gabriel Falcao", 23, u"New York"),
("Lincoln de souza", 28, "Belo Horizonte"),
("Walter cruz", 30, "Brasilia"),
("Wilson Jr", 19, "Corumba-GO"),
("Gabriel Falcao", 23, "New York"),
]
def test_scalar_decimal(self):
@ -4345,7 +4296,7 @@ class TestQueryset(unittest.TestCase):
Person(name="Wilson Jr", rating=Decimal("1.0")).save()
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):
class State(Document):
@ -4364,7 +4315,7 @@ class TestQueryset(unittest.TestCase):
Person(name="Wilson JR", state=s1).save()
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):
class State(Document):
@ -4383,7 +4334,7 @@ class TestQueryset(unittest.TestCase):
Person(name="Wilson JR", state=s1).save()
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):
class TestPerson(Document):
@ -4451,8 +4402,7 @@ class TestQueryset(unittest.TestCase):
assert list(val) == [("test", "test value")]
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.save()
person2 = self.Person(name="User B", age=30)
@ -4669,8 +4619,7 @@ class TestQueryset(unittest.TestCase):
assert [b3] == ak
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):
test = StringField()
@ -4916,13 +4865,11 @@ class TestQueryset(unittest.TestCase):
)
results = User.objects.as_pymongo()
assert set(results[0].keys()) == set(["_id", "name", "age", "price"])
assert set(results[1].keys()) == set(
["_id", "name", "age", "price", "last_login"]
)
assert set(results[0].keys()) == {"_id", "name", "age", "price"}
assert set(results[1].keys()) == {"_id", "name", "age", "price", "last_login"}
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()
results = list(users)
@ -5366,8 +5313,7 @@ class TestQueryset(unittest.TestCase):
assert obj.__class__ == C
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):
a_name = StringField()
@ -5555,12 +5501,12 @@ class TestQueryset(unittest.TestCase):
assert Person.objects._has_data(), "Cursor has data and returned False"
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 (
self.Person.objects().delete() == 3
) # 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 (
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"}}]
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):
class Person(Document):

8
tests/queryset/test_transform.py
View File

@ -12,8 +12,7 @@ class TestTransform(unittest.TestCase):
connect(db="mongoenginetest")
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(age__lt=30) == {"age": {"$lt": 30}}
assert transform.query(age__gt=20, age__lt=50) == {
@ -88,8 +87,7 @@ class TestTransform(unittest.TestCase):
assert update == {"$set": {"tags": ["mongo", "db"]}}
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):
content = StringField(db_field="commentContent")
@ -330,7 +328,7 @@ class TestTransform(unittest.TestCase):
word = Word(word="abc", index=1)
update = transform.update(MainDoc, pull__content__text=word)
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")

24
tests/queryset/test_visitor.py
View File

@ -23,8 +23,7 @@ class TestQ(unittest.TestCase):
self.Person = Person
def test_empty_q(self):
"""Ensure that empty Q objects won't hurt.
"""
"""Ensure that empty Q objects won't hurt."""
q1 = Q()
q2 = Q(age__gte=18)
q3 = Q()
@ -58,8 +57,7 @@ class TestQ(unittest.TestCase):
assert Post.objects.filter(Q(created_user=user)).count() == 1
def test_and_combination(self):
"""Ensure that Q-objects correctly AND together.
"""
"""Ensure that Q-objects correctly AND together."""
class TestDoc(Document):
x = IntField()
@ -89,8 +87,7 @@ class TestQ(unittest.TestCase):
assert query.to_query(TestDoc) == mongo_query
def test_or_combination(self):
"""Ensure that Q-objects correctly OR together.
"""
"""Ensure that Q-objects correctly OR together."""
class TestDoc(Document):
x = IntField()
@ -101,8 +98,7 @@ class TestQ(unittest.TestCase):
assert query == {"$or": [{"x": {"$lt": 3}}, {"x": {"$gt": 7}}]}
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):
x = IntField()
@ -136,8 +132,7 @@ class TestQ(unittest.TestCase):
assert 2 == TestDoc.objects(q1 & q2).count()
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):
x = IntField()
@ -208,8 +203,7 @@ class TestQ(unittest.TestCase):
assert test.count() == 3
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):
title = StringField()
@ -286,8 +280,7 @@ class TestQ(unittest.TestCase):
self.Person.objects.filter("user1")
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.save()
@ -320,8 +313,7 @@ class TestQ(unittest.TestCase):
)
def test_q_lists(self):
"""Ensure that Q objects query ListFields correctly.
"""
"""Ensure that Q objects query ListFields correctly."""
class BlogPost(Document):
tags = ListField(StringField())

2
tests/test_common.py
View File

@ -1,5 +1,3 @@
import unittest
import pytest
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
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):
connect("mongomock://localhost")
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."""
connect("$external")
@ -217,16 +215,14 @@ class ConnectionTest(unittest.TestCase):
assert isinstance(conn, pymongo.mongo_client.MongoClient)
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):
non_string_db_name = ["e. g. list instead of a string"]
connect(non_string_db_name)
@require_mongomock
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")
conn = get_connection()
assert isinstance(conn, mongomock.MongoClient)
@ -270,8 +266,7 @@ class ConnectionTest(unittest.TestCase):
@require_mongomock
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()
class SomeDocument(Document):
@ -452,8 +447,7 @@ class ConnectionTest(unittest.TestCase):
disconnect_all()
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")
expected_connection = get_connection("testdb1")
@ -564,8 +558,7 @@ class ConnectionTest(unittest.TestCase):
authd_conn.admin.system.users.delete_many({})
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")
with pytest.raises(ConnectionFailure):
@ -578,8 +571,7 @@ class ConnectionTest(unittest.TestCase):
assert db.name == "mongoenginetest2"
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)
conn = get_connection("testdb")

10
tests/test_context_managers.py
View File

@ -117,8 +117,7 @@ class TestContextManagers:
assert 1 == Group.objects.count()
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")
class User(Document):
@ -155,8 +154,7 @@ class TestContextManagers:
assert isinstance(group.generic, User)
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")
class User(Document):
@ -182,11 +180,11 @@ class TestContextManagers:
with no_dereference(Group) as Group:
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.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.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
class DocumentStub(object):
class DocumentStub:
def __init__(self):
self._changed_fields = []
self._unset_fields = []
@ -421,7 +421,7 @@ class TestStrictDict(unittest.TestCase):
d.a = 1
assert d.a == 1
with pytest.raises(AttributeError):
getattr(d, "b")
d.b
def test_setattr_raises_on_nonexisting_attr(self):
d = self.dtype()

143
tests/test_dereference.py
View File

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

3
tests/test_replicaset_connection.py
View File

@ -22,8 +22,7 @@ class ConnectionTest(unittest.TestCase):
mongoengine.connection._dbs = {}
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:
conn = mongoengine.connect(
db="mongoenginetest",

7
tests/test_utils.py
View File

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