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

autoformat with updated black

Browse Source
This commit is contained in:
Bastien Gerard 2020-12-08 23:10:07 +01:00
parent ee6ef1ff4b
commit c00a378776
33 changed files with 189 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.pre-commit-config.yaml
View File

@ -1,7 +1,7 @@
fail_fast: false fail_fast: false
repos: repos:
- repo: https://github.com/ambv/black - repo: https://github.com/ambv/black
rev: 19.10b0 rev: 20.8b1
hooks: hooks:
- id: black - id: black
- repo: https://gitlab.com/pycqa/flake8 - repo: https://gitlab.com/pycqa/flake8

18
mongoengine/base/document.py
View File

@ -244,8 +244,7 @@ class BaseDocument:
return iter(self._fields_ordered) return iter(self._fields_ordered)
def __getitem__(self, name): def __getitem__(self, name):
"""Dictionary-style field access, return a field's value if present. """Dictionary-style field access, return a field's value if present."""
"""
try: try:
if name in self._fields_ordered: if name in self._fields_ordered:
return getattr(self, name) return getattr(self, name)
@ -254,8 +253,7 @@ class BaseDocument:
raise KeyError(name) raise KeyError(name)
def __setitem__(self, name, value): def __setitem__(self, name, value):
"""Dictionary-style field access, set a field's value. """Dictionary-style field access, set a field's value."""
"""
# Ensure that the field exists before settings its value # Ensure that the field exists before settings its value
if not self._dynamic and name not in self._fields: if not self._dynamic and name not in self._fields:
raise KeyError(name) raise KeyError(name)
@ -617,8 +615,7 @@ class BaseDocument:
) )
def _get_changed_fields(self): def _get_changed_fields(self):
"""Return a list of all fields that have explicitly been changed. """Return a list of all fields that have explicitly been changed."""
"""
EmbeddedDocument = _import_class("EmbeddedDocument") EmbeddedDocument = _import_class("EmbeddedDocument")
ReferenceField = _import_class("ReferenceField") ReferenceField = _import_class("ReferenceField")
GenericReferenceField = _import_class("GenericReferenceField") GenericReferenceField = _import_class("GenericReferenceField")
@ -750,8 +747,7 @@ class BaseDocument:
@classmethod @classmethod
def _from_son(cls, son, _auto_dereference=True, created=False): def _from_son(cls, son, _auto_dereference=True, created=False):
"""Create an instance of a Document (subclass) from a PyMongo SON (dict) """Create an instance of a Document (subclass) from a PyMongo SON (dict)"""
"""
if son and not isinstance(son, dict): if son and not isinstance(son, dict):
raise ValueError( raise ValueError(
"The source SON object needs to be of type 'dict' but a '%s' was found" "The source SON object needs to be of type 'dict' but a '%s' was found"
@ -800,7 +796,8 @@ class BaseDocument:
["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()] ["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()]
) )
msg = "Invalid data to create a `{}` instance.\n{}".format( msg = "Invalid data to create a `{}` instance.\n{}".format(
cls._class_name, errors, cls._class_name,
errors,
) )
raise InvalidDocumentError(msg) raise InvalidDocumentError(msg)
@ -1165,8 +1162,7 @@ class BaseDocument:
@classmethod @classmethod
def _translate_field_name(cls, field, sep="."): def _translate_field_name(cls, field, sep="."):
"""Translate a field attribute name to a database field name. """Translate a field attribute name to a database field name."""
"""
parts = field.split(sep) parts = field.split(sep)
parts = [f.db_field for f in cls._lookup_field(parts)] parts = [f.db_field for f in cls._lookup_field(parts)]
return ".".join(parts) return ".".join(parts)

3
mongoengine/base/fields.py
View File

@ -117,8 +117,7 @@ class BaseField:
BaseField.creation_counter += 1 BaseField.creation_counter += 1
def __get__(self, instance, owner): def __get__(self, instance, owner):
"""Descriptor for retrieving a value from a field in a document. """Descriptor for retrieving a value from a field in a document."""
"""
if instance is None: if instance is None:
# Document class being used rather than a document object # Document class being used rather than a document object
return self return self

3
mongoengine/context_managers.py
View File

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

3
mongoengine/dereference.py
View File

@ -157,8 +157,7 @@ class DeReference:
return reference_map return reference_map
def _fetch_objects(self, doc_type=None): def _fetch_objects(self, doc_type=None):
"""Fetch all references and convert to their document objects """Fetch all references and convert to their document objects"""
"""
object_map = {} object_map = {}
for collection, dbrefs in self.reference_map.items(): for collection, dbrefs in self.reference_map.items():

3
mongoengine/pymongo_support.py
View File

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

17
mongoengine/queryset/base.py
View File

@ -189,7 +189,8 @@ class BaseQuerySet:
if queryset._scalar: if queryset._scalar:
return queryset._get_scalar( return queryset._get_scalar(
queryset._document._from_son( queryset._document._from_son(
queryset._cursor[key], _auto_dereference=self._auto_dereference, queryset._cursor[key],
_auto_dereference=self._auto_dereference,
) )
) )
@ -197,7 +198,8 @@ class BaseQuerySet:
return queryset._cursor[key] return queryset._cursor[key]
return queryset._document._from_son( return queryset._document._from_son(
queryset._cursor[key], _auto_dereference=self._auto_dereference, queryset._cursor[key],
_auto_dereference=self._auto_dereference,
) )
raise TypeError("Provide a slice or an integer index") raise TypeError("Provide a slice or an integer index")
@ -720,7 +722,7 @@ class BaseQuerySet:
return queryset.filter(pk=object_id).first() return queryset.filter(pk=object_id).first()
def in_bulk(self, object_ids): def in_bulk(self, object_ids):
""""Retrieve a set of documents by their ids. """ "Retrieve a set of documents by their ids.
:param object_ids: a list or tuple of ObjectId's :param object_ids: a list or tuple of ObjectId's
:rtype: dict of ObjectId's as keys and collection-specific :rtype: dict of ObjectId's as keys and collection-specific
@ -738,7 +740,8 @@ class BaseQuerySet:
else: else:
for doc in docs: for doc in docs:
doc_map[doc["_id"]] = self._document._from_son( doc_map[doc["_id"]] = self._document._from_son(
doc, _auto_dereference=self._auto_dereference, doc,
_auto_dereference=self._auto_dereference,
) )
return doc_map return doc_map
@ -1556,8 +1559,7 @@ class BaseQuerySet:
# Iterator helpers # Iterator helpers
def __next__(self): def __next__(self):
"""Wrap the result in a :class:`~mongoengine.Document` object. """Wrap the result in a :class:`~mongoengine.Document` object."""
"""
if self._none or self._empty: if self._none or self._empty:
raise StopIteration raise StopIteration
@ -1567,7 +1569,8 @@ class BaseQuerySet:
return raw_doc return raw_doc
doc = self._document._from_son( doc = self._document._from_son(
raw_doc, _auto_dereference=self._auto_dereference, raw_doc,
_auto_dereference=self._auto_dereference,
) )
if self._scalar: if self._scalar:

12
mongoengine/queryset/visitor.py
View File

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

29
tests/document/test_class_methods.py
View File

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

5
tests/document/test_delta.py
View File

@ -643,7 +643,10 @@ class TestDelta(MongoDBTestCase):
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
assert doc._delta() == ({}, {},) assert doc._delta() == (
{},
{},
)
del doc.embedded_field.list_field[2].list_field del doc.embedded_field.list_field[2].list_field
assert doc._delta() == ( assert doc._delta() == (
{}, {},

36
tests/document/test_indexes.py
View File

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

20
tests/document/test_inheritance.py
View File

@ -45,8 +45,7 @@ class TestInheritance(MongoDBTestCase):
test_doc.delete() test_doc.delete()
def test_superclasses(self): def test_superclasses(self):
"""Ensure that the correct list of superclasses is assembled. """Ensure that the correct list of superclasses is assembled."""
"""
class Animal(Document): class Animal(Document):
meta = {"allow_inheritance": True} meta = {"allow_inheritance": True}
@ -216,8 +215,7 @@ class TestInheritance(MongoDBTestCase):
assert Pike._subclasses == ("Animal.Fish.Pike",) assert Pike._subclasses == ("Animal.Fish.Pike",)
def test_inheritance_meta_data(self): def test_inheritance_meta_data(self):
"""Ensure that document may inherit fields from a superclass document. """Ensure that document may inherit fields from a superclass document."""
"""
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -234,8 +232,7 @@ class TestInheritance(MongoDBTestCase):
assert Employee._get_collection_name() == Person._get_collection_name() assert Employee._get_collection_name() == Person._get_collection_name()
def test_inheritance_to_mongo_keys(self): def test_inheritance_to_mongo_keys(self):
"""Ensure that document may inherit fields from a superclass document. """Ensure that document may inherit fields from a superclass document."""
"""
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -259,7 +256,7 @@ class TestInheritance(MongoDBTestCase):
assert Employee._get_collection_name() == Person._get_collection_name() assert Employee._get_collection_name() == Person._get_collection_name()
def test_indexes_and_multiple_inheritance(self): def test_indexes_and_multiple_inheritance(self):
""" Ensure that all of the indexes are created for a document with """Ensure that all of the indexes are created for a document with
multiple inheritance. multiple inheritance.
""" """
@ -289,8 +286,7 @@ class TestInheritance(MongoDBTestCase):
) )
def test_polymorphic_queries(self): def test_polymorphic_queries(self):
"""Ensure that the correct subclasses are returned from a query """Ensure that the correct subclasses are returned from a query"""
"""
class Animal(Document): class Animal(Document):
meta = {"allow_inheritance": True} meta = {"allow_inheritance": True}
@ -347,8 +343,7 @@ class TestInheritance(MongoDBTestCase):
assert "_cls" not in obj assert "_cls" not in obj
def test_cant_turn_off_inheritance_on_subclass(self): def test_cant_turn_off_inheritance_on_subclass(self):
"""Ensure if inheritance is on in a subclass you cant turn it off. """Ensure if inheritance is on in a subclass you cant turn it off."""
"""
class Animal(Document): class Animal(Document):
name = StringField() name = StringField()
@ -498,8 +493,7 @@ class TestInheritance(MongoDBTestCase):
assert "_cls" in doc.to_mongo() assert "_cls" in doc.to_mongo()
def test_document_inheritance(self): def test_document_inheritance(self):
"""Ensure mutliple inheritance of abstract documents """Ensure mutliple inheritance of abstract documents"""
"""
class DateCreatedDocument(Document): class DateCreatedDocument(Document):
meta = {"allow_inheritance": True, "abstract": True} meta = {"allow_inheritance": True, "abstract": True}

15
tests/document/test_instance.py
View File

@ -160,8 +160,7 @@ class TestDocumentInstance(MongoDBTestCase):
Log.objects Log.objects
def test_repr(self): def test_repr(self):
"""Ensure that unicode representation works """Ensure that unicode representation works"""
"""
class Article(Document): class Article(Document):
title = StringField() title = StringField()
@ -1553,8 +1552,7 @@ class TestDocumentInstance(MongoDBTestCase):
assert site.page.log_message == "Error: Dummy message" assert site.page.log_message == "Error: Dummy message"
def test_update_list_field(self): def test_update_list_field(self):
"""Test update on `ListField` with $pull + $in. """Test update on `ListField` with $pull + $in."""
"""
class Doc(Document): class Doc(Document):
foo = ListField(StringField()) foo = ListField(StringField())
@ -2816,15 +2814,13 @@ class TestDocumentInstance(MongoDBTestCase):
register_connection("testdb-2", "mongoenginetest2") register_connection("testdb-2", "mongoenginetest2")
class A(Document): class A(Document):
"""Uses default db_alias """Uses default db_alias"""
"""
name = StringField() name = StringField()
meta = {"allow_inheritance": True} meta = {"allow_inheritance": True}
class B(A): class B(A):
"""Uses testdb-2 db_alias """Uses testdb-2 db_alias"""
"""
meta = {"db_alias": "testdb-2"} meta = {"db_alias": "testdb-2"}
@ -3612,8 +3608,7 @@ class TestDocumentInstance(MongoDBTestCase):
assert u_from_db.height is None assert u_from_db.height is None
def test_not_saved_eq(self): def test_not_saved_eq(self):
"""Ensure we can compare documents not saved. """Ensure we can compare documents not saved."""
"""
class Person(Document): class Person(Document):
pass pass

6
tests/document/test_validation.py
View File

@ -9,8 +9,7 @@ from tests.utils import MongoDBTestCase
class TestValidatorError(MongoDBTestCase): class TestValidatorError(MongoDBTestCase):
def test_to_dict(self): def test_to_dict(self):
"""Ensure a ValidationError handles error to_dict correctly. """Ensure a ValidationError handles error to_dict correctly."""
"""
error = ValidationError("root") error = ValidationError("root")
assert error.to_dict() == {} assert error.to_dict() == {}
@ -90,8 +89,7 @@ class TestValidatorError(MongoDBTestCase):
p.validate() p.validate()
def test_embedded_document_validation(self): def test_embedded_document_validation(self):
"""Ensure that embedded documents may be validated. """Ensure that embedded documents may be validated."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
date = DateTimeField() date = DateTimeField()

6
tests/fields/test_binary_field.py
View File

@ -13,8 +13,7 @@ BIN_VALUE = "\xa9\xf3\x8d(\xd7\x03\x84\xb4k[\x0f\xe3\xa2\x19\x85p[J\xa3\xd2>\xde
class TestBinaryField(MongoDBTestCase): class TestBinaryField(MongoDBTestCase):
def test_binary_fields(self): def test_binary_fields(self):
"""Ensure that binary fields can be stored and retrieved. """Ensure that binary fields can be stored and retrieved."""
"""
class Attachment(Document): class Attachment(Document):
content_type = StringField() content_type = StringField()
@ -33,8 +32,7 @@ class TestBinaryField(MongoDBTestCase):
assert BLOB == bytes(attachment_1.blob) assert BLOB == bytes(attachment_1.blob)
def test_validation_succeeds(self): def test_validation_succeeds(self):
"""Ensure that valid values can be assigned to binary fields. """Ensure that valid values can be assigned to binary fields."""
"""
class AttachmentRequired(Document): class AttachmentRequired(Document):
blob = BinaryField(required=True) blob = BinaryField(required=True)

3
tests/fields/test_decimal_field.py
View File

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

45
tests/fields/test_fields.py
View File

@ -544,8 +544,7 @@ class TestField(MongoDBTestCase):
post.validate() post.validate()
def test_sorted_list_sorting(self): def test_sorted_list_sorting(self):
"""Ensure that a sorted list field properly sorts values. """Ensure that a sorted list field properly sorts values."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
order = IntField() order = IntField()
@ -661,8 +660,7 @@ class TestField(MongoDBTestCase):
) )
def test_list_field_manipulative_operators(self): def test_list_field_manipulative_operators(self):
"""Ensure that ListField works with standard list operators that manipulate the list. """Ensure that ListField works with standard list operators that manipulate the list."""
"""
class BlogPost(Document): class BlogPost(Document):
ref = StringField() ref = StringField()
@ -1372,8 +1370,7 @@ class TestField(MongoDBTestCase):
assert bar.generic_ref == {"_ref": expected, "_cls": "Foo"} assert bar.generic_ref == {"_ref": expected, "_cls": "Foo"}
def test_list_item_dereference(self): def test_list_item_dereference(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -1398,8 +1395,7 @@ class TestField(MongoDBTestCase):
assert group_obj.members[1].name == user2.name assert group_obj.members[1].name == user2.name
def test_recursive_reference(self): def test_recursive_reference(self):
"""Ensure that ReferenceFields can reference their own documents. """Ensure that ReferenceFields can reference their own documents."""
"""
class Employee(Document): class Employee(Document):
name = StringField() name = StringField()
@ -1426,8 +1422,7 @@ class TestField(MongoDBTestCase):
assert peter.friends == friends assert peter.friends == friends
def test_recursive_embedding(self): def test_recursive_embedding(self):
"""Ensure that EmbeddedDocumentFields can contain their own documents. """Ensure that EmbeddedDocumentFields can contain their own documents."""
"""
class TreeNode(EmbeddedDocument): class TreeNode(EmbeddedDocument):
name = StringField() name = StringField()
@ -1503,8 +1498,7 @@ class TestField(MongoDBTestCase):
AbstractDoc.drop_collection() AbstractDoc.drop_collection()
def test_reference_class_with_abstract_parent(self): def test_reference_class_with_abstract_parent(self):
"""Ensure that a class with an abstract parent can be referenced. """Ensure that a class with an abstract parent can be referenced."""
"""
class Sibling(Document): class Sibling(Document):
name = StringField() name = StringField()
@ -1574,8 +1568,7 @@ class TestField(MongoDBTestCase):
brother.save() brother.save()
def test_generic_reference(self): def test_generic_reference(self):
"""Ensure that a GenericReferenceField properly dereferences items. """Ensure that a GenericReferenceField properly dereferences items."""
"""
class Link(Document): class Link(Document):
title = StringField() title = StringField()
@ -1614,8 +1607,7 @@ class TestField(MongoDBTestCase):
assert isinstance(bm.bookmark_object, Link) assert isinstance(bm.bookmark_object, Link)
def test_generic_reference_list(self): def test_generic_reference_list(self):
"""Ensure that a ListField properly dereferences generic references. """Ensure that a ListField properly dereferences generic references."""
"""
class Link(Document): class Link(Document):
title = StringField() title = StringField()
@ -1718,8 +1710,7 @@ class TestField(MongoDBTestCase):
assert bm.bookmark_object == post_1 assert bm.bookmark_object == post_1
def test_generic_reference_string_choices(self): def test_generic_reference_string_choices(self):
"""Ensure that a GenericReferenceField can handle choices as strings """Ensure that a GenericReferenceField can handle choices as strings"""
"""
class Link(Document): class Link(Document):
title = StringField() title = StringField()
@ -1811,8 +1802,7 @@ class TestField(MongoDBTestCase):
assert user.bookmarks == [post_1] assert user.bookmarks == [post_1]
def test_generic_reference_list_item_modification(self): def test_generic_reference_list_item_modification(self):
"""Ensure that modifications of related documents (through generic reference) don't influence on querying """Ensure that modifications of related documents (through generic reference) don't influence on querying"""
"""
class Post(Document): class Post(Document):
title = StringField() title = StringField()
@ -1900,8 +1890,7 @@ class TestField(MongoDBTestCase):
assert doc == doc2 assert doc == doc2
def test_choices_allow_using_sets_as_choices(self): def test_choices_allow_using_sets_as_choices(self):
"""Ensure that sets can be used when setting choices """Ensure that sets can be used when setting choices"""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(choices={"M", "L"}) size = StringField(choices={"M", "L"})
@ -1920,8 +1909,7 @@ class TestField(MongoDBTestCase):
shirt.validate() shirt.validate()
def test_choices_validation_accept_possible_value(self): def test_choices_validation_accept_possible_value(self):
"""Ensure that value is in a container of allowed values. """Ensure that value is in a container of allowed values."""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(choices=("S", "M")) size = StringField(choices=("S", "M"))
@ -1930,8 +1918,7 @@ class TestField(MongoDBTestCase):
shirt.validate() shirt.validate()
def test_choices_validation_reject_unknown_value(self): def test_choices_validation_reject_unknown_value(self):
"""Ensure that unallowed value are rejected upon validation """Ensure that unallowed value are rejected upon validation"""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(choices=("S", "M")) size = StringField(choices=("S", "M"))
@ -1989,8 +1976,7 @@ class TestField(MongoDBTestCase):
shirt1.validate() shirt1.validate()
def test_simple_choices_validation(self): def test_simple_choices_validation(self):
"""Ensure that value is in a container of allowed values. """Ensure that value is in a container of allowed values."""
"""
class Shirt(Document): class Shirt(Document):
size = StringField(max_length=3, choices=("S", "M", "L", "XL", "XXL")) size = StringField(max_length=3, choices=("S", "M", "L", "XL", "XXL"))
@ -2039,8 +2025,7 @@ class TestField(MongoDBTestCase):
shirt.validate() shirt.validate()
def test_simple_choices_validation_invalid_value(self): def test_simple_choices_validation_invalid_value(self):
"""Ensure that error messages are correct. """Ensure that error messages are correct."""
"""
SIZES = ("S", "M", "L", "XL", "XXL") SIZES = ("S", "M", "L", "XL", "XXL")
COLORS = (("R", "Red"), ("B", "Blue")) COLORS = (("R", "Red"), ("B", "Blue"))
SIZE_MESSAGE = u"Value must be one of ('S', 'M', 'L', 'XL', 'XXL')" SIZE_MESSAGE = u"Value must be one of ('S', 'M', 'L', 'XL', 'XXL')"

12
tests/fields/test_file_field.py
View File

@ -48,8 +48,7 @@ class TestFileField(MongoDBTestCase):
DemoFile.objects.create() DemoFile.objects.create()
def test_file_fields(self): def test_file_fields(self):
"""Ensure that file fields can be written to and their data retrieved """Ensure that file fields can be written to and their data retrieved"""
"""
class PutFile(Document): class PutFile(Document):
the_file = FileField() the_file = FileField()
@ -91,8 +90,7 @@ class TestFileField(MongoDBTestCase):
result.the_file.delete() result.the_file.delete()
def test_file_fields_stream(self): def test_file_fields_stream(self):
"""Ensure that file fields can be written to and their data retrieved """Ensure that file fields can be written to and their data retrieved"""
"""
class StreamFile(Document): class StreamFile(Document):
the_file = FileField() the_file = FileField()
@ -228,8 +226,7 @@ class TestFileField(MongoDBTestCase):
assert ["doc_b", "doc_e"] == grid_fs.list() assert ["doc_b", "doc_e"] == grid_fs.list()
def test_file_uniqueness(self): def test_file_uniqueness(self):
"""Ensure that each instance of a FileField is unique """Ensure that each instance of a FileField is unique"""
"""
class TestFile(Document): class TestFile(Document):
name = StringField() name = StringField()
@ -285,8 +282,7 @@ class TestFileField(MongoDBTestCase):
assert test_file.the_file.get().length == 4971 assert test_file.the_file.get().length == 4971
def test_file_boolean(self): def test_file_boolean(self):
"""Ensure that a boolean test of a FileField indicates its presence """Ensure that a boolean test of a FileField indicates its presence"""
"""
class TestFile(Document): class TestFile(Document):
the_file = FileField() the_file = FileField()

3
tests/fields/test_float_field.py
View File

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

9
tests/fields/test_geo_fields.py
View File

@ -290,8 +290,7 @@ class TestGeoField(MongoDBTestCase):
Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate() Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate()
def test_indexes_geopoint(self): def test_indexes_geopoint(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields."""
"""
class Event(Document): class Event(Document):
title = StringField() title = StringField()
@ -317,8 +316,7 @@ class TestGeoField(MongoDBTestCase):
assert geo_indicies == [{"fields": [("venue.location", "2d")]}] assert geo_indicies == [{"fields": [("venue.location", "2d")]}]
def test_indexes_2dsphere(self): def test_indexes_2dsphere(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields."""
"""
class Event(Document): class Event(Document):
title = StringField() title = StringField()
@ -332,8 +330,7 @@ class TestGeoField(MongoDBTestCase):
assert {"fields": [("point", "2dsphere")]} in geo_indicies assert {"fields": [("point", "2dsphere")]} in geo_indicies
def test_indexes_2dsphere_embedded(self): def test_indexes_2dsphere_embedded(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields."""
"""
class Venue(EmbeddedDocument): class Venue(EmbeddedDocument):
name = StringField() name = StringField()

3
tests/fields/test_int_field.py
View File

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

3
tests/fields/test_long_field.py
View File

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

3
tests/fields/test_reference_field.py
View File

@ -107,8 +107,7 @@ class TestReferenceField(MongoDBTestCase):
assert p.parent == p1 assert p.parent == p1
def test_undefined_reference(self): def test_undefined_reference(self):
"""Ensure that ReferenceFields may reference undefined Documents. """Ensure that ReferenceFields may reference undefined Documents."""
"""
class Product(Document): class Product(Document):
name = StringField() name = StringField()

3
tests/fields/test_url_field.py
View File

@ -38,8 +38,7 @@ class TestURLField(MongoDBTestCase):
) )
def test_url_scheme_validation(self): def test_url_scheme_validation(self):
"""Ensure that URLFields validate urls with specific schemes properly. """Ensure that URLFields validate urls with specific schemes properly."""
"""
class Link(Document): class Link(Document):
url = URLField() url = URLField()

3
tests/fields/test_uuid_field.py
View File

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

9
tests/queryset/test_field_list.py
View File

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

162
tests/queryset/test_queryset.py
View File

@ -60,8 +60,7 @@ class TestQueryset(unittest.TestCase):
self.mongodb_version = get_mongodb_version() self.mongodb_version = get_mongodb_version()
def test_initialisation(self): def test_initialisation(self):
"""Ensure that a QuerySet is correctly initialised by QuerySetManager. """Ensure that a QuerySet is correctly initialised by QuerySetManager."""
"""
assert isinstance(self.Person.objects, QuerySet) assert isinstance(self.Person.objects, QuerySet)
assert ( assert (
self.Person.objects._collection.name == self.Person._get_collection_name() self.Person.objects._collection.name == self.Person._get_collection_name()
@ -271,8 +270,7 @@ class TestQueryset(unittest.TestCase):
) )
def test_find_one(self): def test_find_one(self):
"""Ensure that a query using find_one returns a valid result. """Ensure that a query using find_one returns a valid result."""
"""
person1 = self.Person(name="User A", age=20) person1 = self.Person(name="User A", age=20)
person1.save() person1.save()
person2 = self.Person(name="User B", age=30) person2 = self.Person(name="User B", age=30)
@ -317,8 +315,7 @@ class TestQueryset(unittest.TestCase):
self.Person.objects.get() self.Person.objects.get()
def test_get_multiple_match_raises_multipleobjectsreturned(self): def test_get_multiple_match_raises_multipleobjectsreturned(self):
"""Ensure that a query using ``get`` returns at most one result. """Ensure that a query using ``get`` returns at most one result."""
"""
assert self.Person.objects().count() == 0 assert self.Person.objects().count() == 0
person1 = self.Person(name="User A", age=20) person1 = self.Person(name="User A", age=20)
@ -351,8 +348,7 @@ class TestQueryset(unittest.TestCase):
assert person == person3 assert person == person3
def test_find_array_position(self): def test_find_array_position(self):
"""Ensure that query by array position works. """Ensure that query by array position works."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
name = StringField() name = StringField()
@ -1141,8 +1137,7 @@ class TestQueryset(unittest.TestCase):
assert q == 2 assert q == 2
def test_repeated_iteration(self): def test_repeated_iteration(self):
"""Ensure that QuerySet rewinds itself one iteration finishes. """Ensure that QuerySet rewinds itself one iteration finishes."""
"""
self.Person(name="Person 1").save() self.Person(name="Person 1").save()
self.Person(name="Person 2").save() self.Person(name="Person 2").save()
@ -1191,8 +1186,7 @@ class TestQueryset(unittest.TestCase):
assert ".. queryset mid-iteration .." == repr(docs) assert ".. queryset mid-iteration .." == repr(docs)
def test_regex_query_shortcuts(self): def test_regex_query_shortcuts(self):
"""Ensure that contains, startswith, endswith, etc work. """Ensure that contains, startswith, endswith, etc work."""
"""
person = self.Person(name="Guido van Rossum") person = self.Person(name="Guido van Rossum")
person.save() person.save()
@ -1248,8 +1242,7 @@ class TestQueryset(unittest.TestCase):
assert obj == person assert obj == person
def test_not(self): def test_not(self):
"""Ensure that the __not operator works as expected. """Ensure that the __not operator works as expected."""
"""
alice = self.Person(name="Alice", age=25) alice = self.Person(name="Alice", age=25)
alice.save() alice.save()
@ -1260,8 +1253,7 @@ class TestQueryset(unittest.TestCase):
assert obj is None assert obj is None
def test_filter_chaining(self): def test_filter_chaining(self):
"""Ensure filters can be chained together. """Ensure filters can be chained together."""
"""
class Blog(Document): class Blog(Document):
id = StringField(primary_key=True) id = StringField(primary_key=True)
@ -1337,8 +1329,7 @@ class TestQueryset(unittest.TestCase):
assert qs[i] == expected[i] assert qs[i] == expected[i]
def test_ordering(self): def test_ordering(self):
"""Ensure default ordering is applied and can be overridden. """Ensure default ordering is applied and can be overridden."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -1408,8 +1399,7 @@ class TestQueryset(unittest.TestCase):
assert ORDER_BY_KEY not in q.get_ops()[0][CMD_QUERY_KEY] assert ORDER_BY_KEY not in q.get_ops()[0][CMD_QUERY_KEY]
def test_no_ordering_for_get(self): def test_no_ordering_for_get(self):
""" Ensure that Doc.objects.get doesn't use any ordering. """Ensure that Doc.objects.get doesn't use any ordering."""
"""
ORDER_BY_KEY, CMD_QUERY_KEY = get_key_compat(self.mongodb_version) ORDER_BY_KEY, CMD_QUERY_KEY = get_key_compat(self.mongodb_version)
class BlogPost(Document): class BlogPost(Document):
@ -1485,8 +1475,7 @@ class TestQueryset(unittest.TestCase):
assert result.author is None assert result.author is None
def test_find_dict_item(self): def test_find_dict_item(self):
"""Ensure that DictField items may be found. """Ensure that DictField items may be found."""
"""
class BlogPost(Document): class BlogPost(Document):
info = DictField() info = DictField()
@ -1502,8 +1491,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_exec_js_query(self): def test_exec_js_query(self):
"""Ensure that queries are properly formed for use in exec_js. """Ensure that queries are properly formed for use in exec_js."""
"""
class BlogPost(Document): class BlogPost(Document):
hits = IntField() hits = IntField()
@ -1540,8 +1528,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_exec_js_field_sub(self): def test_exec_js_field_sub(self):
"""Ensure that field substitutions occur properly in exec_js functions. """Ensure that field substitutions occur properly in exec_js functions."""
"""
class Comment(EmbeddedDocument): class Comment(EmbeddedDocument):
content = StringField(db_field="body") content = StringField(db_field="body")
@ -1597,8 +1584,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_delete(self): def test_delete(self):
"""Ensure that documents are properly deleted from the database. """Ensure that documents are properly deleted from the database."""
"""
self.Person(name="User A", age=20).save() self.Person(name="User A", age=20).save()
self.Person(name="User B", age=30).save() self.Person(name="User B", age=30).save()
self.Person(name="User C", age=40).save() self.Person(name="User C", age=40).save()
@ -1612,8 +1598,7 @@ class TestQueryset(unittest.TestCase):
assert self.Person.objects.count() == 0 assert self.Person.objects.count() == 0
def test_reverse_delete_rule_cascade(self): def test_reverse_delete_rule_cascade(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1745,8 +1730,7 @@ class TestQueryset(unittest.TestCase):
assert 0 == Category.objects.count() assert 0 == Category.objects.count()
def test_reverse_delete_rule_nullify(self): def test_reverse_delete_rule_nullify(self):
"""Ensure nullification of references to deleted documents. """Ensure nullification of references to deleted documents."""
"""
class Category(Document): class Category(Document):
name = StringField() name = StringField()
@ -1842,8 +1826,7 @@ class TestQueryset(unittest.TestCase):
self.Person.objects.delete() self.Person.objects.delete()
def test_reverse_delete_rule_pull(self): def test_reverse_delete_rule_pull(self):
"""Ensure pulling of references to deleted documents. """Ensure pulling of references to deleted documents."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1918,8 +1901,7 @@ class TestQueryset(unittest.TestCase):
assert 8 == Log.objects.count() assert 8 == Log.objects.count()
def test_delete_with_limit_handles_delete_rules(self): def test_delete_with_limit_handles_delete_rules(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1951,8 +1933,7 @@ class TestQueryset(unittest.TestCase):
assert del_result is None assert del_result is None
def test_reference_field_find(self): def test_reference_field_find(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -1973,8 +1954,7 @@ class TestQueryset(unittest.TestCase):
assert 1 == BlogPost.objects(author__in=["%s" % me.pk]).count() assert 1 == BlogPost.objects(author__in=["%s" % me.pk]).count()
def test_reference_field_find_dbref(self): def test_reference_field_find_dbref(self):
"""Ensure cascading deletion of referring documents from the database. """Ensure cascading deletion of referring documents from the database."""
"""
class BlogPost(Document): class BlogPost(Document):
content = StringField() content = StringField()
@ -2058,8 +2038,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.objects.update_one(inc__review=0.1) # test with floats BlogPost.objects.update_one(inc__review=0.1) # test with floats
def test_update_listfield_operator(self): def test_update_listfield_operator(self):
"""Ensure that atomic updates work properly. """Ensure that atomic updates work properly."""
"""
class BlogPost(Document): class BlogPost(Document):
tags = ListField(StringField()) tags = ListField(StringField())
@ -2107,8 +2086,7 @@ class TestQueryset(unittest.TestCase):
assert "title" not in pymongo_doc assert "title" not in pymongo_doc
def test_update_push_with_position(self): def test_update_push_with_position(self):
"""Ensure that the 'push' update with position works properly. """Ensure that the 'push' update with position works properly."""
"""
class BlogPost(Document): class BlogPost(Document):
slug = StringField() slug = StringField()
@ -2133,8 +2111,7 @@ class TestQueryset(unittest.TestCase):
assert post.tags == ["scala", "mongodb", "python", "java"] assert post.tags == ["scala", "mongodb", "python", "java"]
def test_update_push_list_of_list(self): def test_update_push_list_of_list(self):
"""Ensure that the 'push' update operation works in the list of list """Ensure that the 'push' update operation works in the list of list"""
"""
class BlogPost(Document): class BlogPost(Document):
slug = StringField() slug = StringField()
@ -2149,8 +2126,7 @@ class TestQueryset(unittest.TestCase):
assert post.tags == [["value1", 123]] assert post.tags == [["value1", 123]]
def test_update_push_and_pull_add_to_set(self): def test_update_push_and_pull_add_to_set(self):
"""Ensure that the 'pull' update operation works correctly. """Ensure that the 'pull' update operation works correctly."""
"""
class BlogPost(Document): class BlogPost(Document):
slug = StringField() slug = StringField()
@ -2259,8 +2235,7 @@ class TestQueryset(unittest.TestCase):
) )
def test_pull_from_nested_embedded_using_in_nin(self): def test_pull_from_nested_embedded_using_in_nin(self):
"""Ensure that the 'pull' update operation works on embedded documents using 'in' and 'nin' operators. """Ensure that the 'pull' update operation works on embedded documents using 'in' and 'nin' operators."""
"""
class User(EmbeddedDocument): class User(EmbeddedDocument):
name = StringField() name = StringField()
@ -2491,8 +2466,7 @@ class TestQueryset(unittest.TestCase):
assert doc.pk == doc.embedded[0]._instance.pk assert doc.pk == doc.embedded[0]._instance.pk
def test_order_by(self): def test_order_by(self):
"""Ensure that QuerySets may be ordered. """Ensure that QuerySets may be ordered."""
"""
self.Person(name="User B", age=40).save() self.Person(name="User B", age=40).save()
self.Person(name="User A", age=20).save() self.Person(name="User A", age=20).save()
self.Person(name="User C", age=30).save() self.Person(name="User C", age=30).save()
@ -2560,8 +2534,7 @@ class TestQueryset(unittest.TestCase):
self.assertSequence(qs, expected) self.assertSequence(qs, expected)
def test_order_by_chaining(self): def test_order_by_chaining(self):
"""Ensure that an order_by query chains properly and allows .only() """Ensure that an order_by query chains properly and allows .only()"""
"""
self.Person(name="User B", age=40).save() self.Person(name="User B", age=40).save()
self.Person(name="User A", age=20).save() self.Person(name="User A", age=20).save()
self.Person(name="User C", age=30).save() self.Person(name="User C", age=30).save()
@ -2635,8 +2608,7 @@ class TestQueryset(unittest.TestCase):
assert op[CMD_QUERY_KEY][COMMENT_KEY] == "looking for an adult" assert op[CMD_QUERY_KEY][COMMENT_KEY] == "looking for an adult"
def test_map_reduce(self): def test_map_reduce(self):
"""Ensure map/reduce is both mapping and reducing. """Ensure map/reduce is both mapping and reducing."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -2988,8 +2960,7 @@ class TestQueryset(unittest.TestCase):
Link.drop_collection() Link.drop_collection()
def test_item_frequencies(self): def test_item_frequencies(self):
"""Ensure that item frequencies are properly generated from lists. """Ensure that item frequencies are properly generated from lists."""
"""
class BlogPost(Document): class BlogPost(Document):
hits = IntField() hits = IntField()
@ -3057,8 +3028,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_item_frequencies_on_embedded(self): def test_item_frequencies_on_embedded(self):
"""Ensure that item frequencies are properly generated from lists. """Ensure that item frequencies are properly generated from lists."""
"""
class Phone(EmbeddedDocument): class Phone(EmbeddedDocument):
number = StringField() number = StringField()
@ -3214,8 +3184,7 @@ class TestQueryset(unittest.TestCase):
assert freqs == {1: 50.0 / 70, 2: 20.0 / 70} assert freqs == {1: 50.0 / 70, 2: 20.0 / 70}
def test_average(self): def test_average(self):
"""Ensure that field can be averaged correctly. """Ensure that field can be averaged correctly."""
"""
self.Person(name="person", age=0).save() self.Person(name="person", age=0).save()
assert int(self.Person.objects.average("age")) == 0 assert int(self.Person.objects.average("age")) == 0
@ -3255,8 +3224,7 @@ class TestQueryset(unittest.TestCase):
assert self.Person.objects.filter(age__gte=50).average("age") == avg assert self.Person.objects.filter(age__gte=50).average("age") == avg
def test_sum(self): def test_sum(self):
"""Ensure that field can be summed over correctly. """Ensure that field can be summed over correctly."""
"""
ages = [23, 54, 12, 94, 27] ages = [23, 54, 12, 94, 27]
for i, age in enumerate(ages): for i, age in enumerate(ages):
self.Person(name="test%s" % i, age=age).save() self.Person(name="test%s" % i, age=age).save()
@ -3406,8 +3374,7 @@ class TestQueryset(unittest.TestCase):
assert Doc.objects.sum("values") == 1360 assert Doc.objects.sum("values") == 1360
def test_distinct(self): def test_distinct(self):
"""Ensure that the QuerySet.distinct method works. """Ensure that the QuerySet.distinct method works."""
"""
self.Person(name="Mr Orange", age=20).save() self.Person(name="Mr Orange", age=20).save()
self.Person(name="Mr White", age=20).save() self.Person(name="Mr White", age=20).save()
self.Person(name="Mr Orange", age=30).save() self.Person(name="Mr Orange", age=30).save()
@ -3547,8 +3514,7 @@ class TestQueryset(unittest.TestCase):
assert Foo.objects.distinct("bar") == [bar] assert Foo.objects.distinct("bar") == [bar]
def test_distinct_handles_db_field(self): def test_distinct_handles_db_field(self):
"""Ensure that distinct resolves field name to db_field as expected. """Ensure that distinct resolves field name to db_field as expected."""
"""
class Product(Document): class Product(Document):
product_id = IntField(db_field="pid") product_id = IntField(db_field="pid")
@ -3644,8 +3610,7 @@ class TestQueryset(unittest.TestCase):
assert Foo.objects.distinct("bar_lst") == [bar_1, bar_2] assert Foo.objects.distinct("bar_lst") == [bar_1, bar_2]
def test_custom_manager(self): def test_custom_manager(self):
"""Ensure that custom QuerySetManager instances work as expected. """Ensure that custom QuerySetManager instances work as expected."""
"""
class BlogPost(Document): class BlogPost(Document):
tags = ListField(StringField()) tags = ListField(StringField())
@ -3746,8 +3711,7 @@ class TestQueryset(unittest.TestCase):
assert 1 == Bar.objects.count() assert 1 == Bar.objects.count()
def test_query_value_conversion(self): def test_query_value_conversion(self):
"""Ensure that query values are properly converted when necessary. """Ensure that query values are properly converted when necessary."""
"""
class BlogPost(Document): class BlogPost(Document):
author = ReferenceField(self.Person) author = ReferenceField(self.Person)
@ -3773,8 +3737,7 @@ class TestQueryset(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
def test_update_value_conversion(self): def test_update_value_conversion(self):
"""Ensure that values used in updates are converted before use. """Ensure that values used in updates are converted before use."""
"""
class Group(Document): class Group(Document):
members = ListField(ReferenceField(self.Person)) members = ListField(ReferenceField(self.Person))
@ -3799,8 +3762,7 @@ class TestQueryset(unittest.TestCase):
Group.drop_collection() Group.drop_collection()
def test_bulk(self): def test_bulk(self):
"""Ensure bulk querying by object id returns a proper dict. """Ensure bulk querying by object id returns a proper dict."""
"""
class BlogPost(Document): class BlogPost(Document):
title = StringField() title = StringField()
@ -3838,8 +3800,7 @@ class TestQueryset(unittest.TestCase):
self.Person.drop_collection() self.Person.drop_collection()
def test_custom_querysets(self): def test_custom_querysets(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3859,8 +3820,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_set_manager_directly(self): def test_custom_querysets_set_manager_directly(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3883,8 +3843,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_managers_directly(self): def test_custom_querysets_managers_directly(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySetManager(QuerySetManager): class CustomQuerySetManager(QuerySetManager):
@staticmethod @staticmethod
@ -3905,8 +3864,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_inherited(self): def test_custom_querysets_inherited(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3928,8 +3886,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_custom_querysets_inherited_direct(self): def test_custom_querysets_inherited_direct(self):
"""Ensure that custom QuerySet classes may be used. """Ensure that custom QuerySet classes may be used."""
"""
class CustomQuerySet(QuerySet): class CustomQuerySet(QuerySet):
def not_empty(self): def not_empty(self):
@ -3990,8 +3947,7 @@ class TestQueryset(unittest.TestCase):
assert A.objects(b=[{"c": "c"}]).count() == 0 assert A.objects(b=[{"c": "c"}]).count() == 0
def test_call_after_limits_set(self): def test_call_after_limits_set(self):
"""Ensure that re-filtering after slicing works """Ensure that re-filtering after slicing works"""
"""
class Post(Document): class Post(Document):
title = StringField() title = StringField()
@ -4007,8 +3963,7 @@ class TestQueryset(unittest.TestCase):
Post.drop_collection() Post.drop_collection()
def test_order_then_filter(self): def test_order_then_filter(self):
"""Ensure that ordering still works after filtering. """Ensure that ordering still works after filtering."""
"""
class Number(Document): class Number(Document):
n = IntField() n = IntField()
@ -4025,8 +3980,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_clone(self): def test_clone(self):
"""Ensure that cloning clones complex querysets """Ensure that cloning clones complex querysets"""
"""
class Number(Document): class Number(Document):
n = IntField() n = IntField()
@ -4055,8 +4009,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_clone_retains_settings(self): def test_clone_retains_settings(self):
"""Ensure that cloning retains the read_preference and read_concern """Ensure that cloning retains the read_preference and read_concern"""
"""
class Number(Document): class Number(Document):
n = IntField() n = IntField()
@ -4081,8 +4034,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_using(self): def test_using(self):
"""Ensure that switching databases for a queryset is possible """Ensure that switching databases for a queryset is possible"""
"""
class Number2(Document): class Number2(Document):
n = IntField() n = IntField()
@ -4134,8 +4086,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_order_works_with_primary(self): def test_order_works_with_primary(self):
"""Ensure that order_by and primary work. """Ensure that order_by and primary work."""
"""
class Number(Document): class Number(Document):
n = IntField(primary_key=True) n = IntField(primary_key=True)
@ -4154,8 +4105,7 @@ class TestQueryset(unittest.TestCase):
Number.drop_collection() Number.drop_collection()
def test_ensure_index(self): def test_ensure_index(self):
"""Ensure that manual creation of indexes works. """Ensure that manual creation of indexes works."""
"""
class Comment(Document): class Comment(Document):
message = StringField() message = StringField()
@ -4171,8 +4121,7 @@ class TestQueryset(unittest.TestCase):
assert ([("_cls", 1), ("message", 1)], False, False) in info assert ([("_cls", 1), ("message", 1)], False, False) in info
def test_where(self): def test_where(self):
"""Ensure that where clauses work. """Ensure that where clauses work."""
"""
class IntPair(Document): class IntPair(Document):
fielda = IntField() fielda = IntField()
@ -4451,8 +4400,7 @@ class TestQueryset(unittest.TestCase):
assert list(val) == [("test", "test value")] assert list(val) == [("test", "test value")]
def test_scalar_cursor_behaviour(self): def test_scalar_cursor_behaviour(self):
"""Ensure that a query returns a valid set of results. """Ensure that a query returns a valid set of results."""
"""
person1 = self.Person(name="User A", age=20) person1 = self.Person(name="User A", age=20)
person1.save() person1.save()
person2 = self.Person(name="User B", age=30) person2 = self.Person(name="User B", age=30)
@ -4669,8 +4617,7 @@ class TestQueryset(unittest.TestCase):
assert [b3] == ak assert [b3] == ak
def test_upsert_includes_cls(self): def test_upsert_includes_cls(self):
"""Upserts should include _cls information for inheritable classes """Upserts should include _cls information for inheritable classes"""
"""
class Test(Document): class Test(Document):
test = StringField() test = StringField()
@ -5366,8 +5313,7 @@ class TestQueryset(unittest.TestCase):
assert obj.__class__ == C assert obj.__class__ == C
def test_query_generic_embedded_document(self): def test_query_generic_embedded_document(self):
"""Ensure that querying sub field on generic_embedded_field works """Ensure that querying sub field on generic_embedded_field works"""
"""
class A(EmbeddedDocument): class A(EmbeddedDocument):
a_name = StringField() a_name = StringField()

6
tests/queryset/test_transform.py
View File

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

24
tests/queryset/test_visitor.py
View File

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

24
tests/test_connection.py
View File

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

6
tests/test_context_managers.py
View File

@ -117,8 +117,7 @@ class TestContextManagers:
assert 1 == Group.objects.count() assert 1 == Group.objects.count()
def test_no_dereference_context_manager_object_id(self): def test_no_dereference_context_manager_object_id(self):
"""Ensure that DBRef items in ListFields aren't dereferenced. """Ensure that DBRef items in ListFields aren't dereferenced."""
"""
connect("mongoenginetest") connect("mongoenginetest")
class User(Document): class User(Document):
@ -155,8 +154,7 @@ class TestContextManagers:
assert isinstance(group.generic, User) assert isinstance(group.generic, User)
def test_no_dereference_context_manager_dbref(self): def test_no_dereference_context_manager_dbref(self):
"""Ensure that DBRef items in ListFields aren't dereferenced. """Ensure that DBRef items in ListFields aren't dereferenced."""
"""
connect("mongoenginetest") connect("mongoenginetest")
class User(Document): class User(Document):

39
tests/test_dereference.py
View File

@ -16,8 +16,7 @@ class FieldTest(unittest.TestCase):
cls.db.drop_database("mongoenginetest") cls.db.drop_database("mongoenginetest")
def test_list_item_dereference(self): def test_list_item_dereference(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -75,8 +74,7 @@ class FieldTest(unittest.TestCase):
Group.drop_collection() Group.drop_collection()
def test_list_item_dereference_dref_false(self): def test_list_item_dereference_dref_false(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -132,8 +130,7 @@ class FieldTest(unittest.TestCase):
assert q == 2 assert q == 2
def test_list_item_dereference_orphan_dbref(self): def test_list_item_dereference_orphan_dbref(self):
"""Ensure that orphan DBRef items in ListFields are dereferenced. """Ensure that orphan DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -176,8 +173,7 @@ class FieldTest(unittest.TestCase):
Group.drop_collection() Group.drop_collection()
def test_list_item_dereference_dref_false_stores_as_type(self): def test_list_item_dereference_dref_false_stores_as_type(self):
"""Ensure that DBRef items are stored as their type """Ensure that DBRef items are stored as their type"""
"""
class User(Document): class User(Document):
my_id = IntField(primary_key=True) my_id = IntField(primary_key=True)
@ -198,8 +194,7 @@ class FieldTest(unittest.TestCase):
assert group.members == [user] assert group.members == [user]
def test_handle_old_style_references(self): def test_handle_old_style_references(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -232,8 +227,7 @@ class FieldTest(unittest.TestCase):
assert group.members[-1].name == "String!" assert group.members[-1].name == "String!"
def test_migrate_references(self): def test_migrate_references(self):
"""Example of migrating ReferenceField storage """Example of migrating ReferenceField storage"""
"""
# Create some sample data # Create some sample data
class User(Document): class User(Document):
@ -278,8 +272,7 @@ class FieldTest(unittest.TestCase):
assert isinstance(raw_data["members"][0], ObjectId) assert isinstance(raw_data["members"][0], ObjectId)
def test_recursive_reference(self): def test_recursive_reference(self):
"""Ensure that ReferenceFields can reference their own documents. """Ensure that ReferenceFields can reference their own documents."""
"""
class Employee(Document): class Employee(Document):
name = StringField() name = StringField()
@ -402,8 +395,7 @@ class FieldTest(unittest.TestCase):
assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects() assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects()
def test_circular_reference_on_self(self): def test_circular_reference_on_self(self):
"""Ensure you can handle circular references """Ensure you can handle circular references"""
"""
class Person(Document): class Person(Document):
name = StringField() name = StringField()
@ -430,8 +422,7 @@ class FieldTest(unittest.TestCase):
assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects() assert "[<Person: Mother>, <Person: Daughter>]" == "%s" % Person.objects()
def test_circular_tree_reference(self): def test_circular_tree_reference(self):
"""Ensure you can handle circular references with more than one level """Ensure you can handle circular references with more than one level"""
"""
class Other(EmbeddedDocument): class Other(EmbeddedDocument):
name = StringField() name = StringField()
@ -557,8 +548,7 @@ class FieldTest(unittest.TestCase):
assert "User" in m.__class__.__name__ assert "User" in m.__class__.__name__
def test_generic_reference_orphan_dbref(self): def test_generic_reference_orphan_dbref(self):
"""Ensure that generic orphan DBRef items in ListFields are dereferenced. """Ensure that generic orphan DBRef items in ListFields are dereferenced."""
"""
class UserA(Document): class UserA(Document):
name = StringField() name = StringField()
@ -1168,8 +1158,7 @@ class FieldTest(unittest.TestCase):
assert msg.author.name == "new-name" assert msg.author.name == "new-name"
def test_list_lookup_not_checked_in_map(self): def test_list_lookup_not_checked_in_map(self):
"""Ensure we dereference list data correctly """Ensure we dereference list data correctly"""
"""
class Comment(Document): class Comment(Document):
id = IntField(primary_key=True) id = IntField(primary_key=True)
@ -1191,8 +1180,7 @@ class FieldTest(unittest.TestCase):
assert 1 == msg.comments[1].id assert 1 == msg.comments[1].id
def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self): def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()
@ -1221,8 +1209,7 @@ class FieldTest(unittest.TestCase):
assert q == 2 assert q == 2
def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self): def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self):
"""Ensure that DBRef items in ListFields are dereferenced. """Ensure that DBRef items in ListFields are dereferenced."""
"""
class User(Document): class User(Document):
name = StringField() name = StringField()

3
tests/test_replicaset_connection.py
View File

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