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

Added Python 3 support to MongoEngine

Browse Source
This commit is contained in:
Laine 2012-08-01 17:21:48 -07:00
parent 4b3cea9e78
commit 91aa90ad4a
17 changed files with 673 additions and 535 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
mongoengine/base.py
View File

@ -1,18 +1,19 @@
import operator
import sys
import warnings import warnings
from collections import defaultdict from collections import defaultdict
from functools import partial
from queryset import QuerySet, QuerySetManager from queryset import QuerySet, QuerySetManager
from queryset import DoesNotExist, MultipleObjectsReturned from queryset import DoesNotExist, MultipleObjectsReturned
from queryset import DO_NOTHING from queryset import DO_NOTHING
from mongoengine import signals from mongoengine import signals
from mongoengine.python3_support import PY3, txt_type
import sys
import pymongo import pymongo
from bson import ObjectId from bson import ObjectId
import operator
from functools import partial
from bson.dbref import DBRef from bson.dbref import DBRef
@ -402,7 +403,7 @@ class ComplexBaseField(BaseField):
""" """
errors = {} errors = {}
if self.field: if self.field:
if hasattr(value, 'iteritems'): if hasattr(value, 'iteritems') or hasattr(value, 'items'):
sequence = value.iteritems() sequence = value.iteritems()
else: else:
sequence = enumerate(value) sequence = enumerate(value)
@ -491,7 +492,7 @@ class DocumentMetaclass(type):
attrs.update(_get_mixin_fields(p_base)) attrs.update(_get_mixin_fields(p_base))
return attrs return attrs
metaclass = attrs.get('__metaclass__') metaclass = attrs.get('my_metaclass')
super_new = super(DocumentMetaclass, cls).__new__ super_new = super(DocumentMetaclass, cls).__new__
if metaclass and issubclass(metaclass, DocumentMetaclass): if metaclass and issubclass(metaclass, DocumentMetaclass):
return super_new(cls, name, bases, attrs) return super_new(cls, name, bases, attrs)
@ -583,7 +584,9 @@ class DocumentMetaclass(type):
raise InvalidDocumentError("Reverse delete rules are not supported for EmbeddedDocuments (field: %s)" % field.name) raise InvalidDocumentError("Reverse delete rules are not supported for EmbeddedDocuments (field: %s)" % field.name)
f.document_type.register_delete_rule(new_class, field.name, delete_rule) f.document_type.register_delete_rule(new_class, field.name, delete_rule)
if field.name and hasattr(Document, field.name) and EmbeddedDocument not in new_class.mro(): if (field.name and
hasattr(Document, field.name) and
EmbeddedDocument not in new_class.mro()):
raise InvalidDocumentError("%s is a document method and not a valid field name" % field.name) raise InvalidDocumentError("%s is a document method and not a valid field name" % field.name)
module = attrs.get('__module__') module = attrs.get('__module__')
@ -602,6 +605,22 @@ class DocumentMetaclass(type):
global _document_registry global _document_registry
_document_registry[doc_class_name] = new_class _document_registry[doc_class_name] = new_class
# in Python 2, User-defined methods objects have special read-only
# attributes 'im_func' and 'im_self' which contain the function obj
# and class instance object respectively. With Python 3 these special
# attributes have been replaced by __func__ and __self__. The Blinker
# module continues to use im_func and im_self, so the code below
# copies __func__ into im_func and __self__ into im_self for
# classmethod objects in Document derived classes.
if PY3:
for key, val in new_class.__dict__.items():
if isinstance(val, classmethod):
f = val.__get__(new_class)
if hasattr(f, '__func__') and not hasattr(f, 'im_func'):
f.__dict__.update({'im_func':getattr(f, '__func__')})
if hasattr(f, '__self__') and not hasattr(f, 'im_self'):
f.__dict__.update({'im_self':getattr(f, '__self__')})
return new_class return new_class
def add_to_class(self, name, value): def add_to_class(self, name, value):
@ -623,7 +642,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
# #
# Also assume a class is abstract if it has abstract set to True in # Also assume a class is abstract if it has abstract set to True in
# its meta dictionary. This allows custom Document superclasses. # its meta dictionary. This allows custom Document superclasses.
if (attrs.get('__metaclass__') == TopLevelDocumentMetaclass or if (attrs.get('my_metaclass') == TopLevelDocumentMetaclass or
('meta' in attrs and attrs['meta'].get('abstract', False))): ('meta' in attrs and attrs['meta'].get('abstract', False))):
# Make sure no base class was non-abstract # Make sure no base class was non-abstract
non_abstract_bases = [b for b in bases non_abstract_bases = [b for b in bases
@ -1189,14 +1208,17 @@ Invalid data to create a `%s` instance.\n%s""".strip() % (cls._class_name, error
def __repr__(self): def __repr__(self):
try: try:
u = unicode(self).encode('utf-8') u = txt_type(self)
except (UnicodeEncodeError, UnicodeDecodeError): except (UnicodeEncodeError, UnicodeDecodeError):
u = '[Bad Unicode data]' u = '[Bad Unicode data]'
return '<%s: %s>' % (self.__class__.__name__, u) return '<%s: %s>' % (self.__class__.__name__, u)
def __str__(self): def __str__(self):
if hasattr(self, '__unicode__'): if hasattr(self, '__unicode__'):
return unicode(self).encode('utf-8') if PY3:
return self.__unicode__()
else:
return unicode(self).encode('utf-8')
return '%s object' % self.__class__.__name__ return '%s object' % self.__class__.__name__
def __eq__(self, other): def __eq__(self, other):
@ -1338,10 +1360,9 @@ class BaseDict(dict):
if sys.version_info < (2, 5): if sys.version_info < (2, 5):
# Prior to Python 2.5, Exception was an old-style class # Prior to Python 2.5, Exception was an old-style class
import types
def subclass_exception(name, parents, unused): def subclass_exception(name, parents, unused):
import types from types import ClassType
return types.ClassType(name, parents, {}) return ClassType(name, parents, {})
else: else:
def subclass_exception(name, parents, module): def subclass_exception(name, parents, module):
return type(name, parents, {'__module__': module}) return type(name, parents, {'__module__': module})

3
mongoengine/django/shortcuts.py
View File

@ -1,4 +1,3 @@
from django.http import Http404
from mongoengine.queryset import QuerySet from mongoengine.queryset import QuerySet
from mongoengine.base import BaseDocument from mongoengine.base import BaseDocument
from mongoengine.base import ValidationError from mongoengine.base import ValidationError
@ -27,6 +26,7 @@ def get_document_or_404(cls, *args, **kwargs):
try: try:
return queryset.get(*args, **kwargs) return queryset.get(*args, **kwargs)
except (queryset._document.DoesNotExist, ValidationError): except (queryset._document.DoesNotExist, ValidationError):
from django.http import Http404
raise Http404('No %s matches the given query.' % queryset._document._class_name) raise Http404('No %s matches the given query.' % queryset._document._class_name)
def get_list_or_404(cls, *args, **kwargs): def get_list_or_404(cls, *args, **kwargs):
@ -42,5 +42,6 @@ def get_list_or_404(cls, *args, **kwargs):
queryset = _get_queryset(cls) queryset = _get_queryset(cls)
obj_list = list(queryset.filter(*args, **kwargs)) obj_list = list(queryset.filter(*args, **kwargs))
if not obj_list: if not obj_list:
from django.http import Http404
raise Http404('No %s matches the given query.' % queryset._document._class_name) raise Http404('No %s matches the given query.' % queryset._document._class_name)
return obj_list return obj_list

22
mongoengine/django/tests.py
View File

@ -1,10 +1,28 @@
#coding: utf-8 #coding: utf-8
from django.test import TestCase from nose.plugins.skip import SkipTest
from django.conf import settings
from mongoengine.python3_support import PY3
from mongoengine import connect from mongoengine import connect
try:
from django.test import TestCase
from django.conf import settings
except Exception as err:
if PY3:
from unittest import TestCase
# Dummy value so no error
class settings:
MONGO_DATABASE_NAME = 'dummy'
else:
raise err
class MongoTestCase(TestCase): class MongoTestCase(TestCase):
def setUp(self):
if PY3:
raise SkipTest('django does not have Python 3 support')
""" """
TestCase class that clear the collection between the tests TestCase class that clear the collection between the tests
""" """

32
mongoengine/document.py
View File

@ -2,7 +2,7 @@ import pymongo
from bson.dbref import DBRef from bson.dbref import DBRef
from mongoengine import signals from mongoengine import signals, queryset
from base import (DocumentMetaclass, TopLevelDocumentMetaclass, BaseDocument, from base import (DocumentMetaclass, TopLevelDocumentMetaclass, BaseDocument,
BaseDict, BaseList) BaseDict, BaseList)
from queryset import OperationError from queryset import OperationError
@ -23,6 +23,9 @@ class EmbeddedDocument(BaseDocument):
:class:`~mongoengine.EmbeddedDocumentField` field type. :class:`~mongoengine.EmbeddedDocumentField` field type.
""" """
# The __metaclass__ attribute is removed by 2to3 when running with Python3
# my_metaclass is defined so that metaclass can be queried in Python 2 & 3
my_metaclass = DocumentMetaclass
__metaclass__ = DocumentMetaclass __metaclass__ = DocumentMetaclass
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
@ -91,9 +94,12 @@ class Document(BaseDocument):
disabled by either setting types to False on the specific index or disabled by either setting types to False on the specific index or
by setting index_types to False on the meta dictionary for the document. by setting index_types to False on the meta dictionary for the document.
""" """
# The __metaclass__ attribute is removed by 2to3 when running with Python3
# my_metaclass is defined so that metaclass can be queried in Python 2 & 3
my_metaclass = TopLevelDocumentMetaclass
__metaclass__ = TopLevelDocumentMetaclass __metaclass__ = TopLevelDocumentMetaclass
@apply
def pk(): def pk():
"""Primary key alias """Primary key alias
""" """
@ -102,6 +108,7 @@ class Document(BaseDocument):
def fset(self, value): def fset(self, value):
return setattr(self, self._meta['id_field'], value) return setattr(self, self._meta['id_field'], value)
return property(fget, fset) return property(fget, fset)
pk = pk()
@classmethod @classmethod
def _get_db(cls): def _get_db(cls):
@ -244,12 +251,11 @@ class Document(BaseDocument):
def cascade_save(self, *args, **kwargs): def cascade_save(self, *args, **kwargs):
"""Recursively saves any references / generic references on an object""" """Recursively saves any references / generic references on an object"""
from fields import ReferenceField, GenericReferenceField import fields
_refs = kwargs.get('_refs', []) or [] _refs = kwargs.get('_refs', []) or []
for name, cls in self._fields.items(): for name, cls in self._fields.items():
if not isinstance(cls, (fields.ReferenceField, fields.GenericReferenceField)):
if not isinstance(cls, (ReferenceField, GenericReferenceField)):
continue continue
ref = getattr(self, name) ref = getattr(self, name)
@ -304,8 +310,8 @@ class Document(BaseDocument):
.. versionadded:: 0.5 .. versionadded:: 0.5
""" """
from dereference import DeReference import dereference
self._data = DeReference()(self._data, max_depth) self._data = dereference.DeReference()(self._data, max_depth)
return self return self
def reload(self, max_depth=1): def reload(self, max_depth=1):
@ -360,10 +366,9 @@ class Document(BaseDocument):
"""Drops the entire collection associated with this """Drops the entire collection associated with this
:class:`~mongoengine.Document` type from the database. :class:`~mongoengine.Document` type from the database.
""" """
from mongoengine.queryset import QuerySet
db = cls._get_db() db = cls._get_db()
db.drop_collection(cls._get_collection_name()) db.drop_collection(cls._get_collection_name())
QuerySet._reset_already_indexed(cls) queryset.QuerySet._reset_already_indexed(cls)
class DynamicDocument(Document): class DynamicDocument(Document):
@ -379,7 +384,12 @@ class DynamicDocument(Document):
There is one caveat on Dynamic Documents: fields cannot start with `_` There is one caveat on Dynamic Documents: fields cannot start with `_`
""" """
# The __metaclass__ attribute is removed by 2to3 when running with Python3
# my_metaclass is defined so that metaclass can be queried in Python 2 & 3
my_metaclass = TopLevelDocumentMetaclass
__metaclass__ = TopLevelDocumentMetaclass __metaclass__ = TopLevelDocumentMetaclass
_dynamic = True _dynamic = True
def __delattr__(self, *args, **kwargs): def __delattr__(self, *args, **kwargs):
@ -398,7 +408,11 @@ class DynamicEmbeddedDocument(EmbeddedDocument):
information about dynamic documents. information about dynamic documents.
""" """
# The __metaclass__ attribute is removed by 2to3 when running with Python3
# my_metaclass is defined so that metaclass can be queried in Python 2 & 3
my_metaclass = DocumentMetaclass
__metaclass__ = DocumentMetaclass __metaclass__ = DocumentMetaclass
_dynamic = True _dynamic = True
def __delattr__(self, *args, **kwargs): def __delattr__(self, *args, **kwargs):

41
mongoengine/fields.py
View File

@ -1,18 +1,23 @@
import datetime import datetime
import time
import decimal import decimal
import gridfs
import re import re
import sys
import time
import uuid import uuid
import warnings import warnings
from operator import itemgetter
import gridfs
from bson import Binary, DBRef, SON, ObjectId from bson import Binary, DBRef, SON, ObjectId
from mongoengine.python3_support import (PY3, b, bin_type,
txt_type, str_types, StringIO)
from base import (BaseField, ComplexBaseField, ObjectIdField, from base import (BaseField, ComplexBaseField, ObjectIdField,
ValidationError, get_document, BaseDocument) ValidationError, get_document, BaseDocument)
from queryset import DO_NOTHING, QuerySet from queryset import DO_NOTHING, QuerySet
from document import Document, EmbeddedDocument from document import Document, EmbeddedDocument
from connection import get_db, DEFAULT_CONNECTION_NAME from connection import get_db, DEFAULT_CONNECTION_NAME
from operator import itemgetter
try: try:
@ -21,12 +26,6 @@ except ImportError:
Image = None Image = None
ImageOps = None ImageOps = None
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
__all__ = ['StringField', 'IntField', 'FloatField', 'BooleanField', __all__ = ['StringField', 'IntField', 'FloatField', 'BooleanField',
'DateTimeField', 'EmbeddedDocumentField', 'ListField', 'DictField', 'DateTimeField', 'EmbeddedDocumentField', 'ListField', 'DictField',
'ObjectIdField', 'ReferenceField', 'ValidationError', 'MapField', 'ObjectIdField', 'ReferenceField', 'ValidationError', 'MapField',
@ -846,8 +845,9 @@ class BinaryField(BaseField):
return Binary(value) return Binary(value)
def validate(self, value): def validate(self, value):
if not isinstance(value, (basestring, Binary)): if not isinstance(value, (bin_type, txt_type, Binary)):
self.error('BinaryField only accepts string or bson Binary values') self.error("BinaryField only accepts instances of "
"(%s, %s, Binary)" % (bin_type.__name__,txt_type.__name__))
if self.max_bytes is not None and len(value) > self.max_bytes: if self.max_bytes is not None and len(value) > self.max_bytes:
self.error('Binary value is too long') self.error('Binary value is too long')
@ -903,12 +903,14 @@ class GridFSProxy(object):
def __repr__(self): def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self.grid_id) return '<%s: %s>' % (self.__class__.__name__, self.grid_id)
def __cmp__(self, other): def __eq__(self, other):
if not isinstance(other, GridFSProxy): if isinstance(other, GridFSProxy):
return -1 return ((self.grid_id == other.grid_id) and
return cmp((self.grid_id, self.collection_name, self.db_alias), (self.collection_name == other.collection_name) and
(other.grid_id, other.collection_name, other.db_alias)) (self.db_alias == other.db_alias))
else:
return False
@property @property
def fs(self): def fs(self):
if not self._fs: if not self._fs:
@ -1020,7 +1022,8 @@ class FileField(BaseField):
def __set__(self, instance, value): def __set__(self, instance, value):
key = self.name key = self.name
if (hasattr(value, 'read') and not isinstance(value, GridFSProxy)) or isinstance(value, basestring): if ((hasattr(value, 'read') and not
isinstance(value, GridFSProxy)) or isinstance(value, str_types)):
# using "FileField() = file/string" notation # using "FileField() = file/string" notation
grid_file = instance._data.get(self.name) grid_file = instance._data.get(self.name)
# If a file already exists, delete it # If a file already exists, delete it
@ -1211,7 +1214,7 @@ class ImageField(FileField):
for att_name, att in extra_args.items(): for att_name, att in extra_args.items():
if att and (isinstance(att, tuple) or isinstance(att, list)): if att and (isinstance(att, tuple) or isinstance(att, list)):
setattr(self, att_name, dict( setattr(self, att_name, dict(
map(None, params_size, att))) zip(params_size, att)))
else: else:
setattr(self, att_name, None) setattr(self, att_name, None)

29
mongoengine/python3_support.py Normal file
View File

@ -0,0 +1,29 @@
"""Helper functions and types to aid with Python 3 support."""
import sys
PY3 = sys.version_info[0] == 3
if PY3:
import codecs
from io import BytesIO as StringIO
# return s converted to binary. b('test') should be equivalent to b'test'
def b(s):
return codecs.latin_1_encode(s)[0]
bin_type = bytes
txt_type = str
else:
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
# Conversion to binary only necessary in Python 3
def b(s):
return s
bin_type = str
txt_type = unicode
str_types = (bin_type, txt_type)

8
mongoengine/queryset.py
View File

@ -3,7 +3,7 @@ import re
import copy import copy
import itertools import itertools
import operator import operator
import functools
from functools import partial from functools import partial
import pymongo import pymongo
@ -121,12 +121,12 @@ class QueryTreeTransformerVisitor(QNodeVisitor):
# that ANDs the necessary part with the $or part. # that ANDs the necessary part with the $or part.
clauses = [] clauses = []
for or_group in itertools.product(*or_groups): for or_group in itertools.product(*or_groups):
q_object = reduce(lambda a, b: a & b, and_parts, Q()) q_object = functools.reduce(lambda a, b: a & b, and_parts, Q())
q_object = reduce(lambda a, b: a & b, or_group, q_object) q_object = functools.reduce(lambda a, b: a & b, or_group, q_object)
clauses.append(q_object) clauses.append(q_object)
# Finally, $or the generated clauses in to one query. Each of the # Finally, $or the generated clauses in to one query. Each of the
# clauses is sufficient for the query to succeed. # clauses is sufficient for the query to succeed.
return reduce(lambda a, b: a | b, clauses, Q()) return functools.reduce(lambda a, b: a | b, clauses, Q())
if combination.operation == combination.OR: if combination.operation == combination.OR:
children = [] children = []

4
setup.cfg
View File

@ -1,6 +1,3 @@
[aliases]
test = nosetests
[nosetests] [nosetests]
verbosity = 2 verbosity = 2
detailed-errors = 1 detailed-errors = 1
@ -10,4 +7,5 @@ detailed-errors = 1
#cover-html-dir = ../htmlcov #cover-html-dir = ../htmlcov
#cover-package = mongoengine #cover-package = mongoengine
where = tests where = tests
py3where = build
#tests = test_bugfix.py #tests = test_bugfix.py

30
setup.py
View File

@ -1,5 +1,12 @@
from setuptools import setup, find_packages from setuptools import setup, find_packages
import os import os
import sys
# Hack to silence atexit traceback in newer python versions
try:
import multiprocessing
except ImportError:
pass
DESCRIPTION = "A Python Document-Object Mapper for working with MongoDB" DESCRIPTION = "A Python Document-Object Mapper for working with MongoDB"
@ -19,9 +26,10 @@ def get_version(version_tuple):
# import it as it depends on PyMongo and PyMongo isn't installed until this # import it as it depends on PyMongo and PyMongo isn't installed until this
# file is read # file is read
init = os.path.join(os.path.dirname(__file__), 'mongoengine', '__init__.py') init = os.path.join(os.path.dirname(__file__), 'mongoengine', '__init__.py')
version_line = filter(lambda l: l.startswith('VERSION'), open(init))[0] version_line = list(filter(lambda l: l.startswith('VERSION'), open(init)))[0]
VERSION = get_version(eval(version_line.split('=')[-1])) VERSION = get_version(eval(version_line.split('=')[-1]))
print VERSION print(VERSION)
CLASSIFIERS = [ CLASSIFIERS = [
'Development Status :: 4 - Beta', 'Development Status :: 4 - Beta',
@ -29,13 +37,26 @@ CLASSIFIERS = [
'License :: OSI Approved :: MIT License', 'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent', 'Operating System :: OS Independent',
'Programming Language :: Python', 'Programming Language :: Python',
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
'Topic :: Database', 'Topic :: Database',
'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Software Development :: Libraries :: Python Modules',
] ]
extra_opts = {}
if sys.version_info[0] == 3:
extra_opts['use_2to3'] = True
extra_opts['tests_require'] = ['nose', 'coverage', 'blinker']
extra_opts['packages'] = find_packages(exclude=('tests',))
if "test" in sys.argv or "nosetests" in sys.argv:
extra_opts['packages'].append("tests")
extra_opts['package_data'] = {"tests": ["mongoengine.png"]}
else:
extra_opts['tests_require'] = ['nose', 'coverage', 'blinker', 'django>=1.3', 'PIL']
extra_opts['packages'] = find_packages(exclude=('tests',))
setup(name='mongoengine', setup(name='mongoengine',
version=VERSION, version=VERSION,
packages=find_packages(exclude=('tests',)),
author='Harry Marr', author='Harry Marr',
author_email='harry.marr@{nospam}gmail.com', author_email='harry.marr@{nospam}gmail.com',
maintainer="Ross Lawley", maintainer="Ross Lawley",
@ -48,5 +69,6 @@ setup(name='mongoengine',
platforms=['any'], platforms=['any'],
classifiers=CLASSIFIERS, classifiers=CLASSIFIERS,
install_requires=['pymongo'], install_requires=['pymongo'],
tests_require=['nose', 'coverage', 'blinker', 'django>=1.3', 'PIL'] test_suite='nose.collector',
**extra_opts
) )

28
tests/test_dereference.py
View File

@ -109,10 +109,10 @@ class FieldTest(unittest.TestCase):
peter = Employee.objects.with_id(peter.id).select_related() peter = Employee.objects.with_id(peter.id).select_related()
self.assertEqual(q, 2) self.assertEqual(q, 2)
self.assertEquals(peter.boss, bill) self.assertEqual(peter.boss, bill)
self.assertEqual(q, 2) self.assertEqual(q, 2)
self.assertEquals(peter.friends, friends) self.assertEqual(peter.friends, friends)
self.assertEqual(q, 2) self.assertEqual(q, 2)
# Queryset select_related # Queryset select_related
@ -123,10 +123,10 @@ class FieldTest(unittest.TestCase):
self.assertEqual(q, 2) self.assertEqual(q, 2)
for employee in employees: for employee in employees:
self.assertEquals(employee.boss, bill) self.assertEqual(employee.boss, bill)
self.assertEqual(q, 2) self.assertEqual(q, 2)
self.assertEquals(employee.friends, friends) self.assertEqual(employee.friends, friends)
self.assertEqual(q, 2) self.assertEqual(q, 2)
def test_circular_reference(self): def test_circular_reference(self):
@ -160,7 +160,7 @@ class FieldTest(unittest.TestCase):
daughter.relations.append(self_rel) daughter.relations.append(self_rel)
daughter.save() daughter.save()
self.assertEquals("[<Person: Mother>, <Person: Daughter>]", "%s" % Person.objects()) self.assertEqual("[<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
@ -186,7 +186,7 @@ class FieldTest(unittest.TestCase):
daughter.relations.append(daughter) daughter.relations.append(daughter)
daughter.save() daughter.save()
self.assertEquals("[<Person: Mother>, <Person: Daughter>]", "%s" % Person.objects()) self.assertEqual("[<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
@ -228,7 +228,7 @@ class FieldTest(unittest.TestCase):
anna.other.name = "Anna's friends" anna.other.name = "Anna's friends"
anna.save() anna.save()
self.assertEquals( self.assertEqual(
"[<Person: Paul>, <Person: Maria>, <Person: Julia>, <Person: Anna>]", "[<Person: Paul>, <Person: Maria>, <Person: Julia>, <Person: Anna>]",
"%s" % Person.objects() "%s" % Person.objects()
) )
@ -781,8 +781,8 @@ class FieldTest(unittest.TestCase):
root.save() root.save()
root = root.reload() root = root.reload()
self.assertEquals(root.children, [company]) self.assertEqual(root.children, [company])
self.assertEquals(company.parents, [root]) self.assertEqual(company.parents, [root])
def test_dict_in_dbref_instance(self): def test_dict_in_dbref_instance(self):
@ -808,8 +808,8 @@ class FieldTest(unittest.TestCase):
room_101.save() room_101.save()
room = Room.objects.first().select_related() room = Room.objects.first().select_related()
self.assertEquals(room.staffs_with_position[0]['staff'], sarah) self.assertEqual(room.staffs_with_position[0]['staff'], sarah)
self.assertEquals(room.staffs_with_position[1]['staff'], bob) self.assertEqual(room.staffs_with_position[1]['staff'], bob)
def test_document_reload_no_inheritance(self): def test_document_reload_no_inheritance(self):
class Foo(Document): class Foo(Document):
@ -839,8 +839,8 @@ class FieldTest(unittest.TestCase):
foo.save() foo.save()
foo.reload() foo.reload()
self.assertEquals(type(foo.bar), Bar) self.assertEqual(type(foo.bar), Bar)
self.assertEquals(type(foo.baz), Baz) self.assertEqual(type(foo.baz), Baz)
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
@ -862,4 +862,4 @@ class FieldTest(unittest.TestCase):
msg = Message.objects.get(id=1) msg = Message.objects.get(id=1)
self.assertEqual(0, msg.comments[0].id) self.assertEqual(0, msg.comments[0].id)
self.assertEqual(1, msg.comments[1].id) self.assertEqual(1, msg.comments[1].id)

32
tests/test_django.py
View File

@ -1,24 +1,34 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import unittest import unittest
from nose.plugins.skip import SkipTest
from mongoengine.python3_support import PY3
from mongoengine import * from mongoengine import *
from mongoengine.django.shortcuts import get_document_or_404
from django.http import Http404 try:
from django.template import Context, Template from mongoengine.django.shortcuts import get_document_or_404
from django.conf import settings
from django.core.paginator import Paginator
settings.configure() from django.http import Http404
from django.template import Context, Template
from django.conf import settings
from django.core.paginator import Paginator
from django.contrib.sessions.tests import SessionTestsMixin settings.configure()
from mongoengine.django.sessions import SessionStore, MongoSession
from django.contrib.sessions.tests import SessionTestsMixin
from mongoengine.django.sessions import SessionStore, MongoSession
except Exception as err:
if PY3:
SessionTestsMixin = type #dummy value so no error
SessionStore = None #dummy value so no error
else:
raise err
class QuerySetTest(unittest.TestCase): class QuerySetTest(unittest.TestCase):
def setUp(self): def setUp(self):
if PY3:
raise SkipTest('django does not have Python 3 support')
connect(db='mongoenginetest') connect(db='mongoenginetest')
class Person(Document): class Person(Document):
@ -99,6 +109,8 @@ class MongoDBSessionTest(SessionTestsMixin, unittest.TestCase):
backend = SessionStore backend = SessionStore
def setUp(self): def setUp(self):
if PY3:
raise SkipTest('django does not have Python 3 support')
connect(db='mongoenginetest') connect(db='mongoenginetest')
MongoSession.drop_collection() MongoSession.drop_collection()
super(MongoDBSessionTest, self).setUp() super(MongoDBSessionTest, self).setUp()

387
tests/test_document.py
View File

@ -38,7 +38,7 @@ class DocumentTest(unittest.TestCase):
"""Add FutureWarning for future allow_inhertiance default change. """Add FutureWarning for future allow_inhertiance default change.
""" """
with warnings.catch_warnings(True) as errors: with warnings.catch_warnings(record=True) as errors:
class SimpleBase(Document): class SimpleBase(Document):
a = IntField() a = IntField()
@ -47,10 +47,10 @@ class DocumentTest(unittest.TestCase):
b = IntField() b = IntField()
InheritedClass() InheritedClass()
self.assertEquals(len(errors), 1) self.assertEqual(len(errors), 1)
warning = errors[0] warning = errors[0]
self.assertEquals(FutureWarning, warning.category) self.assertEqual(FutureWarning, warning.category)
self.assertTrue("InheritedClass" in warning.message.message) self.assertTrue("InheritedClass" in str(warning.message))
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.
@ -105,16 +105,16 @@ class DocumentTest(unittest.TestCase):
class DefaultNamingTest(Document): class DefaultNamingTest(Document):
pass pass
self.assertEquals('default_naming_test', DefaultNamingTest._get_collection_name()) self.assertEqual('default_naming_test', DefaultNamingTest._get_collection_name())
class CustomNamingTest(Document): class CustomNamingTest(Document):
meta = {'collection': 'pimp_my_collection'} meta = {'collection': 'pimp_my_collection'}
self.assertEquals('pimp_my_collection', CustomNamingTest._get_collection_name()) self.assertEqual('pimp_my_collection', CustomNamingTest._get_collection_name())
class DynamicNamingTest(Document): class DynamicNamingTest(Document):
meta = {'collection': lambda c: "DYNAMO"} meta = {'collection': lambda c: "DYNAMO"}
self.assertEquals('DYNAMO', DynamicNamingTest._get_collection_name()) self.assertEqual('DYNAMO', DynamicNamingTest._get_collection_name())
# Use Abstract class to handle backwards compatibility # Use Abstract class to handle backwards compatibility
class BaseDocument(Document): class BaseDocument(Document):
@ -125,11 +125,11 @@ class DocumentTest(unittest.TestCase):
class OldNamingConvention(BaseDocument): class OldNamingConvention(BaseDocument):
pass pass
self.assertEquals('oldnamingconvention', OldNamingConvention._get_collection_name()) self.assertEqual('oldnamingconvention', OldNamingConvention._get_collection_name())
class InheritedAbstractNamingTest(BaseDocument): class InheritedAbstractNamingTest(BaseDocument):
meta = {'collection': 'wibble'} meta = {'collection': 'wibble'}
self.assertEquals('wibble', InheritedAbstractNamingTest._get_collection_name()) self.assertEqual('wibble', InheritedAbstractNamingTest._get_collection_name())
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered. # Cause all warnings to always be triggered.
@ -142,7 +142,7 @@ class DocumentTest(unittest.TestCase):
meta = {'collection': 'fail'} meta = {'collection': 'fail'}
self.assertTrue(issubclass(w[0].category, SyntaxWarning)) self.assertTrue(issubclass(w[0].category, SyntaxWarning))
self.assertEquals('non_abstract_base', InheritedDocumentFailTest._get_collection_name()) self.assertEqual('non_abstract_base', InheritedDocumentFailTest._get_collection_name())
# Mixin tests # Mixin tests
class BaseMixin(object): class BaseMixin(object):
@ -152,7 +152,7 @@ class DocumentTest(unittest.TestCase):
class OldMixinNamingConvention(Document, BaseMixin): class OldMixinNamingConvention(Document, BaseMixin):
pass pass
self.assertEquals('oldmixinnamingconvention', OldMixinNamingConvention._get_collection_name()) self.assertEqual('oldmixinnamingconvention', OldMixinNamingConvention._get_collection_name())
class BaseMixin(object): class BaseMixin(object):
meta = { meta = {
@ -165,7 +165,7 @@ class DocumentTest(unittest.TestCase):
class MyDocument(BaseDocument): class MyDocument(BaseDocument):
pass pass
self.assertEquals('basedocument', MyDocument._get_collection_name()) self.assertEqual('basedocument', MyDocument._get_collection_name())
def test_get_superclasses(self): def test_get_superclasses(self):
"""Ensure that the correct list of superclasses is assembled. """Ensure that the correct list of superclasses is assembled.
@ -212,10 +212,10 @@ class DocumentTest(unittest.TestCase):
h = Human() h = Human()
h.save() h.save()
self.assertEquals(Human.objects.count(), 1) self.assertEqual(Human.objects.count(), 1)
self.assertEquals(Mammal.objects.count(), 1) self.assertEqual(Mammal.objects.count(), 1)
self.assertEquals(Animal.objects.count(), 1) self.assertEqual(Animal.objects.count(), 1)
self.assertEquals(Base.objects.count(), 1) self.assertEqual(Base.objects.count(), 1)
Base.drop_collection() Base.drop_collection()
def test_polymorphic_queries(self): def test_polymorphic_queries(self):
@ -427,7 +427,7 @@ class DocumentTest(unittest.TestCase):
info = collection.index_information() info = collection.index_information()
info = [value['key'] for key, value in info.iteritems()] info = [value['key'] for key, value in info.iteritems()]
self.assertEquals([[(u'_id', 1)], [(u'_types', 1), (u'name', 1)]], info) self.assertEqual([[(u'_id', 1)], [(u'_types', 1), (u'name', 1)]], info)
# Turn off inheritance # Turn off inheritance
class Animal(Document): class Animal(Document):
@ -445,7 +445,7 @@ class DocumentTest(unittest.TestCase):
info = collection.index_information() info = collection.index_information()
info = [value['key'] for key, value in info.iteritems()] info = [value['key'] for key, value in info.iteritems()]
self.assertEquals([[(u'_id', 1)], [(u'_types', 1), (u'name', 1)]], info) self.assertEqual([[(u'_id', 1)], [(u'_types', 1), (u'name', 1)]], info)
info = collection.index_information() info = collection.index_information()
indexes_to_drop = [key for key, value in info.iteritems() if '_types' in dict(value['key'])] indexes_to_drop = [key for key, value in info.iteritems() if '_types' in dict(value['key'])]
@ -454,14 +454,14 @@ class DocumentTest(unittest.TestCase):
info = collection.index_information() info = collection.index_information()
info = [value['key'] for key, value in info.iteritems()] info = [value['key'] for key, value in info.iteritems()]
self.assertEquals([[(u'_id', 1)]], info) self.assertEqual([[(u'_id', 1)]], info)
# Recreate indexes # Recreate indexes
dog = Animal.objects.first() dog = Animal.objects.first()
dog.save() dog.save()
info = collection.index_information() info = collection.index_information()
info = [value['key'] for key, value in info.iteritems()] info = [value['key'] for key, value in info.iteritems()]
self.assertEquals([[(u'_id', 1)], [(u'name', 1),]], info) self.assertEqual([[(u'_id', 1)], [(u'name', 1),]], info)
Animal.drop_collection() Animal.drop_collection()
@ -681,8 +681,8 @@ class DocumentTest(unittest.TestCase):
Person(name="Fred").save() Person(name="Fred").save()
self.assertEquals(Person.objects.get(name="Jack").rank, "Corporal") self.assertEqual(Person.objects.get(name="Jack").rank, "Corporal")
self.assertEquals(Person.objects.get(name="Fred").rank, "Private") self.assertEqual(Person.objects.get(name="Fred").rank, "Private")
def test_db_embedded_doc_field_load(self): def test_db_embedded_doc_field_load(self):
"""Ensure we load embedded document data correctly """Ensure we load embedded document data correctly
@ -704,8 +704,8 @@ class DocumentTest(unittest.TestCase):
Person(name="Fred").save() Person(name="Fred").save()
self.assertEquals(Person.objects.get(name="Jack").rank, "Corporal") self.assertEqual(Person.objects.get(name="Jack").rank, "Corporal")
self.assertEquals(Person.objects.get(name="Fred").rank, "Private") self.assertEqual(Person.objects.get(name="Fred").rank, "Private")
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]
@ -782,7 +782,7 @@ class DocumentTest(unittest.TestCase):
p = Person(name="test", user_guid='123') p = Person(name="test", user_guid='123')
p.save() p.save()
self.assertEquals(1, Person.objects.count()) self.assertEqual(1, Person.objects.count())
info = Person.objects._collection.index_information() info = Person.objects._collection.index_information()
self.assertEqual(info.keys(), ['_types_1_user_guid_1', '_id_', '_types_1_name_1']) self.assertEqual(info.keys(), ['_types_1_user_guid_1', '_id_', '_types_1_name_1'])
Person.drop_collection() Person.drop_collection()
@ -804,7 +804,7 @@ class DocumentTest(unittest.TestCase):
u = User(user_guid='123') u = User(user_guid='123')
u.save() u.save()
self.assertEquals(1, User.objects.count()) self.assertEqual(1, User.objects.count())
info = User.objects._collection.index_information() info = User.objects._collection.index_information()
self.assertEqual(info.keys(), ['_id_']) self.assertEqual(info.keys(), ['_id_'])
User.drop_collection() User.drop_collection()
@ -890,8 +890,8 @@ class DocumentTest(unittest.TestCase):
self.assertFalse('location_2d' in info) self.assertFalse('location_2d' in info)
self.assertEquals(len(Parent._geo_indices()), 0) self.assertEqual(len(Parent._geo_indices()), 0)
self.assertEquals(len(Location._geo_indices()), 1) self.assertEqual(len(Location._geo_indices()), 1)
def test_covered_index(self): def test_covered_index(self):
"""Ensure that covered indexes can be used """Ensure that covered indexes can be used
@ -938,7 +938,7 @@ class DocumentTest(unittest.TestCase):
BlogPost.drop_collection() BlogPost.drop_collection()
indexes = BlogPost.objects._collection.index_information() indexes = BlogPost.objects._collection.index_information()
self.assertEquals(indexes['categories_1__id_1']['key'], self.assertEqual(indexes['categories_1__id_1']['key'],
[('categories', 1), ('_id', 1)]) [('categories', 1), ('_id', 1)])
def test_hint(self): def test_hint(self):
@ -957,11 +957,11 @@ class DocumentTest(unittest.TestCase):
tags = [("tag %i" % n) for n in xrange(0, i % 2)] tags = [("tag %i" % n) for n in xrange(0, i % 2)]
BlogPost(tags=tags).save() BlogPost(tags=tags).save()
self.assertEquals(BlogPost.objects.count(), 10) self.assertEqual(BlogPost.objects.count(), 10)
self.assertEquals(BlogPost.objects.hint().count(), 10) self.assertEqual(BlogPost.objects.hint().count(), 10)
self.assertEquals(BlogPost.objects.hint([('tags', 1)]).count(), 10) self.assertEqual(BlogPost.objects.hint([('tags', 1)]).count(), 10)
self.assertEquals(BlogPost.objects.hint([('ZZ', 1)]).count(), 10) self.assertEqual(BlogPost.objects.hint([('ZZ', 1)]).count(), 10)
def invalid_index(): def invalid_index():
BlogPost.objects.hint('tags') BlogPost.objects.hint('tags')
@ -1255,32 +1255,32 @@ class DocumentTest(unittest.TestCase):
doc.embedded_field.list_field.append(1) doc.embedded_field.list_field.append(1)
doc.embedded_field.dict_field['woot'] = "woot" doc.embedded_field.dict_field['woot'] = "woot"
self.assertEquals(doc._get_changed_fields(), [ self.assertEqual(doc._get_changed_fields(), [
'list_field', 'dict_field', 'embedded_field.list_field', 'list_field', 'dict_field', 'embedded_field.list_field',
'embedded_field.dict_field']) 'embedded_field.dict_field'])
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(len(doc.list_field), 4) self.assertEqual(len(doc.list_field), 4)
self.assertEquals(len(doc.dict_field), 2) self.assertEqual(len(doc.dict_field), 2)
self.assertEquals(len(doc.embedded_field.list_field), 4) self.assertEqual(len(doc.embedded_field.list_field), 4)
self.assertEquals(len(doc.embedded_field.dict_field), 2) self.assertEqual(len(doc.embedded_field.dict_field), 2)
def test_dictionary_access(self): def test_dictionary_access(self):
"""Ensure that dictionary-style field access works properly. """Ensure that dictionary-style field access works properly.
""" """
person = self.Person(name='Test User', age=30) person = self.Person(name='Test User', age=30)
self.assertEquals(person['name'], 'Test User') self.assertEqual(person['name'], 'Test User')
self.assertRaises(KeyError, person.__getitem__, 'salary') self.assertRaises(KeyError, person.__getitem__, 'salary')
self.assertRaises(KeyError, person.__setitem__, 'salary', 50) self.assertRaises(KeyError, person.__setitem__, 'salary', 50)
person['name'] = 'Another User' person['name'] = 'Another User'
self.assertEquals(person['name'], 'Another User') self.assertEqual(person['name'], 'Another User')
# Length = length(assigned fields + id) # Length = length(assigned fields + id)
self.assertEquals(len(person), 3) self.assertEqual(len(person), 3)
self.assertTrue('age' in person) self.assertTrue('age' in person)
person.age = None person.age = None
@ -1330,7 +1330,7 @@ class DocumentTest(unittest.TestCase):
doc = Doc.objects.first() doc = Doc.objects.first()
doc.validate() doc.validate()
self.assertEquals([None, 'e'], doc._data.keys()) self.assertEqual([None, 'e'], doc._data.keys())
def test_save(self): def test_save(self):
"""Ensure that a document may be saved in the database. """Ensure that a document may be saved in the database.
@ -1373,7 +1373,7 @@ class DocumentTest(unittest.TestCase):
user.save() user.save()
user.reload() user.reload()
self.assertEquals(user.thing.count, 0) self.assertEqual(user.thing.count, 0)
def test_save_max_recursion_not_hit(self): def test_save_max_recursion_not_hit(self):
@ -1414,16 +1414,17 @@ class DocumentTest(unittest.TestCase):
a.save() a.save()
a.bar = a a.bar = a
a.picture = open(TEST_IMAGE_PATH, 'rb') with open(TEST_IMAGE_PATH, 'rb') as test_image:
a.save() a.picture = test_image
a.save()
# Confirm can save and it resets the changed fields without hitting # Confirm can save and it resets the changed fields without hitting
# max recursion error # max recursion error
b = Foo.objects.with_id(a.id) b = Foo.objects.with_id(a.id)
b.name='world' b.name='world'
b.save() b.save()
self.assertEquals(b.picture, b.bar.picture, b.bar.bar.picture) self.assertEqual(b.picture, b.bar.picture, b.bar.bar.picture)
def test_save_cascades(self): def test_save_cascades(self):
@ -1446,7 +1447,7 @@ class DocumentTest(unittest.TestCase):
p.save() p.save()
p1.reload() p1.reload()
self.assertEquals(p1.name, p.parent.name) self.assertEqual(p1.name, p.parent.name)
def test_save_cascade_kwargs(self): def test_save_cascade_kwargs(self):
@ -1469,7 +1470,7 @@ class DocumentTest(unittest.TestCase):
p.save() p.save()
p1.reload() p1.reload()
self.assertEquals(p1.name, p.parent.name) self.assertEqual(p1.name, p.parent.name)
def test_save_cascade_meta(self): def test_save_cascade_meta(self):
@ -1494,11 +1495,11 @@ class DocumentTest(unittest.TestCase):
p.save() p.save()
p1.reload() p1.reload()
self.assertNotEquals(p1.name, p.parent.name) self.assertNotEqual(p1.name, p.parent.name)
p.save(cascade=True) p.save(cascade=True)
p1.reload() p1.reload()
self.assertEquals(p1.name, p.parent.name) self.assertEqual(p1.name, p.parent.name)
def test_save_cascades_generically(self): def test_save_cascades_generically(self):
@ -1520,7 +1521,7 @@ class DocumentTest(unittest.TestCase):
p.save() p.save()
p1.reload() p1.reload()
self.assertEquals(p1.name, p.parent.name) self.assertEqual(p1.name, p.parent.name)
def test_update(self): def test_update(self):
"""Ensure that an existing document is updated instead of be overwritten. """Ensure that an existing document is updated instead of be overwritten.
@ -1535,7 +1536,7 @@ class DocumentTest(unittest.TestCase):
same_person.save() same_person.save()
# Confirm only one object # Confirm only one object
self.assertEquals(self.Person.objects.count(), 1) self.assertEqual(self.Person.objects.count(), 1)
# reload # reload
person.reload() person.reload()
@ -1621,7 +1622,7 @@ class DocumentTest(unittest.TestCase):
author.reload() author.reload()
p1 = self.Person.objects.first() p1 = self.Person.objects.first()
self.assertEquals(p1.name, author.name) self.assertEqual(p1.name, author.name)
def update_no_value_raises(): def update_no_value_raises():
person = self.Person.objects.first() person = self.Person.objects.first()
@ -1714,8 +1715,8 @@ class DocumentTest(unittest.TestCase):
p = Person.objects[0].select_related() p = Person.objects[0].select_related()
o = Organization.objects.first() o = Organization.objects.first()
self.assertEquals(p.owns[0], o) self.assertEqual(p.owns[0], o)
self.assertEquals(o.owner, p) self.assertEqual(o.owner, p)
def test_circular_reference_deltas_2(self): def test_circular_reference_deltas_2(self):
@ -1755,9 +1756,9 @@ class DocumentTest(unittest.TestCase):
e = Person.objects.get(name="employee") e = Person.objects.get(name="employee")
o = Organization.objects.first() o = Organization.objects.first()
self.assertEquals(p.owns[0], o) self.assertEqual(p.owns[0], o)
self.assertEquals(o.owner, p) self.assertEqual(o.owner, p)
self.assertEquals(e.employer, o) self.assertEqual(e.employer, o)
def test_delta(self): def test_delta(self):
@ -1772,40 +1773,40 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(doc._delta(), ({}, {})) self.assertEqual(doc._delta(), ({}, {}))
doc.string_field = 'hello' doc.string_field = 'hello'
self.assertEquals(doc._get_changed_fields(), ['string_field']) self.assertEqual(doc._get_changed_fields(), ['string_field'])
self.assertEquals(doc._delta(), ({'string_field': 'hello'}, {})) self.assertEqual(doc._delta(), ({'string_field': 'hello'}, {}))
doc._changed_fields = [] doc._changed_fields = []
doc.int_field = 1 doc.int_field = 1
self.assertEquals(doc._get_changed_fields(), ['int_field']) self.assertEqual(doc._get_changed_fields(), ['int_field'])
self.assertEquals(doc._delta(), ({'int_field': 1}, {})) self.assertEqual(doc._delta(), ({'int_field': 1}, {}))
doc._changed_fields = [] doc._changed_fields = []
dict_value = {'hello': 'world', 'ping': 'pong'} dict_value = {'hello': 'world', 'ping': 'pong'}
doc.dict_field = dict_value doc.dict_field = dict_value
self.assertEquals(doc._get_changed_fields(), ['dict_field']) self.assertEqual(doc._get_changed_fields(), ['dict_field'])
self.assertEquals(doc._delta(), ({'dict_field': dict_value}, {})) self.assertEqual(doc._delta(), ({'dict_field': dict_value}, {}))
doc._changed_fields = [] doc._changed_fields = []
list_value = ['1', 2, {'hello': 'world'}] list_value = ['1', 2, {'hello': 'world'}]
doc.list_field = list_value doc.list_field = list_value
self.assertEquals(doc._get_changed_fields(), ['list_field']) self.assertEqual(doc._get_changed_fields(), ['list_field'])
self.assertEquals(doc._delta(), ({'list_field': list_value}, {})) self.assertEqual(doc._delta(), ({'list_field': list_value}, {}))
# Test unsetting # Test unsetting
doc._changed_fields = [] doc._changed_fields = []
doc.dict_field = {} doc.dict_field = {}
self.assertEquals(doc._get_changed_fields(), ['dict_field']) self.assertEqual(doc._get_changed_fields(), ['dict_field'])
self.assertEquals(doc._delta(), ({}, {'dict_field': 1})) self.assertEqual(doc._delta(), ({}, {'dict_field': 1}))
doc._changed_fields = [] doc._changed_fields = []
doc.list_field = [] doc.list_field = []
self.assertEquals(doc._get_changed_fields(), ['list_field']) self.assertEqual(doc._get_changed_fields(), ['list_field'])
self.assertEquals(doc._delta(), ({}, {'list_field': 1})) self.assertEqual(doc._delta(), ({}, {'list_field': 1}))
def test_delta_recursive(self): def test_delta_recursive(self):
@ -1827,8 +1828,8 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(doc._delta(), ({}, {})) self.assertEqual(doc._delta(), ({}, {}))
embedded_1 = Embedded() embedded_1 = Embedded()
embedded_1.string_field = 'hello' embedded_1.string_field = 'hello'
@ -1837,7 +1838,7 @@ class DocumentTest(unittest.TestCase):
embedded_1.list_field = ['1', 2, {'hello': 'world'}] embedded_1.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field = embedded_1 doc.embedded_field = embedded_1
self.assertEquals(doc._get_changed_fields(), ['embedded_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field'])
embedded_delta = { embedded_delta = {
'string_field': 'hello', 'string_field': 'hello',
@ -1845,31 +1846,31 @@ class DocumentTest(unittest.TestCase):
'dict_field': {'hello': 'world'}, 'dict_field': {'hello': 'world'},
'list_field': ['1', 2, {'hello': 'world'}] 'list_field': ['1', 2, {'hello': 'world'}]
} }
self.assertEquals(doc.embedded_field._delta(), (embedded_delta, {})) self.assertEqual(doc.embedded_field._delta(), (embedded_delta, {}))
embedded_delta.update({ embedded_delta.update({
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
}) })
self.assertEquals(doc._delta(), ({'embedded_field': embedded_delta}, {})) self.assertEqual(doc._delta(), ({'embedded_field': embedded_delta}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
doc.embedded_field.dict_field = {} doc.embedded_field.dict_field = {}
self.assertEquals(doc._get_changed_fields(), ['embedded_field.dict_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.dict_field'])
self.assertEquals(doc.embedded_field._delta(), ({}, {'dict_field': 1})) self.assertEqual(doc.embedded_field._delta(), ({}, {'dict_field': 1}))
self.assertEquals(doc._delta(), ({}, {'embedded_field.dict_field': 1})) self.assertEqual(doc._delta(), ({}, {'embedded_field.dict_field': 1}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.dict_field, {}) self.assertEqual(doc.embedded_field.dict_field, {})
doc.embedded_field.list_field = [] doc.embedded_field.list_field = []
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field'])
self.assertEquals(doc.embedded_field._delta(), ({}, {'list_field': 1})) self.assertEqual(doc.embedded_field._delta(), ({}, {'list_field': 1}))
self.assertEquals(doc._delta(), ({}, {'embedded_field.list_field': 1})) self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field': 1}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field, []) self.assertEqual(doc.embedded_field.list_field, [])
embedded_2 = Embedded() embedded_2 = Embedded()
embedded_2.string_field = 'hello' embedded_2.string_field = 'hello'
@ -1878,8 +1879,8 @@ class DocumentTest(unittest.TestCase):
embedded_2.list_field = ['1', 2, {'hello': 'world'}] embedded_2.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field.list_field = ['1', 2, embedded_2] doc.embedded_field.list_field = ['1', 2, embedded_2]
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field'])
self.assertEquals(doc.embedded_field._delta(), ({ self.assertEqual(doc.embedded_field._delta(), ({
'list_field': ['1', 2, { 'list_field': ['1', 2, {
'_cls': 'Embedded', '_cls': 'Embedded',
'_types': ['Embedded'], '_types': ['Embedded'],
@ -1890,7 +1891,7 @@ class DocumentTest(unittest.TestCase):
}] }]
}, {})) }, {}))
self.assertEquals(doc._delta(), ({ self.assertEqual(doc._delta(), ({
'embedded_field.list_field': ['1', 2, { 'embedded_field.list_field': ['1', 2, {
'_cls': 'Embedded', '_cls': 'Embedded',
'_types': ['Embedded'], '_types': ['Embedded'],
@ -1903,24 +1904,24 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[0], '1') self.assertEqual(doc.embedded_field.list_field[0], '1')
self.assertEquals(doc.embedded_field.list_field[1], 2) self.assertEqual(doc.embedded_field.list_field[1], 2)
for k in doc.embedded_field.list_field[2]._fields: for k in doc.embedded_field.list_field[2]._fields:
self.assertEquals(doc.embedded_field.list_field[2][k], embedded_2[k]) self.assertEqual(doc.embedded_field.list_field[2][k], embedded_2[k])
doc.embedded_field.list_field[2].string_field = 'world' doc.embedded_field.list_field[2].string_field = 'world'
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field.2.string_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field.2.string_field'])
self.assertEquals(doc.embedded_field._delta(), ({'list_field.2.string_field': 'world'}, {})) self.assertEqual(doc.embedded_field._delta(), ({'list_field.2.string_field': 'world'}, {}))
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.string_field': 'world'}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.string_field': 'world'}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].string_field, 'world') self.assertEqual(doc.embedded_field.list_field[2].string_field, 'world')
# Test multiple assignments # Test multiple assignments
doc.embedded_field.list_field[2].string_field = 'hello world' doc.embedded_field.list_field[2].string_field = 'hello world'
doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2] doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2]
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field'])
self.assertEquals(doc.embedded_field._delta(), ({ self.assertEqual(doc.embedded_field._delta(), ({
'list_field': ['1', 2, { 'list_field': ['1', 2, {
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
@ -1928,7 +1929,7 @@ class DocumentTest(unittest.TestCase):
'int_field': 1, 'int_field': 1,
'list_field': ['1', 2, {'hello': 'world'}], 'list_field': ['1', 2, {'hello': 'world'}],
'dict_field': {'hello': 'world'}}]}, {})) 'dict_field': {'hello': 'world'}}]}, {}))
self.assertEquals(doc._delta(), ({ self.assertEqual(doc._delta(), ({
'embedded_field.list_field': ['1', 2, { 'embedded_field.list_field': ['1', 2, {
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
@ -1939,32 +1940,32 @@ class DocumentTest(unittest.TestCase):
]}, {})) ]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].string_field, 'hello world') self.assertEqual(doc.embedded_field.list_field[2].string_field, 'hello world')
# Test list native methods # Test list native methods
doc.embedded_field.list_field[2].list_field.pop(0) doc.embedded_field.list_field[2].list_field.pop(0)
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}]}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
doc.embedded_field.list_field[2].list_field.append(1) doc.embedded_field.list_field[2].list_field.append(1)
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}, 1]}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}, 1]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].list_field, [2, {'hello': 'world'}, 1]) self.assertEqual(doc.embedded_field.list_field[2].list_field, [2, {'hello': 'world'}, 1])
doc.embedded_field.list_field[2].list_field.sort() doc.embedded_field.list_field[2].list_field.sort(key=str)
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].list_field, [1, 2, {'hello': 'world'}]) self.assertEqual(doc.embedded_field.list_field[2].list_field, [1, 2, {'hello': 'world'}])
del(doc.embedded_field.list_field[2].list_field[2]['hello']) del(doc.embedded_field.list_field[2].list_field[2]['hello'])
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.list_field': [1, 2, {}]}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.list_field': [1, 2, {}]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
del(doc.embedded_field.list_field[2].list_field) del(doc.embedded_field.list_field[2].list_field)
self.assertEquals(doc._delta(), ({}, {'embedded_field.list_field.2.list_field': 1})) self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field.2.list_field': 1}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
@ -1974,8 +1975,8 @@ class DocumentTest(unittest.TestCase):
doc = doc.reload(10) doc = doc.reload(10)
doc.dict_field['Embedded'].string_field = 'Hello World' doc.dict_field['Embedded'].string_field = 'Hello World'
self.assertEquals(doc._get_changed_fields(), ['dict_field.Embedded.string_field']) self.assertEqual(doc._get_changed_fields(), ['dict_field.Embedded.string_field'])
self.assertEquals(doc._delta(), ({'dict_field.Embedded.string_field': 'Hello World'}, {})) self.assertEqual(doc._delta(), ({'dict_field.Embedded.string_field': 'Hello World'}, {}))
def test_delta_db_field(self): def test_delta_db_field(self):
@ -1991,40 +1992,40 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(doc._delta(), ({}, {})) self.assertEqual(doc._delta(), ({}, {}))
doc.string_field = 'hello' doc.string_field = 'hello'
self.assertEquals(doc._get_changed_fields(), ['db_string_field']) self.assertEqual(doc._get_changed_fields(), ['db_string_field'])
self.assertEquals(doc._delta(), ({'db_string_field': 'hello'}, {})) self.assertEqual(doc._delta(), ({'db_string_field': 'hello'}, {}))
doc._changed_fields = [] doc._changed_fields = []
doc.int_field = 1 doc.int_field = 1
self.assertEquals(doc._get_changed_fields(), ['db_int_field']) self.assertEqual(doc._get_changed_fields(), ['db_int_field'])
self.assertEquals(doc._delta(), ({'db_int_field': 1}, {})) self.assertEqual(doc._delta(), ({'db_int_field': 1}, {}))
doc._changed_fields = [] doc._changed_fields = []
dict_value = {'hello': 'world', 'ping': 'pong'} dict_value = {'hello': 'world', 'ping': 'pong'}
doc.dict_field = dict_value doc.dict_field = dict_value
self.assertEquals(doc._get_changed_fields(), ['db_dict_field']) self.assertEqual(doc._get_changed_fields(), ['db_dict_field'])
self.assertEquals(doc._delta(), ({'db_dict_field': dict_value}, {})) self.assertEqual(doc._delta(), ({'db_dict_field': dict_value}, {}))
doc._changed_fields = [] doc._changed_fields = []
list_value = ['1', 2, {'hello': 'world'}] list_value = ['1', 2, {'hello': 'world'}]
doc.list_field = list_value doc.list_field = list_value
self.assertEquals(doc._get_changed_fields(), ['db_list_field']) self.assertEqual(doc._get_changed_fields(), ['db_list_field'])
self.assertEquals(doc._delta(), ({'db_list_field': list_value}, {})) self.assertEqual(doc._delta(), ({'db_list_field': list_value}, {}))
# Test unsetting # Test unsetting
doc._changed_fields = [] doc._changed_fields = []
doc.dict_field = {} doc.dict_field = {}
self.assertEquals(doc._get_changed_fields(), ['db_dict_field']) self.assertEqual(doc._get_changed_fields(), ['db_dict_field'])
self.assertEquals(doc._delta(), ({}, {'db_dict_field': 1})) self.assertEqual(doc._delta(), ({}, {'db_dict_field': 1}))
doc._changed_fields = [] doc._changed_fields = []
doc.list_field = [] doc.list_field = []
self.assertEquals(doc._get_changed_fields(), ['db_list_field']) self.assertEqual(doc._get_changed_fields(), ['db_list_field'])
self.assertEquals(doc._delta(), ({}, {'db_list_field': 1})) self.assertEqual(doc._delta(), ({}, {'db_list_field': 1}))
# Test it saves that data # Test it saves that data
doc = Doc() doc = Doc()
@ -2037,10 +2038,10 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.string_field, 'hello') self.assertEqual(doc.string_field, 'hello')
self.assertEquals(doc.int_field, 1) self.assertEqual(doc.int_field, 1)
self.assertEquals(doc.dict_field, {'hello': 'world'}) self.assertEqual(doc.dict_field, {'hello': 'world'})
self.assertEquals(doc.list_field, ['1', 2, {'hello': 'world'}]) self.assertEqual(doc.list_field, ['1', 2, {'hello': 'world'}])
def test_delta_recursive_db_field(self): def test_delta_recursive_db_field(self):
@ -2062,8 +2063,8 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(doc._delta(), ({}, {})) self.assertEqual(doc._delta(), ({}, {}))
embedded_1 = Embedded() embedded_1 = Embedded()
embedded_1.string_field = 'hello' embedded_1.string_field = 'hello'
@ -2072,7 +2073,7 @@ class DocumentTest(unittest.TestCase):
embedded_1.list_field = ['1', 2, {'hello': 'world'}] embedded_1.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field = embedded_1 doc.embedded_field = embedded_1
self.assertEquals(doc._get_changed_fields(), ['db_embedded_field']) self.assertEqual(doc._get_changed_fields(), ['db_embedded_field'])
embedded_delta = { embedded_delta = {
'db_string_field': 'hello', 'db_string_field': 'hello',
@ -2080,31 +2081,31 @@ class DocumentTest(unittest.TestCase):
'db_dict_field': {'hello': 'world'}, 'db_dict_field': {'hello': 'world'},
'db_list_field': ['1', 2, {'hello': 'world'}] 'db_list_field': ['1', 2, {'hello': 'world'}]
} }
self.assertEquals(doc.embedded_field._delta(), (embedded_delta, {})) self.assertEqual(doc.embedded_field._delta(), (embedded_delta, {}))
embedded_delta.update({ embedded_delta.update({
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
}) })
self.assertEquals(doc._delta(), ({'db_embedded_field': embedded_delta}, {})) self.assertEqual(doc._delta(), ({'db_embedded_field': embedded_delta}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
doc.embedded_field.dict_field = {} doc.embedded_field.dict_field = {}
self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_dict_field']) self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_dict_field'])
self.assertEquals(doc.embedded_field._delta(), ({}, {'db_dict_field': 1})) self.assertEqual(doc.embedded_field._delta(), ({}, {'db_dict_field': 1}))
self.assertEquals(doc._delta(), ({}, {'db_embedded_field.db_dict_field': 1})) self.assertEqual(doc._delta(), ({}, {'db_embedded_field.db_dict_field': 1}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.dict_field, {}) self.assertEqual(doc.embedded_field.dict_field, {})
doc.embedded_field.list_field = [] doc.embedded_field.list_field = []
self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field'])
self.assertEquals(doc.embedded_field._delta(), ({}, {'db_list_field': 1})) self.assertEqual(doc.embedded_field._delta(), ({}, {'db_list_field': 1}))
self.assertEquals(doc._delta(), ({}, {'db_embedded_field.db_list_field': 1})) self.assertEqual(doc._delta(), ({}, {'db_embedded_field.db_list_field': 1}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field, []) self.assertEqual(doc.embedded_field.list_field, [])
embedded_2 = Embedded() embedded_2 = Embedded()
embedded_2.string_field = 'hello' embedded_2.string_field = 'hello'
@ -2113,8 +2114,8 @@ class DocumentTest(unittest.TestCase):
embedded_2.list_field = ['1', 2, {'hello': 'world'}] embedded_2.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field.list_field = ['1', 2, embedded_2] doc.embedded_field.list_field = ['1', 2, embedded_2]
self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field'])
self.assertEquals(doc.embedded_field._delta(), ({ self.assertEqual(doc.embedded_field._delta(), ({
'db_list_field': ['1', 2, { 'db_list_field': ['1', 2, {
'_cls': 'Embedded', '_cls': 'Embedded',
'_types': ['Embedded'], '_types': ['Embedded'],
@ -2125,7 +2126,7 @@ class DocumentTest(unittest.TestCase):
}] }]
}, {})) }, {}))
self.assertEquals(doc._delta(), ({ self.assertEqual(doc._delta(), ({
'db_embedded_field.db_list_field': ['1', 2, { 'db_embedded_field.db_list_field': ['1', 2, {
'_cls': 'Embedded', '_cls': 'Embedded',
'_types': ['Embedded'], '_types': ['Embedded'],
@ -2138,24 +2139,24 @@ class DocumentTest(unittest.TestCase):
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[0], '1') self.assertEqual(doc.embedded_field.list_field[0], '1')
self.assertEquals(doc.embedded_field.list_field[1], 2) self.assertEqual(doc.embedded_field.list_field[1], 2)
for k in doc.embedded_field.list_field[2]._fields: for k in doc.embedded_field.list_field[2]._fields:
self.assertEquals(doc.embedded_field.list_field[2][k], embedded_2[k]) self.assertEqual(doc.embedded_field.list_field[2][k], embedded_2[k])
doc.embedded_field.list_field[2].string_field = 'world' doc.embedded_field.list_field[2].string_field = 'world'
self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_list_field.2.db_string_field']) self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field.2.db_string_field'])
self.assertEquals(doc.embedded_field._delta(), ({'db_list_field.2.db_string_field': 'world'}, {})) self.assertEqual(doc.embedded_field._delta(), ({'db_list_field.2.db_string_field': 'world'}, {}))
self.assertEquals(doc._delta(), ({'db_embedded_field.db_list_field.2.db_string_field': 'world'}, {})) self.assertEqual(doc._delta(), ({'db_embedded_field.db_list_field.2.db_string_field': 'world'}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].string_field, 'world') self.assertEqual(doc.embedded_field.list_field[2].string_field, 'world')
# Test multiple assignments # Test multiple assignments
doc.embedded_field.list_field[2].string_field = 'hello world' doc.embedded_field.list_field[2].string_field = 'hello world'
doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2] doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2]
self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field'])
self.assertEquals(doc.embedded_field._delta(), ({ self.assertEqual(doc.embedded_field._delta(), ({
'db_list_field': ['1', 2, { 'db_list_field': ['1', 2, {
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
@ -2163,7 +2164,7 @@ class DocumentTest(unittest.TestCase):
'db_int_field': 1, 'db_int_field': 1,
'db_list_field': ['1', 2, {'hello': 'world'}], 'db_list_field': ['1', 2, {'hello': 'world'}],
'db_dict_field': {'hello': 'world'}}]}, {})) 'db_dict_field': {'hello': 'world'}}]}, {}))
self.assertEquals(doc._delta(), ({ self.assertEqual(doc._delta(), ({
'db_embedded_field.db_list_field': ['1', 2, { 'db_embedded_field.db_list_field': ['1', 2, {
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
@ -2174,32 +2175,32 @@ class DocumentTest(unittest.TestCase):
]}, {})) ]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].string_field, 'hello world') self.assertEqual(doc.embedded_field.list_field[2].string_field, 'hello world')
# Test list native methods # Test list native methods
doc.embedded_field.list_field[2].list_field.pop(0) doc.embedded_field.list_field[2].list_field.pop(0)
self.assertEquals(doc._delta(), ({'db_embedded_field.db_list_field.2.db_list_field': [2, {'hello': 'world'}]}, {})) self.assertEqual(doc._delta(), ({'db_embedded_field.db_list_field.2.db_list_field': [2, {'hello': 'world'}]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
doc.embedded_field.list_field[2].list_field.append(1) doc.embedded_field.list_field[2].list_field.append(1)
self.assertEquals(doc._delta(), ({'db_embedded_field.db_list_field.2.db_list_field': [2, {'hello': 'world'}, 1]}, {})) self.assertEqual(doc._delta(), ({'db_embedded_field.db_list_field.2.db_list_field': [2, {'hello': 'world'}, 1]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].list_field, [2, {'hello': 'world'}, 1]) self.assertEqual(doc.embedded_field.list_field[2].list_field, [2, {'hello': 'world'}, 1])
doc.embedded_field.list_field[2].list_field.sort() doc.embedded_field.list_field[2].list_field.sort(key=str)
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
self.assertEquals(doc.embedded_field.list_field[2].list_field, [1, 2, {'hello': 'world'}]) self.assertEqual(doc.embedded_field.list_field[2].list_field, [1, 2, {'hello': 'world'}])
del(doc.embedded_field.list_field[2].list_field[2]['hello']) del(doc.embedded_field.list_field[2].list_field[2]['hello'])
self.assertEquals(doc._delta(), ({'db_embedded_field.db_list_field.2.db_list_field': [1, 2, {}]}, {})) self.assertEqual(doc._delta(), ({'db_embedded_field.db_list_field.2.db_list_field': [1, 2, {}]}, {}))
doc.save() doc.save()
doc = doc.reload(10) doc = doc.reload(10)
del(doc.embedded_field.list_field[2].list_field) del(doc.embedded_field.list_field[2].list_field)
self.assertEquals(doc._delta(), ({}, {'db_embedded_field.db_list_field.2.db_list_field': 1})) self.assertEqual(doc._delta(), ({}, {'db_embedded_field.db_list_field.2.db_list_field': 1}))
def test_save_only_changed_fields(self): def test_save_only_changed_fields(self):
"""Ensure save only sets / unsets changed fields """Ensure save only sets / unsets changed fields
@ -2227,9 +2228,9 @@ class DocumentTest(unittest.TestCase):
same_person.save() same_person.save()
person = self.Person.objects.get() person = self.Person.objects.get()
self.assertEquals(person.name, 'User') self.assertEqual(person.name, 'User')
self.assertEquals(person.age, 21) self.assertEqual(person.age, 21)
self.assertEquals(person.active, False) self.assertEqual(person.active, False)
def test_save_only_changed_fields_recursive(self): def test_save_only_changed_fields_recursive(self):
"""Ensure save only sets / unsets changed fields """Ensure save only sets / unsets changed fields
@ -2485,16 +2486,16 @@ class DocumentTest(unittest.TestCase):
p = Person(name="Rozza") p = Person(name="Rozza")
p.save() p.save()
self.assertEquals(p._fields.keys(), ['name', 'id']) self.assertEqual(p._fields.keys(), ['name', 'id'])
collection = self.db[Person._get_collection_name()] collection = self.db[Person._get_collection_name()]
obj = collection.find_one() obj = collection.find_one()
self.assertEquals(obj['_cls'], 'Person') self.assertEqual(obj['_cls'], 'Person')
self.assertEquals(obj['_types'], ['Person']) self.assertEqual(obj['_types'], ['Person'])
self.assertEquals(Person.objects.count(), 1) self.assertEqual(Person.objects.count(), 1)
rozza = Person.objects.get(name="Rozza") rozza = Person.objects.get(name="Rozza")
Person.drop_collection() Person.drop_collection()
@ -2518,10 +2519,10 @@ class DocumentTest(unittest.TestCase):
t = TestDoc.objects.first() t = TestDoc.objects.first()
self.assertEquals(t.age, 19) self.assertEqual(t.age, 19)
self.assertEquals(t.comment, "great!") self.assertEqual(t.comment, "great!")
self.assertEquals(t.data, "test") self.assertEqual(t.data, "test")
self.assertEquals(t.count, 12) self.assertEqual(t.count, 12)
def test_save_reference(self): def test_save_reference(self):
"""Ensure that a document reference field may be saved in the database. """Ensure that a document reference field may be saved in the database.
@ -2802,8 +2803,8 @@ class DocumentTest(unittest.TestCase):
A().save() A().save()
B(foo=True).save() B(foo=True).save()
self.assertEquals(A.objects.count(), 2) self.assertEqual(A.objects.count(), 2)
self.assertEquals(B.objects.count(), 1) self.assertEqual(B.objects.count(), 1)
A.drop_collection() A.drop_collection()
B.drop_collection() B.drop_collection()
@ -2864,13 +2865,13 @@ class DocumentTest(unittest.TestCase):
pickled_doc = pickle.dumps(pickle_doc) pickled_doc = pickle.dumps(pickle_doc)
resurrected = pickle.loads(pickled_doc) resurrected = pickle.loads(pickled_doc)
self.assertEquals(resurrected, pickle_doc) self.assertEqual(resurrected, pickle_doc)
resurrected.string = "Two" resurrected.string = "Two"
resurrected.save() resurrected.save()
pickle_doc = pickle_doc.reload() pickle_doc = pickle_doc.reload()
self.assertEquals(resurrected, pickle_doc) self.assertEqual(resurrected, pickle_doc)
def test_throw_invalid_document_error(self): def test_throw_invalid_document_error(self):
@ -2893,7 +2894,7 @@ class DocumentTest(unittest.TestCase):
a = A() a = A()
a.save() a.save()
a.reload() a.reload()
self.assertEquals(a.b.field1, 'field1') self.assertEqual(a.b.field1, 'field1')
class C(EmbeddedDocument): class C(EmbeddedDocument):
c_field = StringField(default='cfield') c_field = StringField(default='cfield')
@ -2910,7 +2911,7 @@ class DocumentTest(unittest.TestCase):
a.save() a.save()
a.reload() a.reload()
self.assertEquals(a.b.field2.c_field, 'new value') self.assertEqual(a.b.field2.c_field, 'new value')
def test_can_save_false_values(self): def test_can_save_false_values(self):
"""Ensures you can save False values on save""" """Ensures you can save False values on save"""
@ -2924,7 +2925,7 @@ class DocumentTest(unittest.TestCase):
d.archived = False d.archived = False
d.save() d.save()
self.assertEquals(Doc.objects(archived=False).count(), 1) self.assertEqual(Doc.objects(archived=False).count(), 1)
def test_can_save_false_values_dynamic(self): def test_can_save_false_values_dynamic(self):
@ -2938,7 +2939,7 @@ class DocumentTest(unittest.TestCase):
d.archived = False d.archived = False
d.save() d.save()
self.assertEquals(Doc.objects(archived=False).count(), 1) self.assertEqual(Doc.objects(archived=False).count(), 1)
def test_do_not_save_unchanged_references(self): def test_do_not_save_unchanged_references(self):
"""Ensures cascading saves dont auto update""" """Ensures cascading saves dont auto update"""
@ -3037,7 +3038,7 @@ class DocumentTest(unittest.TestCase):
class B(A): class B(A):
pass pass
self.assertEquals('testdb-1', B._meta.get('db_alias')) self.assertEqual('testdb-1', B._meta.get('db_alias'))
def test_db_ref_usage(self): def test_db_ref_usage(self):
""" DB Ref usage in __raw__ queries """ """ DB Ref usage in __raw__ queries """
@ -3118,12 +3119,12 @@ class ValidatorErrorTest(unittest.TestCase):
"""Ensure a ValidationError handles error to_dict correctly. """Ensure a ValidationError handles error to_dict correctly.
""" """
error = ValidationError('root') error = ValidationError('root')
self.assertEquals(error.to_dict(), {}) self.assertEqual(error.to_dict(), {})
# 1st level error schema # 1st level error schema
error.errors = {'1st': ValidationError('bad 1st'), } error.errors = {'1st': ValidationError('bad 1st'), }
self.assertTrue('1st' in error.to_dict()) self.assertTrue('1st' in error.to_dict())
self.assertEquals(error.to_dict()['1st'], 'bad 1st') self.assertEqual(error.to_dict()['1st'], 'bad 1st')
# 2nd level error schema # 2nd level error schema
error.errors = {'1st': ValidationError('bad 1st', errors={ error.errors = {'1st': ValidationError('bad 1st', errors={
@ -3132,7 +3133,7 @@ class ValidatorErrorTest(unittest.TestCase):
self.assertTrue('1st' in error.to_dict()) self.assertTrue('1st' in error.to_dict())
self.assertTrue(isinstance(error.to_dict()['1st'], dict)) self.assertTrue(isinstance(error.to_dict()['1st'], dict))
self.assertTrue('2nd' in error.to_dict()['1st']) self.assertTrue('2nd' in error.to_dict()['1st'])
self.assertEquals(error.to_dict()['1st']['2nd'], 'bad 2nd') self.assertEqual(error.to_dict()['1st']['2nd'], 'bad 2nd')
# moar levels # moar levels
error.errors = {'1st': ValidationError('bad 1st', errors={ error.errors = {'1st': ValidationError('bad 1st', errors={
@ -3146,10 +3147,10 @@ class ValidatorErrorTest(unittest.TestCase):
self.assertTrue('2nd' in error.to_dict()['1st']) self.assertTrue('2nd' in error.to_dict()['1st'])
self.assertTrue('3rd' in error.to_dict()['1st']['2nd']) self.assertTrue('3rd' in error.to_dict()['1st']['2nd'])
self.assertTrue('4th' in error.to_dict()['1st']['2nd']['3rd']) self.assertTrue('4th' in error.to_dict()['1st']['2nd']['3rd'])
self.assertEquals(error.to_dict()['1st']['2nd']['3rd']['4th'], self.assertEqual(error.to_dict()['1st']['2nd']['3rd']['4th'],
'Inception') 'Inception')
self.assertEquals(error.message, "root(2nd.3rd.4th.Inception: ['1st'])") self.assertEqual(error.message, "root(2nd.3rd.4th.Inception: ['1st'])")
def test_model_validation(self): def test_model_validation(self):
@ -3161,8 +3162,8 @@ class ValidatorErrorTest(unittest.TestCase):
User().validate() User().validate()
except ValidationError, e: except ValidationError, e:
expected_error_message = """ValidationError(Field is required: ['username', 'name'])""" expected_error_message = """ValidationError(Field is required: ['username', 'name'])"""
self.assertEquals(e.message, expected_error_message) self.assertEqual(e.message, expected_error_message)
self.assertEquals(e.to_dict(), { self.assertEqual(e.to_dict(), {
'username': 'Field is required', 'username': 'Field is required',
'name': 'Field is required'}) 'name': 'Field is required'})

178
tests/test_dynamic_document.py
View File

@ -25,14 +25,14 @@ class DynamicDocTest(unittest.TestCase):
p.name = "James" p.name = "James"
p.age = 34 p.age = 34
self.assertEquals(p.to_mongo(), self.assertEqual(p.to_mongo(),
{"_types": ["Person"], "_cls": "Person", {"_types": ["Person"], "_cls": "Person",
"name": "James", "age": 34} "name": "James", "age": 34}
) )
p.save() p.save()
self.assertEquals(self.Person.objects.first().age, 34) self.assertEqual(self.Person.objects.first().age, 34)
# Confirm no changes to self.Person # Confirm no changes to self.Person
self.assertFalse(hasattr(self.Person, 'age')) self.assertFalse(hasattr(self.Person, 'age'))
@ -40,11 +40,11 @@ class DynamicDocTest(unittest.TestCase):
def test_dynamic_document_delta(self): def test_dynamic_document_delta(self):
"""Ensures simple dynamic documents can delta correctly""" """Ensures simple dynamic documents can delta correctly"""
p = self.Person(name="James", age=34) p = self.Person(name="James", age=34)
self.assertEquals(p._delta(), ({'_types': ['Person'], 'age': 34, 'name': 'James', '_cls': 'Person'}, {})) self.assertEqual(p._delta(), ({'_types': ['Person'], 'age': 34, 'name': 'James', '_cls': 'Person'}, {}))
p.doc = 123 p.doc = 123
del(p.doc) del(p.doc)
self.assertEquals(p._delta(), ({'_types': ['Person'], 'age': 34, 'name': 'James', '_cls': 'Person'}, {'doc': 1})) self.assertEqual(p._delta(), ({'_types': ['Person'], 'age': 34, 'name': 'James', '_cls': 'Person'}, {'doc': 1}))
def test_change_scope_of_variable(self): def test_change_scope_of_variable(self):
"""Test changing the scope of a dynamic field has no adverse effects""" """Test changing the scope of a dynamic field has no adverse effects"""
@ -58,7 +58,7 @@ class DynamicDocTest(unittest.TestCase):
p.save() p.save()
p = self.Person.objects.get() p = self.Person.objects.get()
self.assertEquals(p.misc, {'hello': 'world'}) self.assertEqual(p.misc, {'hello': 'world'})
def test_delete_dynamic_field(self): def test_delete_dynamic_field(self):
"""Test deleting a dynamic field works""" """Test deleting a dynamic field works"""
@ -73,10 +73,10 @@ class DynamicDocTest(unittest.TestCase):
p.save() p.save()
p = self.Person.objects.get() p = self.Person.objects.get()
self.assertEquals(p.misc, {'hello': 'world'}) self.assertEqual(p.misc, {'hello': 'world'})
collection = self.db[self.Person._get_collection_name()] collection = self.db[self.Person._get_collection_name()]
obj = collection.find_one() obj = collection.find_one()
self.assertEquals(sorted(obj.keys()), ['_cls', '_id', '_types', 'misc', 'name']) self.assertEqual(sorted(obj.keys()), ['_cls', '_id', '_types', 'misc', 'name'])
del(p.misc) del(p.misc)
p.save() p.save()
@ -85,7 +85,7 @@ class DynamicDocTest(unittest.TestCase):
self.assertFalse(hasattr(p, 'misc')) self.assertFalse(hasattr(p, 'misc'))
obj = collection.find_one() obj = collection.find_one()
self.assertEquals(sorted(obj.keys()), ['_cls', '_id', '_types', 'name']) self.assertEqual(sorted(obj.keys()), ['_cls', '_id', '_types', 'name'])
def test_dynamic_document_queries(self): def test_dynamic_document_queries(self):
"""Ensure we can query dynamic fields""" """Ensure we can query dynamic fields"""
@ -94,10 +94,10 @@ class DynamicDocTest(unittest.TestCase):
p.age = 22 p.age = 22
p.save() p.save()
self.assertEquals(1, self.Person.objects(age=22).count()) self.assertEqual(1, self.Person.objects(age=22).count())
p = self.Person.objects(age=22) p = self.Person.objects(age=22)
p = p.get() p = p.get()
self.assertEquals(22, p.age) self.assertEqual(22, p.age)
def test_complex_dynamic_document_queries(self): def test_complex_dynamic_document_queries(self):
class Person(DynamicDocument): class Person(DynamicDocument):
@ -117,8 +117,8 @@ class DynamicDocTest(unittest.TestCase):
p2.age = 10 p2.age = 10
p2.save() p2.save()
self.assertEquals(Person.objects(age__icontains='ten').count(), 2) self.assertEqual(Person.objects(age__icontains='ten').count(), 2)
self.assertEquals(Person.objects(age__gte=10).count(), 1) self.assertEqual(Person.objects(age__gte=10).count(), 1)
def test_complex_data_lookups(self): def test_complex_data_lookups(self):
"""Ensure you can query dynamic document dynamic fields""" """Ensure you can query dynamic document dynamic fields"""
@ -126,7 +126,7 @@ class DynamicDocTest(unittest.TestCase):
p.misc = {'hello': 'world'} p.misc = {'hello': 'world'}
p.save() p.save()
self.assertEquals(1, self.Person.objects(misc__hello='world').count()) self.assertEqual(1, self.Person.objects(misc__hello='world').count())
def test_inheritance(self): def test_inheritance(self):
"""Ensure that dynamic document plays nice with inheritance""" """Ensure that dynamic document plays nice with inheritance"""
@ -146,8 +146,8 @@ class DynamicDocTest(unittest.TestCase):
joe_bloggs.age = 20 joe_bloggs.age = 20
joe_bloggs.save() joe_bloggs.save()
self.assertEquals(1, self.Person.objects(age=20).count()) self.assertEqual(1, self.Person.objects(age=20).count())
self.assertEquals(1, Employee.objects(age=20).count()) self.assertEqual(1, Employee.objects(age=20).count())
joe_bloggs = self.Person.objects.first() joe_bloggs = self.Person.objects.first()
self.assertTrue(isinstance(joe_bloggs, Employee)) self.assertTrue(isinstance(joe_bloggs, Employee))
@ -170,7 +170,7 @@ class DynamicDocTest(unittest.TestCase):
embedded_1.list_field = ['1', 2, {'hello': 'world'}] embedded_1.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field = embedded_1 doc.embedded_field = embedded_1
self.assertEquals(doc.to_mongo(), {"_types": ['Doc'], "_cls": "Doc", self.assertEqual(doc.to_mongo(), {"_types": ['Doc'], "_cls": "Doc",
"embedded_field": { "embedded_field": {
"_types": ['Embedded'], "_cls": "Embedded", "_types": ['Embedded'], "_cls": "Embedded",
"string_field": "hello", "string_field": "hello",
@ -182,11 +182,11 @@ class DynamicDocTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc.embedded_field.__class__, Embedded) self.assertEqual(doc.embedded_field.__class__, Embedded)
self.assertEquals(doc.embedded_field.string_field, "hello") self.assertEqual(doc.embedded_field.string_field, "hello")
self.assertEquals(doc.embedded_field.int_field, 1) self.assertEqual(doc.embedded_field.int_field, 1)
self.assertEquals(doc.embedded_field.dict_field, {'hello': 'world'}) self.assertEqual(doc.embedded_field.dict_field, {'hello': 'world'})
self.assertEquals(doc.embedded_field.list_field, ['1', 2, {'hello': 'world'}]) self.assertEqual(doc.embedded_field.list_field, ['1', 2, {'hello': 'world'}])
def test_complex_embedded_documents(self): def test_complex_embedded_documents(self):
"""Test complex dynamic embedded documents setups""" """Test complex dynamic embedded documents setups"""
@ -213,7 +213,7 @@ class DynamicDocTest(unittest.TestCase):
embedded_1.list_field = ['1', 2, embedded_2] embedded_1.list_field = ['1', 2, embedded_2]
doc.embedded_field = embedded_1 doc.embedded_field = embedded_1
self.assertEquals(doc.to_mongo(), {"_types": ['Doc'], "_cls": "Doc", self.assertEqual(doc.to_mongo(), {"_types": ['Doc'], "_cls": "Doc",
"embedded_field": { "embedded_field": {
"_types": ['Embedded'], "_cls": "Embedded", "_types": ['Embedded'], "_cls": "Embedded",
"string_field": "hello", "string_field": "hello",
@ -230,20 +230,20 @@ class DynamicDocTest(unittest.TestCase):
}) })
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc.embedded_field.__class__, Embedded) self.assertEqual(doc.embedded_field.__class__, Embedded)
self.assertEquals(doc.embedded_field.string_field, "hello") self.assertEqual(doc.embedded_field.string_field, "hello")
self.assertEquals(doc.embedded_field.int_field, 1) self.assertEqual(doc.embedded_field.int_field, 1)
self.assertEquals(doc.embedded_field.dict_field, {'hello': 'world'}) self.assertEqual(doc.embedded_field.dict_field, {'hello': 'world'})
self.assertEquals(doc.embedded_field.list_field[0], '1') self.assertEqual(doc.embedded_field.list_field[0], '1')
self.assertEquals(doc.embedded_field.list_field[1], 2) self.assertEqual(doc.embedded_field.list_field[1], 2)
embedded_field = doc.embedded_field.list_field[2] embedded_field = doc.embedded_field.list_field[2]
self.assertEquals(embedded_field.__class__, Embedded) self.assertEqual(embedded_field.__class__, Embedded)
self.assertEquals(embedded_field.string_field, "hello") self.assertEqual(embedded_field.string_field, "hello")
self.assertEquals(embedded_field.int_field, 1) self.assertEqual(embedded_field.int_field, 1)
self.assertEquals(embedded_field.dict_field, {'hello': 'world'}) self.assertEqual(embedded_field.dict_field, {'hello': 'world'})
self.assertEquals(embedded_field.list_field, ['1', 2, {'hello': 'world'}]) self.assertEqual(embedded_field.list_field, ['1', 2, {'hello': 'world'}])
def test_delta_for_dynamic_documents(self): def test_delta_for_dynamic_documents(self):
p = self.Person() p = self.Person()
@ -252,18 +252,18 @@ class DynamicDocTest(unittest.TestCase):
p.save() p.save()
p.age = 24 p.age = 24
self.assertEquals(p.age, 24) self.assertEqual(p.age, 24)
self.assertEquals(p._get_changed_fields(), ['age']) self.assertEqual(p._get_changed_fields(), ['age'])
self.assertEquals(p._delta(), ({'age': 24}, {})) self.assertEqual(p._delta(), ({'age': 24}, {}))
p = self.Person.objects(age=22).get() p = self.Person.objects(age=22).get()
p.age = 24 p.age = 24
self.assertEquals(p.age, 24) self.assertEqual(p.age, 24)
self.assertEquals(p._get_changed_fields(), ['age']) self.assertEqual(p._get_changed_fields(), ['age'])
self.assertEquals(p._delta(), ({'age': 24}, {})) self.assertEqual(p._delta(), ({'age': 24}, {}))
p.save() p.save()
self.assertEquals(1, self.Person.objects(age=24).count()) self.assertEqual(1, self.Person.objects(age=24).count())
def test_delta(self): def test_delta(self):
@ -275,40 +275,40 @@ class DynamicDocTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(doc._delta(), ({}, {})) self.assertEqual(doc._delta(), ({}, {}))
doc.string_field = 'hello' doc.string_field = 'hello'
self.assertEquals(doc._get_changed_fields(), ['string_field']) self.assertEqual(doc._get_changed_fields(), ['string_field'])
self.assertEquals(doc._delta(), ({'string_field': 'hello'}, {})) self.assertEqual(doc._delta(), ({'string_field': 'hello'}, {}))
doc._changed_fields = [] doc._changed_fields = []
doc.int_field = 1 doc.int_field = 1
self.assertEquals(doc._get_changed_fields(), ['int_field']) self.assertEqual(doc._get_changed_fields(), ['int_field'])
self.assertEquals(doc._delta(), ({'int_field': 1}, {})) self.assertEqual(doc._delta(), ({'int_field': 1}, {}))
doc._changed_fields = [] doc._changed_fields = []
dict_value = {'hello': 'world', 'ping': 'pong'} dict_value = {'hello': 'world', 'ping': 'pong'}
doc.dict_field = dict_value doc.dict_field = dict_value
self.assertEquals(doc._get_changed_fields(), ['dict_field']) self.assertEqual(doc._get_changed_fields(), ['dict_field'])
self.assertEquals(doc._delta(), ({'dict_field': dict_value}, {})) self.assertEqual(doc._delta(), ({'dict_field': dict_value}, {}))
doc._changed_fields = [] doc._changed_fields = []
list_value = ['1', 2, {'hello': 'world'}] list_value = ['1', 2, {'hello': 'world'}]
doc.list_field = list_value doc.list_field = list_value
self.assertEquals(doc._get_changed_fields(), ['list_field']) self.assertEqual(doc._get_changed_fields(), ['list_field'])
self.assertEquals(doc._delta(), ({'list_field': list_value}, {})) self.assertEqual(doc._delta(), ({'list_field': list_value}, {}))
# Test unsetting # Test unsetting
doc._changed_fields = [] doc._changed_fields = []
doc.dict_field = {} doc.dict_field = {}
self.assertEquals(doc._get_changed_fields(), ['dict_field']) self.assertEqual(doc._get_changed_fields(), ['dict_field'])
self.assertEquals(doc._delta(), ({}, {'dict_field': 1})) self.assertEqual(doc._delta(), ({}, {'dict_field': 1}))
doc._changed_fields = [] doc._changed_fields = []
doc.list_field = [] doc.list_field = []
self.assertEquals(doc._get_changed_fields(), ['list_field']) self.assertEqual(doc._get_changed_fields(), ['list_field'])
self.assertEquals(doc._delta(), ({}, {'list_field': 1})) self.assertEqual(doc._delta(), ({}, {'list_field': 1}))
def test_delta_recursive(self): def test_delta_recursive(self):
"""Testing deltaing works with dynamic documents""" """Testing deltaing works with dynamic documents"""
@ -323,8 +323,8 @@ class DynamicDocTest(unittest.TestCase):
doc.save() doc.save()
doc = Doc.objects.first() doc = Doc.objects.first()
self.assertEquals(doc._get_changed_fields(), []) self.assertEqual(doc._get_changed_fields(), [])
self.assertEquals(doc._delta(), ({}, {})) self.assertEqual(doc._delta(), ({}, {}))
embedded_1 = Embedded() embedded_1 = Embedded()
embedded_1.string_field = 'hello' embedded_1.string_field = 'hello'
@ -333,7 +333,7 @@ class DynamicDocTest(unittest.TestCase):
embedded_1.list_field = ['1', 2, {'hello': 'world'}] embedded_1.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field = embedded_1 doc.embedded_field = embedded_1
self.assertEquals(doc._get_changed_fields(), ['embedded_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field'])
embedded_delta = { embedded_delta = {
'string_field': 'hello', 'string_field': 'hello',
@ -341,28 +341,28 @@ class DynamicDocTest(unittest.TestCase):
'dict_field': {'hello': 'world'}, 'dict_field': {'hello': 'world'},
'list_field': ['1', 2, {'hello': 'world'}] 'list_field': ['1', 2, {'hello': 'world'}]
} }
self.assertEquals(doc.embedded_field._delta(), (embedded_delta, {})) self.assertEqual(doc.embedded_field._delta(), (embedded_delta, {}))
embedded_delta.update({ embedded_delta.update({
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
}) })
self.assertEquals(doc._delta(), ({'embedded_field': embedded_delta}, {})) self.assertEqual(doc._delta(), ({'embedded_field': embedded_delta}, {}))
doc.save() doc.save()
doc.reload() doc.reload()
doc.embedded_field.dict_field = {} doc.embedded_field.dict_field = {}
self.assertEquals(doc._get_changed_fields(), ['embedded_field.dict_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.dict_field'])
self.assertEquals(doc.embedded_field._delta(), ({}, {'dict_field': 1})) self.assertEqual(doc.embedded_field._delta(), ({}, {'dict_field': 1}))
self.assertEquals(doc._delta(), ({}, {'embedded_field.dict_field': 1})) self.assertEqual(doc._delta(), ({}, {'embedded_field.dict_field': 1}))
doc.save() doc.save()
doc.reload() doc.reload()
doc.embedded_field.list_field = [] doc.embedded_field.list_field = []
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field'])
self.assertEquals(doc.embedded_field._delta(), ({}, {'list_field': 1})) self.assertEqual(doc.embedded_field._delta(), ({}, {'list_field': 1}))
self.assertEquals(doc._delta(), ({}, {'embedded_field.list_field': 1})) self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field': 1}))
doc.save() doc.save()
doc.reload() doc.reload()
@ -373,8 +373,8 @@ class DynamicDocTest(unittest.TestCase):
embedded_2.list_field = ['1', 2, {'hello': 'world'}] embedded_2.list_field = ['1', 2, {'hello': 'world'}]
doc.embedded_field.list_field = ['1', 2, embedded_2] doc.embedded_field.list_field = ['1', 2, embedded_2]
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field'])
self.assertEquals(doc.embedded_field._delta(), ({ self.assertEqual(doc.embedded_field._delta(), ({
'list_field': ['1', 2, { 'list_field': ['1', 2, {
'_cls': 'Embedded', '_cls': 'Embedded',
'_types': ['Embedded'], '_types': ['Embedded'],
@ -385,7 +385,7 @@ class DynamicDocTest(unittest.TestCase):
}] }]
}, {})) }, {}))
self.assertEquals(doc._delta(), ({ self.assertEqual(doc._delta(), ({
'embedded_field.list_field': ['1', 2, { 'embedded_field.list_field': ['1', 2, {
'_cls': 'Embedded', '_cls': 'Embedded',
'_types': ['Embedded'], '_types': ['Embedded'],
@ -398,25 +398,25 @@ class DynamicDocTest(unittest.TestCase):
doc.save() doc.save()
doc.reload() doc.reload()
self.assertEquals(doc.embedded_field.list_field[2]._changed_fields, []) self.assertEqual(doc.embedded_field.list_field[2]._changed_fields, [])
self.assertEquals(doc.embedded_field.list_field[0], '1') self.assertEqual(doc.embedded_field.list_field[0], '1')
self.assertEquals(doc.embedded_field.list_field[1], 2) self.assertEqual(doc.embedded_field.list_field[1], 2)
for k in doc.embedded_field.list_field[2]._fields: for k in doc.embedded_field.list_field[2]._fields:
self.assertEquals(doc.embedded_field.list_field[2][k], embedded_2[k]) self.assertEqual(doc.embedded_field.list_field[2][k], embedded_2[k])
doc.embedded_field.list_field[2].string_field = 'world' doc.embedded_field.list_field[2].string_field = 'world'
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field.2.string_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field.2.string_field'])
self.assertEquals(doc.embedded_field._delta(), ({'list_field.2.string_field': 'world'}, {})) self.assertEqual(doc.embedded_field._delta(), ({'list_field.2.string_field': 'world'}, {}))
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.string_field': 'world'}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.string_field': 'world'}, {}))
doc.save() doc.save()
doc.reload() doc.reload()
self.assertEquals(doc.embedded_field.list_field[2].string_field, 'world') self.assertEqual(doc.embedded_field.list_field[2].string_field, 'world')
# Test multiple assignments # Test multiple assignments
doc.embedded_field.list_field[2].string_field = 'hello world' doc.embedded_field.list_field[2].string_field = 'hello world'
doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2] doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2]
self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field'])
self.assertEquals(doc.embedded_field._delta(), ({ self.assertEqual(doc.embedded_field._delta(), ({
'list_field': ['1', 2, { 'list_field': ['1', 2, {
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
@ -424,7 +424,7 @@ class DynamicDocTest(unittest.TestCase):
'int_field': 1, 'int_field': 1,
'list_field': ['1', 2, {'hello': 'world'}], 'list_field': ['1', 2, {'hello': 'world'}],
'dict_field': {'hello': 'world'}}]}, {})) 'dict_field': {'hello': 'world'}}]}, {}))
self.assertEquals(doc._delta(), ({ self.assertEqual(doc._delta(), ({
'embedded_field.list_field': ['1', 2, { 'embedded_field.list_field': ['1', 2, {
'_types': ['Embedded'], '_types': ['Embedded'],
'_cls': 'Embedded', '_cls': 'Embedded',
@ -435,32 +435,32 @@ class DynamicDocTest(unittest.TestCase):
]}, {})) ]}, {}))
doc.save() doc.save()
doc.reload() doc.reload()
self.assertEquals(doc.embedded_field.list_field[2].string_field, 'hello world') self.assertEqual(doc.embedded_field.list_field[2].string_field, 'hello world')
# Test list native methods # Test list native methods
doc.embedded_field.list_field[2].list_field.pop(0) doc.embedded_field.list_field[2].list_field.pop(0)
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}]}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}]}, {}))
doc.save() doc.save()
doc.reload() doc.reload()
doc.embedded_field.list_field[2].list_field.append(1) doc.embedded_field.list_field[2].list_field.append(1)
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}, 1]}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.list_field': [2, {'hello': 'world'}, 1]}, {}))
doc.save() doc.save()
doc.reload() doc.reload()
self.assertEquals(doc.embedded_field.list_field[2].list_field, [2, {'hello': 'world'}, 1]) self.assertEqual(doc.embedded_field.list_field[2].list_field, [2, {'hello': 'world'}, 1])
doc.embedded_field.list_field[2].list_field.sort() doc.embedded_field.list_field[2].list_field.sort(key=str)# use str as a key to allow comparing uncomperable types
doc.save() doc.save()
doc.reload() doc.reload()
self.assertEquals(doc.embedded_field.list_field[2].list_field, [1, 2, {'hello': 'world'}]) self.assertEqual(doc.embedded_field.list_field[2].list_field, [1, 2, {'hello': 'world'}])
del(doc.embedded_field.list_field[2].list_field[2]['hello']) del(doc.embedded_field.list_field[2].list_field[2]['hello'])
self.assertEquals(doc._delta(), ({'embedded_field.list_field.2.list_field': [1, 2, {}]}, {})) self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.list_field': [1, 2, {}]}, {}))
doc.save() doc.save()
doc.reload() doc.reload()
del(doc.embedded_field.list_field[2].list_field) del(doc.embedded_field.list_field[2].list_field)
self.assertEquals(doc._delta(), ({}, {'embedded_field.list_field.2.list_field': 1})) self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field.2.list_field': 1}))
doc.save() doc.save()
doc.reload() doc.reload()
@ -470,8 +470,8 @@ class DynamicDocTest(unittest.TestCase):
doc.reload() doc.reload()
doc.dict_field['embedded'].string_field = 'Hello World' doc.dict_field['embedded'].string_field = 'Hello World'
self.assertEquals(doc._get_changed_fields(), ['dict_field.embedded.string_field']) self.assertEqual(doc._get_changed_fields(), ['dict_field.embedded.string_field'])
self.assertEquals(doc._delta(), ({'dict_field.embedded.string_field': 'Hello World'}, {})) self.assertEqual(doc._delta(), ({'dict_field.embedded.string_field': 'Hello World'}, {}))
def test_indexes(self): def test_indexes(self):
"""Ensure that indexes are used when meta[indexes] is specified. """Ensure that indexes are used when meta[indexes] is specified.

210
tests/test_fields.py
View File

@ -2,20 +2,21 @@ import datetime
import os import os
import unittest import unittest
import uuid import uuid
import StringIO
import tempfile import tempfile
import gridfs
from bson import Binary
from decimal import Decimal from decimal import Decimal
from bson import Binary
import gridfs
from nose.plugins.skip import SkipTest
from mongoengine import * from mongoengine import *
from mongoengine.connection import get_db from mongoengine.connection import get_db
from mongoengine.base import _document_registry, NotRegistered from mongoengine.base import _document_registry, NotRegistered
from mongoengine.python3_support import PY3, b, StringIO, bin_type
TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), 'mongoengine.png') TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), 'mongoengine.png')
class FieldTest(unittest.TestCase): class FieldTest(unittest.TestCase):
def setUp(self): def setUp(self):
@ -124,7 +125,7 @@ class FieldTest(unittest.TestCase):
self.assertEqual(ret.int_fld, None) self.assertEqual(ret.int_fld, None)
self.assertEqual(ret.flt_fld, None) self.assertEqual(ret.flt_fld, None)
# Return current time if retrived value is None. # Return current time if retrived value is None.
self.assert_(isinstance(ret.comp_dt_fld, datetime.datetime)) self.assertTrue(isinstance(ret.comp_dt_fld, datetime.datetime))
self.assertRaises(ValidationError, ret.validate) self.assertRaises(ValidationError, ret.validate)
@ -356,7 +357,7 @@ class FieldTest(unittest.TestCase):
log.date = datetime.date.today() log.date = datetime.date.today()
log.save() log.save()
log.reload() log.reload()
self.assertEquals(log.date.date(), datetime.date.today()) self.assertEqual(log.date.date(), datetime.date.today())
LogEntry.drop_collection() LogEntry.drop_collection()
@ -367,8 +368,8 @@ class FieldTest(unittest.TestCase):
log.date = d1 log.date = d1
log.save() log.save()
log.reload() log.reload()
self.assertNotEquals(log.date, d1) self.assertNotEqual(log.date, d1)
self.assertEquals(log.date, d2) self.assertEqual(log.date, d2)
# Post UTC - microseconds are rounded (down) nearest millisecond # Post UTC - microseconds are rounded (down) nearest millisecond
d1 = datetime.datetime(1970, 01, 01, 00, 00, 01, 9999) d1 = datetime.datetime(1970, 01, 01, 00, 00, 01, 9999)
@ -376,17 +377,19 @@ class FieldTest(unittest.TestCase):
log.date = d1 log.date = d1
log.save() log.save()
log.reload() log.reload()
self.assertNotEquals(log.date, d1) self.assertNotEqual(log.date, d1)
self.assertEquals(log.date, d2) self.assertEqual(log.date, d2)
# Pre UTC dates microseconds below 1000 are dropped if not PY3:
d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999) # Pre UTC dates microseconds below 1000 are dropped
d2 = datetime.datetime(1969, 12, 31, 23, 59, 59) # This does not seem to be true in PY3
log.date = d1 d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)
log.save() d2 = datetime.datetime(1969, 12, 31, 23, 59, 59)
log.reload() log.date = d1
self.assertNotEquals(log.date, d1) log.save()
self.assertEquals(log.date, d2) log.reload()
self.assertNotEqual(log.date, d1)
self.assertEqual(log.date, d2)
LogEntry.drop_collection() LogEntry.drop_collection()
@ -405,21 +408,21 @@ class FieldTest(unittest.TestCase):
log.date = d1 log.date = d1
log.save() log.save()
log.reload() log.reload()
self.assertEquals(log.date, d1) self.assertEqual(log.date, d1)
# Post UTC - microseconds are rounded (down) nearest millisecond - with default datetimefields # Post UTC - microseconds are rounded (down) nearest millisecond - with default datetimefields
d1 = datetime.datetime(1970, 01, 01, 00, 00, 01, 9999) d1 = datetime.datetime(1970, 01, 01, 00, 00, 01, 9999)
log.date = d1 log.date = d1
log.save() log.save()
log.reload() log.reload()
self.assertEquals(log.date, d1) self.assertEqual(log.date, d1)
# Pre UTC dates microseconds below 1000 are dropped - with default datetimefields # Pre UTC dates microseconds below 1000 are dropped - with default datetimefields
d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999) d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)
log.date = d1 log.date = d1
log.save() log.save()
log.reload() log.reload()
self.assertEquals(log.date, d1) self.assertEqual(log.date, d1)
# Pre UTC microseconds above 1000 is wonky - with default datetimefields # Pre UTC microseconds above 1000 is wonky - with default datetimefields
# log.date has an invalid microsecond value so I can't construct # log.date has an invalid microsecond value so I can't construct
@ -429,7 +432,7 @@ class FieldTest(unittest.TestCase):
log.date = d1 log.date = d1
log.save() log.save()
log.reload() log.reload()
self.assertEquals(log.date, d1) self.assertEqual(log.date, d1)
log1 = LogEntry.objects.get(date=d1) log1 = LogEntry.objects.get(date=d1)
self.assertEqual(log, log1) self.assertEqual(log, log1)
@ -450,7 +453,7 @@ class FieldTest(unittest.TestCase):
log.save() log.save()
log1 = LogEntry.objects.get(date=d1) log1 = LogEntry.objects.get(date=d1)
self.assertEquals(log, log1) self.assertEqual(log, log1)
LogEntry.drop_collection() LogEntry.drop_collection()
@ -638,13 +641,13 @@ class FieldTest(unittest.TestCase):
post.info = [{'test': 3}] post.info = [{'test': 3}]
post.save() post.save()
self.assertEquals(BlogPost.objects.count(), 3) self.assertEqual(BlogPost.objects.count(), 3)
self.assertEquals(BlogPost.objects.filter(info__exact='test').count(), 1) self.assertEqual(BlogPost.objects.filter(info__exact='test').count(), 1)
self.assertEquals(BlogPost.objects.filter(info__0__test='test').count(), 1) self.assertEqual(BlogPost.objects.filter(info__0__test='test').count(), 1)
# Confirm handles non strings or non existing keys # Confirm handles non strings or non existing keys
self.assertEquals(BlogPost.objects.filter(info__0__test__exact='5').count(), 0) self.assertEqual(BlogPost.objects.filter(info__0__test__exact='5').count(), 0)
self.assertEquals(BlogPost.objects.filter(info__100__test__exact='test').count(), 0) self.assertEqual(BlogPost.objects.filter(info__100__test__exact='test').count(), 0)
BlogPost.drop_collection() BlogPost.drop_collection()
def test_list_field_passed_in_value(self): def test_list_field_passed_in_value(self):
@ -659,7 +662,7 @@ class FieldTest(unittest.TestCase):
foo = Foo(bars=[]) foo = Foo(bars=[])
foo.bars.append(bar) foo.bars.append(bar)
self.assertEquals(repr(foo.bars), '[<Bar: Bar object>]') self.assertEqual(repr(foo.bars), '[<Bar: Bar object>]')
def test_list_field_strict(self): def test_list_field_strict(self):
@ -744,20 +747,20 @@ class FieldTest(unittest.TestCase):
self.assertTrue(isinstance(e2.mapping[1], IntegerSetting)) self.assertTrue(isinstance(e2.mapping[1], IntegerSetting))
# Test querying # Test querying
self.assertEquals(Simple.objects.filter(mapping__1__value=42).count(), 1) self.assertEqual(Simple.objects.filter(mapping__1__value=42).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__2__number=1).count(), 1) self.assertEqual(Simple.objects.filter(mapping__2__number=1).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__2__complex__value=42).count(), 1) self.assertEqual(Simple.objects.filter(mapping__2__complex__value=42).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__2__list__0__value=42).count(), 1) self.assertEqual(Simple.objects.filter(mapping__2__list__0__value=42).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__2__list__1__value='foo').count(), 1) self.assertEqual(Simple.objects.filter(mapping__2__list__1__value='foo').count(), 1)
# Confirm can update # Confirm can update
Simple.objects().update(set__mapping__1=IntegerSetting(value=10)) Simple.objects().update(set__mapping__1=IntegerSetting(value=10))
self.assertEquals(Simple.objects.filter(mapping__1__value=10).count(), 1) self.assertEqual(Simple.objects.filter(mapping__1__value=10).count(), 1)
Simple.objects().update( Simple.objects().update(
set__mapping__2__list__1=StringSetting(value='Boo')) set__mapping__2__list__1=StringSetting(value='Boo'))
self.assertEquals(Simple.objects.filter(mapping__2__list__1__value='foo').count(), 0) self.assertEqual(Simple.objects.filter(mapping__2__list__1__value='foo').count(), 0)
self.assertEquals(Simple.objects.filter(mapping__2__list__1__value='Boo').count(), 1) self.assertEqual(Simple.objects.filter(mapping__2__list__1__value='Boo').count(), 1)
Simple.drop_collection() Simple.drop_collection()
@ -796,19 +799,19 @@ class FieldTest(unittest.TestCase):
post.info = {'details': {'test': 3}} post.info = {'details': {'test': 3}}
post.save() post.save()
self.assertEquals(BlogPost.objects.count(), 3) self.assertEqual(BlogPost.objects.count(), 3)
self.assertEquals(BlogPost.objects.filter(info__title__exact='test').count(), 1) self.assertEqual(BlogPost.objects.filter(info__title__exact='test').count(), 1)
self.assertEquals(BlogPost.objects.filter(info__details__test__exact='test').count(), 1) self.assertEqual(BlogPost.objects.filter(info__details__test__exact='test').count(), 1)
# Confirm handles non strings or non existing keys # Confirm handles non strings or non existing keys
self.assertEquals(BlogPost.objects.filter(info__details__test__exact=5).count(), 0) self.assertEqual(BlogPost.objects.filter(info__details__test__exact=5).count(), 0)
self.assertEquals(BlogPost.objects.filter(info__made_up__test__exact='test').count(), 0) self.assertEqual(BlogPost.objects.filter(info__made_up__test__exact='test').count(), 0)
post = BlogPost.objects.create(info={'title': 'original'}) post = BlogPost.objects.create(info={'title': 'original'})
post.info.update({'title': 'updated'}) post.info.update({'title': 'updated'})
post.save() post.save()
post.reload() post.reload()
self.assertEquals('updated', post.info['title']) self.assertEqual('updated', post.info['title'])
BlogPost.drop_collection() BlogPost.drop_collection()
@ -861,19 +864,19 @@ class FieldTest(unittest.TestCase):
self.assertTrue(isinstance(e2.mapping['someint'], IntegerSetting)) self.assertTrue(isinstance(e2.mapping['someint'], IntegerSetting))
# Test querying # Test querying
self.assertEquals(Simple.objects.filter(mapping__someint__value=42).count(), 1) self.assertEqual(Simple.objects.filter(mapping__someint__value=42).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__nested_dict__number=1).count(), 1) self.assertEqual(Simple.objects.filter(mapping__nested_dict__number=1).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__nested_dict__complex__value=42).count(), 1) self.assertEqual(Simple.objects.filter(mapping__nested_dict__complex__value=42).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__nested_dict__list__0__value=42).count(), 1) self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__0__value=42).count(), 1)
self.assertEquals(Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 1) self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 1)
# Confirm can update # Confirm can update
Simple.objects().update( Simple.objects().update(
set__mapping={"someint": IntegerSetting(value=10)}) set__mapping={"someint": IntegerSetting(value=10)})
Simple.objects().update( Simple.objects().update(
set__mapping__nested_dict__list__1=StringSetting(value='Boo')) set__mapping__nested_dict__list__1=StringSetting(value='Boo'))
self.assertEquals(Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 0) self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 0)
self.assertEquals(Simple.objects.filter(mapping__nested_dict__list__1__value='Boo').count(), 1) self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__1__value='Boo').count(), 1)
Simple.drop_collection() Simple.drop_collection()
@ -1383,7 +1386,7 @@ class FieldTest(unittest.TestCase):
Person.drop_collection() Person.drop_collection()
Person(name="Wilson Jr").save() Person(name="Wilson Jr").save()
self.assertEquals(repr(Person.objects(city=None)), self.assertEqual(repr(Person.objects(city=None)),
"[<Person: Person object>]") "[<Person: Person object>]")
@ -1461,7 +1464,7 @@ class FieldTest(unittest.TestCase):
content_type = StringField() content_type = StringField()
blob = BinaryField() blob = BinaryField()
BLOB = '\xe6\x00\xc4\xff\x07' BLOB = b('\xe6\x00\xc4\xff\x07')
MIME_TYPE = 'application/octet-stream' MIME_TYPE = 'application/octet-stream'
Attachment.drop_collection() Attachment.drop_collection()
@ -1471,7 +1474,7 @@ class FieldTest(unittest.TestCase):
attachment_1 = Attachment.objects().first() attachment_1 = Attachment.objects().first()
self.assertEqual(MIME_TYPE, attachment_1.content_type) self.assertEqual(MIME_TYPE, attachment_1.content_type)
self.assertEqual(BLOB, str(attachment_1.blob)) self.assertEqual(BLOB, bin_type(attachment_1.blob))
Attachment.drop_collection() Attachment.drop_collection()
@ -1498,12 +1501,12 @@ class FieldTest(unittest.TestCase):
attachment_required = AttachmentRequired() attachment_required = AttachmentRequired()
self.assertRaises(ValidationError, attachment_required.validate) self.assertRaises(ValidationError, attachment_required.validate)
attachment_required.blob = Binary('\xe6\x00\xc4\xff\x07') attachment_required.blob = Binary(b('\xe6\x00\xc4\xff\x07'))
attachment_required.validate() attachment_required.validate()
attachment_size_limit = AttachmentSizeLimit(blob='\xe6\x00\xc4\xff\x07') attachment_size_limit = AttachmentSizeLimit(blob=b('\xe6\x00\xc4\xff\x07'))
self.assertRaises(ValidationError, attachment_size_limit.validate) self.assertRaises(ValidationError, attachment_size_limit.validate)
attachment_size_limit.blob = '\xe6\x00\xc4\xff' attachment_size_limit.blob = b('\xe6\x00\xc4\xff')
attachment_size_limit.validate() attachment_size_limit.validate()
Attachment.drop_collection() Attachment.drop_collection()
@ -1630,8 +1633,8 @@ class FieldTest(unittest.TestCase):
class SetFile(Document): class SetFile(Document):
the_file = FileField() the_file = FileField()
text = 'Hello, World!' text = b('Hello, World!')
more_text = 'Foo Bar' more_text = b('Foo Bar')
content_type = 'text/plain' content_type = 'text/plain'
PutFile.drop_collection() PutFile.drop_collection()
@ -1644,14 +1647,14 @@ class FieldTest(unittest.TestCase):
putfile.validate() putfile.validate()
result = PutFile.objects.first() result = PutFile.objects.first()
self.assertTrue(putfile == result) self.assertTrue(putfile == result)
self.assertEquals(result.the_file.read(), text) self.assertEqual(result.the_file.read(), text)
self.assertEquals(result.the_file.content_type, content_type) self.assertEqual(result.the_file.content_type, content_type)
result.the_file.delete() # Remove file from GridFS result.the_file.delete() # Remove file from GridFS
PutFile.objects.delete() PutFile.objects.delete()
# Ensure file-like objects are stored # Ensure file-like objects are stored
putfile = PutFile() putfile = PutFile()
putstring = StringIO.StringIO() putstring = StringIO()
putstring.write(text) putstring.write(text)
putstring.seek(0) putstring.seek(0)
putfile.the_file.put(putstring, content_type=content_type) putfile.the_file.put(putstring, content_type=content_type)
@ -1659,8 +1662,8 @@ class FieldTest(unittest.TestCase):
putfile.validate() putfile.validate()
result = PutFile.objects.first() result = PutFile.objects.first()
self.assertTrue(putfile == result) self.assertTrue(putfile == result)
self.assertEquals(result.the_file.read(), text) self.assertEqual(result.the_file.read(), text)
self.assertEquals(result.the_file.content_type, content_type) self.assertEqual(result.the_file.content_type, content_type)
result.the_file.delete() result.the_file.delete()
streamfile = StreamFile() streamfile = StreamFile()
@ -1675,11 +1678,11 @@ class FieldTest(unittest.TestCase):
self.assertEquals(result.the_file.read(), text + more_text) self.assertEquals(result.the_file.read(), text + more_text)
self.assertEquals(result.the_file.content_type, content_type) self.assertEquals(result.the_file.content_type, content_type)
result.the_file.seek(0) result.the_file.seek(0)
self.assertEquals(result.the_file.tell(), 0) self.assertEqual(result.the_file.tell(), 0)
self.assertEquals(result.the_file.read(len(text)), text) self.assertEqual(result.the_file.read(len(text)), text)
self.assertEquals(result.the_file.tell(), len(text)) self.assertEqual(result.the_file.tell(), len(text))
self.assertEquals(result.the_file.read(len(more_text)), more_text) self.assertEqual(result.the_file.read(len(more_text)), more_text)
self.assertEquals(result.the_file.tell(), len(text + more_text)) self.assertEqual(result.the_file.tell(), len(text + more_text))
result.the_file.delete() result.the_file.delete()
# Ensure deleted file returns None # Ensure deleted file returns None
@ -1691,7 +1694,7 @@ class FieldTest(unittest.TestCase):
setfile.validate() setfile.validate()
result = SetFile.objects.first() result = SetFile.objects.first()
self.assertTrue(setfile == result) self.assertTrue(setfile == result)
self.assertEquals(result.the_file.read(), text) self.assertEqual(result.the_file.read(), text)
# Try replacing file with new one # Try replacing file with new one
result.the_file.replace(more_text) result.the_file.replace(more_text)
@ -1699,7 +1702,7 @@ class FieldTest(unittest.TestCase):
result.validate() result.validate()
result = SetFile.objects.first() result = SetFile.objects.first()
self.assertTrue(setfile == result) self.assertTrue(setfile == result)
self.assertEquals(result.the_file.read(), more_text) self.assertEqual(result.the_file.read(), more_text)
result.the_file.delete() result.the_file.delete()
PutFile.drop_collection() PutFile.drop_collection()
@ -1720,7 +1723,7 @@ class FieldTest(unittest.TestCase):
GridDocument.drop_collection() GridDocument.drop_collection()
with tempfile.TemporaryFile() as f: with tempfile.TemporaryFile() as f:
f.write("Hello World!") f.write(b("Hello World!"))
f.flush() f.flush()
# Test without default # Test without default
@ -1731,28 +1734,28 @@ class FieldTest(unittest.TestCase):
doc_b = GridDocument.objects.with_id(doc_a.id) doc_b = GridDocument.objects.with_id(doc_a.id)
doc_b.the_file.replace(f, filename='doc_b') doc_b.the_file.replace(f, filename='doc_b')
doc_b.save() doc_b.save()
self.assertNotEquals(doc_b.the_file.grid_id, None) self.assertNotEqual(doc_b.the_file.grid_id, None)
# Test it matches # Test it matches
doc_c = GridDocument.objects.with_id(doc_b.id) doc_c = GridDocument.objects.with_id(doc_b.id)
self.assertEquals(doc_b.the_file.grid_id, doc_c.the_file.grid_id) self.assertEqual(doc_b.the_file.grid_id, doc_c.the_file.grid_id)
# Test with default # Test with default
doc_d = GridDocument(the_file='') doc_d = GridDocument(the_file=b(''))
doc_d.save() doc_d.save()
doc_e = GridDocument.objects.with_id(doc_d.id) doc_e = GridDocument.objects.with_id(doc_d.id)
self.assertEquals(doc_d.the_file.grid_id, doc_e.the_file.grid_id) self.assertEqual(doc_d.the_file.grid_id, doc_e.the_file.grid_id)
doc_e.the_file.replace(f, filename='doc_e') doc_e.the_file.replace(f, filename='doc_e')
doc_e.save() doc_e.save()
doc_f = GridDocument.objects.with_id(doc_e.id) doc_f = GridDocument.objects.with_id(doc_e.id)
self.assertEquals(doc_e.the_file.grid_id, doc_f.the_file.grid_id) self.assertEqual(doc_e.the_file.grid_id, doc_f.the_file.grid_id)
db = GridDocument._get_db() db = GridDocument._get_db()
grid_fs = gridfs.GridFS(db) grid_fs = gridfs.GridFS(db)
self.assertEquals(['doc_b', 'doc_e'], grid_fs.list()) self.assertEqual(['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
@ -1764,7 +1767,7 @@ class FieldTest(unittest.TestCase):
# First instance # First instance
test_file = TestFile() test_file = TestFile()
test_file.name = "Hello, World!" test_file.name = "Hello, World!"
test_file.the_file.put('Hello, World!') test_file.the_file.put(b('Hello, World!'))
test_file.save() test_file.save()
# Second instance # Second instance
@ -1784,7 +1787,7 @@ class FieldTest(unittest.TestCase):
test_file = TestFile() test_file = TestFile()
self.assertFalse(bool(test_file.the_file)) self.assertFalse(bool(test_file.the_file))
test_file.the_file = 'Hello, World!' test_file.the_file = b('Hello, World!')
test_file.the_file.content_type = 'text/plain' test_file.the_file.content_type = 'text/plain'
test_file.save() test_file.save()
self.assertTrue(bool(test_file.the_file)) self.assertTrue(bool(test_file.the_file))
@ -1800,6 +1803,8 @@ class FieldTest(unittest.TestCase):
self.assertFalse(test_file.the_file in [{"test": 1}]) self.assertFalse(test_file.the_file in [{"test": 1}])
def test_image_field(self): def test_image_field(self):
if PY3:
raise SkipTest('PIL does not have Python 3 support')
class TestImage(Document): class TestImage(Document):
image = ImageField() image = ImageField()
@ -1821,6 +1826,8 @@ class FieldTest(unittest.TestCase):
t.image.delete() t.image.delete()
def test_image_field_resize(self): def test_image_field_resize(self):
if PY3:
raise SkipTest('PIL does not have Python 3 support')
class TestImage(Document): class TestImage(Document):
image = ImageField(size=(185, 37)) image = ImageField(size=(185, 37))
@ -1842,6 +1849,8 @@ class FieldTest(unittest.TestCase):
t.image.delete() t.image.delete()
def test_image_field_thumbnail(self): def test_image_field_thumbnail(self):
if PY3:
raise SkipTest('PIL does not have Python 3 support')
class TestImage(Document): class TestImage(Document):
image = ImageField(thumbnail_size=(92, 18)) image = ImageField(thumbnail_size=(92, 18))
@ -1860,7 +1869,6 @@ class FieldTest(unittest.TestCase):
t.image.delete() t.image.delete()
def test_file_multidb(self): def test_file_multidb(self):
register_connection('test_files', 'test_files') register_connection('test_files', 'test_files')
class TestFile(Document): class TestFile(Document):
@ -1877,7 +1885,7 @@ class FieldTest(unittest.TestCase):
# First instance # First instance
test_file = TestFile() test_file = TestFile()
test_file.name = "Hello, World!" test_file.name = "Hello, World!"
test_file.the_file.put('Hello, World!', test_file.the_file.put(b('Hello, World!'),
name="hello.txt") name="hello.txt")
test_file.save() test_file.save()
@ -1885,8 +1893,8 @@ class FieldTest(unittest.TestCase):
self.assertEquals(data.get('name'), 'hello.txt') self.assertEquals(data.get('name'), 'hello.txt')
test_file = TestFile.objects.first() test_file = TestFile.objects.first()
self.assertEquals(test_file.the_file.read(), self.assertEqual(test_file.the_file.read(),
'Hello, World!') b('Hello, World!'))
def test_geo_indexes(self): def test_geo_indexes(self):
"""Ensure that indexes are created automatically for GeoPointFields. """Ensure that indexes are created automatically for GeoPointFields.
@ -2146,28 +2154,28 @@ class FieldTest(unittest.TestCase):
post = Post(title='hello world') post = Post(title='hello world')
post.comments.append(Comment(content='hello', author=bob)) post.comments.append(Comment(content='hello', author=bob))
post.comments.append(Comment(author=bob)) post.comments.append(Comment(author=bob))
self.assertRaises(ValidationError, post.validate)
try: try:
post.validate() post.validate()
except ValidationError, error: except ValidationError, error:
pass # ValidationError.errors property
self.assertTrue(hasattr(error, 'errors'))
self.assertTrue(isinstance(error.errors, dict))
self.assertTrue('comments' in error.errors)
self.assertTrue(1 in error.errors['comments'])
self.assertTrue(isinstance(error.errors['comments'][1]['content'],
ValidationError))
# ValidationError.errors property # ValidationError.schema property
self.assertTrue(hasattr(error, 'errors')) error_dict = error.to_dict()
self.assertTrue(isinstance(error.errors, dict)) self.assertTrue(isinstance(error_dict, dict))
self.assertTrue('comments' in error.errors) self.assertTrue('comments' in error_dict)
self.assertTrue(1 in error.errors['comments']) self.assertTrue(1 in error_dict['comments'])
self.assertTrue(isinstance(error.errors['comments'][1]['content'], self.assertTrue('content' in error_dict['comments'][1])
ValidationError)) self.assertEqual(error_dict['comments'][1]['content'],
u'Field is required')
# ValidationError.schema property
error_dict = error.to_dict()
self.assertTrue(isinstance(error_dict, dict))
self.assertTrue('comments' in error_dict)
self.assertTrue(1 in error_dict['comments'])
self.assertTrue('content' in error_dict['comments'][1])
self.assertEquals(error_dict['comments'][1]['content'],
'Field is required')
post.comments[1].content = 'here we go' post.comments[1].content = 'here we go'
post.validate() post.validate()

150
tests/test_queryset.py
View File

@ -1,16 +1,19 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import unittest import unittest
import pymongo
from bson import ObjectId
from datetime import datetime, timedelta from datetime import datetime, timedelta
import pymongo
from bson import ObjectId
from mongoengine import *
from mongoengine.connection import get_connection
from mongoengine.python3_support import PY3
from mongoengine.tests import query_counter
from mongoengine.queryset import (QuerySet, QuerySetManager, from mongoengine.queryset import (QuerySet, QuerySetManager,
MultipleObjectsReturned, DoesNotExist, MultipleObjectsReturned, DoesNotExist,
QueryFieldList) QueryFieldList)
from mongoengine import *
from mongoengine.connection import get_connection
from mongoengine.tests import query_counter
class QuerySetTest(unittest.TestCase): class QuerySetTest(unittest.TestCase):
@ -239,11 +242,11 @@ class QuerySetTest(unittest.TestCase):
self.Person.objects.update(set__name='Ross', write_options=write_options) self.Person.objects.update(set__name='Ross', write_options=write_options)
author = self.Person.objects.first() author = self.Person.objects.first()
self.assertEquals(author.name, 'Ross') self.assertEqual(author.name, 'Ross')
self.Person.objects.update_one(set__name='Test User', write_options=write_options) self.Person.objects.update_one(set__name='Test User', write_options=write_options)
author = self.Person.objects.first() author = self.Person.objects.first()
self.assertEquals(author.name, 'Test User') self.assertEqual(author.name, 'Test User')
def test_update_update_has_a_value(self): def test_update_update_has_a_value(self):
"""Test to ensure that update is passed a value to update to""" """Test to ensure that update is passed a value to update to"""
@ -332,8 +335,8 @@ class QuerySetTest(unittest.TestCase):
BlogPost.objects(comments__by="jane").update(inc__comments__S__votes=1) BlogPost.objects(comments__by="jane").update(inc__comments__S__votes=1)
post = BlogPost.objects.first() post = BlogPost.objects.first()
self.assertEquals(post.comments[1].by, 'jane') self.assertEqual(post.comments[1].by, 'jane')
self.assertEquals(post.comments[1].votes, 8) self.assertEqual(post.comments[1].votes, 8)
# Currently the $ operator only applies to the first matched item in # Currently the $ operator only applies to the first matched item in
# the query # the query
@ -346,7 +349,7 @@ class QuerySetTest(unittest.TestCase):
Simple.objects(x=2).update(inc__x__S=1) Simple.objects(x=2).update(inc__x__S=1)
simple = Simple.objects.first() simple = Simple.objects.first()
self.assertEquals(simple.x, [1, 3, 3, 2]) self.assertEqual(simple.x, [1, 3, 3, 2])
Simple.drop_collection() Simple.drop_collection()
# You can set multiples # You can set multiples
@ -358,10 +361,10 @@ class QuerySetTest(unittest.TestCase):
Simple.objects(x=3).update(set__x__S=0) Simple.objects(x=3).update(set__x__S=0)
s = Simple.objects() s = Simple.objects()
self.assertEquals(s[0].x, [1, 2, 0, 4]) self.assertEqual(s[0].x, [1, 2, 0, 4])
self.assertEquals(s[1].x, [2, 0, 4, 5]) self.assertEqual(s[1].x, [2, 0, 4, 5])
self.assertEquals(s[2].x, [0, 4, 5, 6]) self.assertEqual(s[2].x, [0, 4, 5, 6])
self.assertEquals(s[3].x, [4, 5, 6, 7]) self.assertEqual(s[3].x, [4, 5, 6, 7])
# Using "$unset" with an expression like this "array.$" will result in # Using "$unset" with an expression like this "array.$" will result in
# the array item becoming None, not being removed. # the array item becoming None, not being removed.
@ -369,14 +372,14 @@ class QuerySetTest(unittest.TestCase):
Simple(x=[1, 2, 3, 4, 3, 2, 3, 4]).save() Simple(x=[1, 2, 3, 4, 3, 2, 3, 4]).save()
Simple.objects(x=3).update(unset__x__S=1) Simple.objects(x=3).update(unset__x__S=1)
simple = Simple.objects.first() simple = Simple.objects.first()
self.assertEquals(simple.x, [1, 2, None, 4, 3, 2, 3, 4]) self.assertEqual(simple.x, [1, 2, None, 4, 3, 2, 3, 4])
# Nested updates arent supported yet.. # Nested updates arent supported yet..
def update_nested(): def update_nested():
Simple.drop_collection() Simple.drop_collection()
Simple(x=[{'test': [1, 2, 3, 4]}]).save() Simple(x=[{'test': [1, 2, 3, 4]}]).save()
Simple.objects(x__test=2).update(set__x__S__test__S=3) Simple.objects(x__test=2).update(set__x__S__test__S=3)
self.assertEquals(simple.x, [1, 2, 3, 4]) self.assertEqual(simple.x, [1, 2, 3, 4])
self.assertRaises(OperationError, update_nested) self.assertRaises(OperationError, update_nested)
Simple.drop_collection() Simple.drop_collection()
@ -406,8 +409,8 @@ class QuerySetTest(unittest.TestCase):
BlogPost.objects(comments__by="joe").update(set__comments__S__votes=Vote(score=4)) BlogPost.objects(comments__by="joe").update(set__comments__S__votes=Vote(score=4))
post = BlogPost.objects.first() post = BlogPost.objects.first()
self.assertEquals(post.comments[0].by, 'joe') self.assertEqual(post.comments[0].by, 'joe')
self.assertEquals(post.comments[0].votes.score, 4) self.assertEqual(post.comments[0].votes.score, 4)
def test_mapfield_update(self): def test_mapfield_update(self):
"""Ensure that the MapField can be updated.""" """Ensure that the MapField can be updated."""
@ -561,7 +564,7 @@ class QuerySetTest(unittest.TestCase):
Blog.drop_collection() Blog.drop_collection()
blog1 = Blog(title="code", posts=[post1, post2]) blog1 = Blog(title="code", posts=[post1, post2])
obj_id = Blog.objects.insert(blog1, load_bulk=False) obj_id = Blog.objects.insert(blog1, load_bulk=False)
self.assertEquals(obj_id.__class__.__name__, 'ObjectId') self.assertEqual(obj_id.__class__.__name__, 'ObjectId')
Blog.drop_collection() Blog.drop_collection()
post3 = Post(comments=[comment1, comment1]) post3 = Post(comments=[comment1, comment1])
@ -710,20 +713,20 @@ class QuerySetTest(unittest.TestCase):
docs = Doc.objects.order_by('number') docs = Doc.objects.order_by('number')
self.assertEquals(docs.count(), 1000) self.assertEqual(docs.count(), 1000)
self.assertEquals(len(docs), 1000) self.assertEqual(len(docs), 1000)
docs_string = "%s" % docs docs_string = "%s" % docs
self.assertTrue("Doc: 0" in docs_string) self.assertTrue("Doc: 0" in docs_string)
self.assertEquals(docs.count(), 1000) self.assertEqual(docs.count(), 1000)
self.assertEquals(len(docs), 1000) self.assertEqual(len(docs), 1000)
# Limit and skip # Limit and skip
self.assertEquals('[<Doc: 1>, <Doc: 2>, <Doc: 3>]', "%s" % docs[1:4]) self.assertEqual('[<Doc: 1>, <Doc: 2>, <Doc: 3>]', "%s" % docs[1:4])
self.assertEquals(docs.count(), 3) self.assertEqual(docs.count(), 3)
self.assertEquals(len(docs), 3) self.assertEqual(len(docs), 3)
for doc in docs: for doc in docs:
self.assertEqual('.. queryset mid-iteration ..', repr(docs)) self.assertEqual('.. queryset mid-iteration ..', repr(docs))
@ -1082,27 +1085,27 @@ class QuerySetTest(unittest.TestCase):
# first three # first three
numbers = Numbers.objects.fields(slice__n=3).get() numbers = Numbers.objects.fields(slice__n=3).get()
self.assertEquals(numbers.n, [0, 1, 2]) self.assertEqual(numbers.n, [0, 1, 2])
# last three # last three
numbers = Numbers.objects.fields(slice__n=-3).get() numbers = Numbers.objects.fields(slice__n=-3).get()
self.assertEquals(numbers.n, [-3, -2, -1]) self.assertEqual(numbers.n, [-3, -2, -1])
# skip 2, limit 3 # skip 2, limit 3
numbers = Numbers.objects.fields(slice__n=[2, 3]).get() numbers = Numbers.objects.fields(slice__n=[2, 3]).get()
self.assertEquals(numbers.n, [2, 3, 4]) self.assertEqual(numbers.n, [2, 3, 4])
# skip to fifth from last, limit 4 # skip to fifth from last, limit 4
numbers = Numbers.objects.fields(slice__n=[-5, 4]).get() numbers = Numbers.objects.fields(slice__n=[-5, 4]).get()
self.assertEquals(numbers.n, [-5, -4, -3, -2]) self.assertEqual(numbers.n, [-5, -4, -3, -2])
# skip to fifth from last, limit 10 # skip to fifth from last, limit 10
numbers = Numbers.objects.fields(slice__n=[-5, 10]).get() numbers = Numbers.objects.fields(slice__n=[-5, 10]).get()
self.assertEquals(numbers.n, [-5, -4, -3, -2, -1]) self.assertEqual(numbers.n, [-5, -4, -3, -2, -1])
# skip to fifth from last, limit 10 dict method # skip to fifth from last, limit 10 dict method
numbers = Numbers.objects.fields(n={"$slice": [-5, 10]}).get() numbers = Numbers.objects.fields(n={"$slice": [-5, 10]}).get()
self.assertEquals(numbers.n, [-5, -4, -3, -2, -1]) self.assertEqual(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.
@ -1122,27 +1125,27 @@ class QuerySetTest(unittest.TestCase):
# first three # first three
numbers = Numbers.objects.fields(slice__embedded__n=3).get() numbers = Numbers.objects.fields(slice__embedded__n=3).get()
self.assertEquals(numbers.embedded.n, [0, 1, 2]) self.assertEqual(numbers.embedded.n, [0, 1, 2])
# last three # last three
numbers = Numbers.objects.fields(slice__embedded__n=-3).get() numbers = Numbers.objects.fields(slice__embedded__n=-3).get()
self.assertEquals(numbers.embedded.n, [-3, -2, -1]) self.assertEqual(numbers.embedded.n, [-3, -2, -1])
# skip 2, limit 3 # skip 2, limit 3
numbers = Numbers.objects.fields(slice__embedded__n=[2, 3]).get() numbers = Numbers.objects.fields(slice__embedded__n=[2, 3]).get()
self.assertEquals(numbers.embedded.n, [2, 3, 4]) self.assertEqual(numbers.embedded.n, [2, 3, 4])
# skip to fifth from last, limit 4 # skip to fifth from last, limit 4
numbers = Numbers.objects.fields(slice__embedded__n=[-5, 4]).get() numbers = Numbers.objects.fields(slice__embedded__n=[-5, 4]).get()
self.assertEquals(numbers.embedded.n, [-5, -4, -3, -2]) self.assertEqual(numbers.embedded.n, [-5, -4, -3, -2])
# skip to fifth from last, limit 10 # skip to fifth from last, limit 10
numbers = Numbers.objects.fields(slice__embedded__n=[-5, 10]).get() numbers = Numbers.objects.fields(slice__embedded__n=[-5, 10]).get()
self.assertEquals(numbers.embedded.n, [-5, -4, -3, -2, -1]) self.assertEqual(numbers.embedded.n, [-5, -4, -3, -2, -1])
# skip to fifth from last, limit 10 dict method # skip to fifth from last, limit 10 dict method
numbers = Numbers.objects.fields(embedded__n={"$slice": [-5, 10]}).get() numbers = Numbers.objects.fields(embedded__n={"$slice": [-5, 10]}).get()
self.assertEquals(numbers.embedded.n, [-5, -4, -3, -2, -1]) self.assertEqual(numbers.embedded.n, [-5, -4, -3, -2, -1])
def test_find_embedded(self): def test_find_embedded(self):
"""Ensure that an embedded document is properly returned from a query. """Ensure that an embedded document is properly returned from a query.
@ -1383,7 +1386,7 @@ class QuerySetTest(unittest.TestCase):
# Test template style # Test template style
code = "{{~comments.content}}" code = "{{~comments.content}}"
sub_code = BlogPost.objects._sub_js_fields(code) sub_code = BlogPost.objects._sub_js_fields(code)
self.assertEquals("cmnts.body", sub_code) self.assertEqual("cmnts.body", sub_code)
BlogPost.drop_collection() BlogPost.drop_collection()
@ -1446,13 +1449,13 @@ class QuerySetTest(unittest.TestCase):
child_child.save() child_child.save()
tree_size = 1 + num_children + (num_children * num_children) tree_size = 1 + num_children + (num_children * num_children)
self.assertEquals(tree_size, Category.objects.count()) self.assertEqual(tree_size, Category.objects.count())
self.assertEquals(num_children, Category.objects(parent=base).count()) self.assertEqual(num_children, Category.objects(parent=base).count())
# The delete should effectively wipe out the Category collection # The delete should effectively wipe out the Category collection
# without resulting in infinite parent-child cascade recursion # without resulting in infinite parent-child cascade recursion
base.delete() base.delete()
self.assertEquals(0, Category.objects.count()) self.assertEqual(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.
@ -1713,7 +1716,7 @@ class QuerySetTest(unittest.TestCase):
BlogPost.objects(slug="test-2").update_one(set__tags__0__name="python") BlogPost.objects(slug="test-2").update_one(set__tags__0__name="python")
post.reload() post.reload()
self.assertEquals(post.tags[0].name, 'python') self.assertEqual(post.tags[0].name, 'python')
BlogPost.objects(slug="test-2").update_one(pop__tags=-1) BlogPost.objects(slug="test-2").update_one(pop__tags=-1)
post.reload() post.reload()
@ -1740,7 +1743,7 @@ class QuerySetTest(unittest.TestCase):
set__authors__S=Author(name="Ross")) set__authors__S=Author(name="Ross"))
message = message.reload() message = message.reload()
self.assertEquals(message.authors[0].name, "Ross") self.assertEqual(message.authors[0].name, "Ross")
Message.objects(authors__name="Ross").update_one( Message.objects(authors__name="Ross").update_one(
set__authors=[Author(name="Harry"), set__authors=[Author(name="Harry"),
@ -1748,9 +1751,9 @@ class QuerySetTest(unittest.TestCase):
Author(name="Adam")]) Author(name="Adam")])
message = message.reload() message = message.reload()
self.assertEquals(message.authors[0].name, "Harry") self.assertEqual(message.authors[0].name, "Harry")
self.assertEquals(message.authors[1].name, "Ross") self.assertEqual(message.authors[1].name, "Ross")
self.assertEquals(message.authors[2].name, "Adam") self.assertEqual(message.authors[2].name, "Adam")
def test_order_by(self): def test_order_by(self):
"""Ensure that QuerySets may be ordered. """Ensure that QuerySets may be ordered.
@ -1830,10 +1833,10 @@ class QuerySetTest(unittest.TestCase):
results = list(results) results = list(results)
self.assertEqual(len(results), 4) self.assertEqual(len(results), 4)
music = filter(lambda r: r.key == "music", results)[0] music = list(filter(lambda r: r.key == "music", results))[0]
self.assertEqual(music.value, 2) self.assertEqual(music.value, 2)
film = filter(lambda r: r.key == "film", results)[0] film = list(filter(lambda r: r.key == "film", results))[0]
self.assertEqual(film.value, 3) self.assertEqual(film.value, 3)
BlogPost.drop_collection() BlogPost.drop_collection()
@ -2133,15 +2136,15 @@ class QuerySetTest(unittest.TestCase):
Person(name="Wilson Jr").save() Person(name="Wilson Jr").save()
freq = Person.objects.item_frequencies('city') freq = Person.objects.item_frequencies('city')
self.assertEquals(freq, {'CRB': 1.0, None: 1.0}) self.assertEqual(freq, {'CRB': 1.0, None: 1.0})
freq = Person.objects.item_frequencies('city', normalize=True) freq = Person.objects.item_frequencies('city', normalize=True)
self.assertEquals(freq, {'CRB': 0.5, None: 0.5}) self.assertEqual(freq, {'CRB': 0.5, None: 0.5})
freq = Person.objects.item_frequencies('city', map_reduce=True) freq = Person.objects.item_frequencies('city', map_reduce=True)
self.assertEquals(freq, {'CRB': 1.0, None: 1.0}) self.assertEqual(freq, {'CRB': 1.0, None: 1.0})
freq = Person.objects.item_frequencies('city', normalize=True, map_reduce=True) freq = Person.objects.item_frequencies('city', normalize=True, map_reduce=True)
self.assertEquals(freq, {'CRB': 0.5, None: 0.5}) self.assertEqual(freq, {'CRB': 0.5, None: 0.5})
def test_item_frequencies_with_null_embedded(self): def test_item_frequencies_with_null_embedded(self):
class Data(EmbeddedDocument): class Data(EmbeddedDocument):
@ -2166,10 +2169,10 @@ class QuerySetTest(unittest.TestCase):
p.save() p.save()
ot = Person.objects.item_frequencies('extra.tag', map_reduce=False) ot = Person.objects.item_frequencies('extra.tag', map_reduce=False)
self.assertEquals(ot, {None: 1.0, u'friend': 1.0}) self.assertEqual(ot, {None: 1.0, u'friend': 1.0})
ot = Person.objects.item_frequencies('extra.tag', map_reduce=True) ot = Person.objects.item_frequencies('extra.tag', map_reduce=True)
self.assertEquals(ot, {None: 1.0, u'friend': 1.0}) self.assertEqual(ot, {None: 1.0, u'friend': 1.0})
def test_item_frequencies_with_0_values(self): def test_item_frequencies_with_0_values(self):
class Test(Document): class Test(Document):
@ -2181,9 +2184,9 @@ class QuerySetTest(unittest.TestCase):
t.save() t.save()
ot = Test.objects.item_frequencies('val', map_reduce=True) ot = Test.objects.item_frequencies('val', map_reduce=True)
self.assertEquals(ot, {0: 1}) self.assertEqual(ot, {0: 1})
ot = Test.objects.item_frequencies('val', map_reduce=False) ot = Test.objects.item_frequencies('val', map_reduce=False)
self.assertEquals(ot, {0: 1}) self.assertEqual(ot, {0: 1})
def test_item_frequencies_with_False_values(self): def test_item_frequencies_with_False_values(self):
class Test(Document): class Test(Document):
@ -2195,9 +2198,9 @@ class QuerySetTest(unittest.TestCase):
t.save() t.save()
ot = Test.objects.item_frequencies('val', map_reduce=True) ot = Test.objects.item_frequencies('val', map_reduce=True)
self.assertEquals(ot, {False: 1}) self.assertEqual(ot, {False: 1})
ot = Test.objects.item_frequencies('val', map_reduce=False) ot = Test.objects.item_frequencies('val', map_reduce=False)
self.assertEquals(ot, {False: 1}) self.assertEqual(ot, {False: 1})
def test_item_frequencies_normalize(self): def test_item_frequencies_normalize(self):
class Test(Document): class Test(Document):
@ -2212,10 +2215,10 @@ class QuerySetTest(unittest.TestCase):
Test(val=2).save() Test(val=2).save()
freqs = Test.objects.item_frequencies('val', map_reduce=False, normalize=True) freqs = Test.objects.item_frequencies('val', map_reduce=False, normalize=True)
self.assertEquals(freqs, {1: 50.0/70, 2: 20.0/70}) self.assertEqual(freqs, {1: 50.0/70, 2: 20.0/70})
freqs = Test.objects.item_frequencies('val', map_reduce=True, normalize=True) freqs = Test.objects.item_frequencies('val', map_reduce=True, normalize=True)
self.assertEquals(freqs, {1: 50.0/70, 2: 20.0/70}) self.assertEqual(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.
@ -2275,7 +2278,7 @@ class QuerySetTest(unittest.TestCase):
foo = Foo(bar=bar) foo = Foo(bar=bar)
foo.save() foo.save()
self.assertEquals(Foo.objects.distinct("bar"), [bar]) self.assertEqual(Foo.objects.distinct("bar"), [bar])
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.
@ -2735,8 +2738,8 @@ class QuerySetTest(unittest.TestCase):
Post().save() Post().save()
Post(is_published=True).save() Post(is_published=True).save()
self.assertEquals(Post.objects.count(), 2) self.assertEqual(Post.objects.count(), 2)
self.assertEquals(Post.published.count(), 1) self.assertEqual(Post.published.count(), 1)
Post.drop_collection() Post.drop_collection()
@ -2902,10 +2905,10 @@ class QuerySetTest(unittest.TestCase):
Number(n=3).save() Number(n=3).save()
numbers = [n.n for n in Number.objects.order_by('-n')] numbers = [n.n for n in Number.objects.order_by('-n')]
self.assertEquals([3, 2, 1], numbers) self.assertEqual([3, 2, 1], numbers)
numbers = [n.n for n in Number.objects.order_by('+n')] numbers = [n.n for n in Number.objects.order_by('+n')]
self.assertEquals([1, 2, 3], numbers) self.assertEqual([1, 2, 3], numbers)
Number.drop_collection() Number.drop_collection()
@ -3227,15 +3230,22 @@ class QuerySetTest(unittest.TestCase):
self.assertEqual(len(self.Person.objects.scalar('name')), 55) self.assertEqual(len(self.Person.objects.scalar('name')), 55)
self.assertEqual("A0", "%s" % self.Person.objects.order_by('name').scalar('name').first()) self.assertEqual("A0", "%s" % self.Person.objects.order_by('name').scalar('name').first())
self.assertEqual("A0", "%s" % self.Person.objects.scalar('name').order_by('name')[0]) self.assertEqual("A0", "%s" % self.Person.objects.scalar('name').order_by('name')[0])
self.assertEqual("[u'A1', u'A2']", "%s" % self.Person.objects.order_by('age').scalar('name')[1:3]) if PY3:
self.assertEqual("[u'A51', u'A52']", "%s" % self.Person.objects.order_by('age').scalar('name')[51:53]) self.assertEqual("['A1', 'A2']", "%s" % self.Person.objects.order_by('age').scalar('name')[1:3])
self.assertEqual("['A51', 'A52']", "%s" % self.Person.objects.order_by('age').scalar('name')[51:53])
else:
self.assertEqual("[u'A1', u'A2']", "%s" % self.Person.objects.order_by('age').scalar('name')[1:3])
self.assertEqual("[u'A51', u'A52']", "%s" % self.Person.objects.order_by('age').scalar('name')[51:53])
# with_id and in_bulk # with_id and in_bulk
person = self.Person.objects.order_by('name').first() person = self.Person.objects.order_by('name').first()
self.assertEqual("A0", "%s" % self.Person.objects.scalar('name').with_id(person.id)) self.assertEqual("A0", "%s" % self.Person.objects.scalar('name').with_id(person.id))
pks = self.Person.objects.order_by('age').scalar('pk')[1:3] pks = self.Person.objects.order_by('age').scalar('pk')[1:3]
self.assertEqual("[u'A1', u'A2']", "%s" % sorted(self.Person.objects.scalar('name').in_bulk(list(pks)).values())) if PY3:
self.assertEqual("['A1', 'A2']", "%s" % sorted(self.Person.objects.scalar('name').in_bulk(list(pks)).values()))
else:
self.assertEqual("[u'A1', u'A2']", "%s" % sorted(self.Person.objects.scalar('name').in_bulk(list(pks)).values()))
class QTest(unittest.TestCase): class QTest(unittest.TestCase):

3
tests/test_replicaset_connection.py
View File

@ -1,4 +1,5 @@
import unittest import unittest
import pymongo import pymongo
from pymongo import ReadPreference, ReplicaSetConnection from pymongo import ReadPreference, ReplicaSetConnection
@ -26,7 +27,7 @@ class ConnectionTest(unittest.TestCase):
if not isinstance(conn, ReplicaSetConnection): if not isinstance(conn, ReplicaSetConnection):
return return
self.assertEquals(conn.read_preference, ReadPreference.SECONDARY_ONLY) self.assertEqual(conn.read_preference, ReadPreference.SECONDARY_ONLY)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

4
tests/test_signals.py
View File

@ -212,9 +212,9 @@ class SignalTests(unittest.TestCase):
# The output of this signal is not entirely deterministic. The reloaded # The output of this signal is not entirely deterministic. The reloaded
# object will have an object ID. Hence, we only check part of the output # object will have an object ID. Hence, we only check part of the output
self.assertEquals(signal_output[3], self.assertEqual(signal_output[3],
"pre_bulk_insert signal, [<Author: Bill Shakespeare>]") "pre_bulk_insert signal, [<Author: Bill Shakespeare>]")
self.assertEquals(signal_output[-2:], self.assertEqual(signal_output[-2:],
["post_bulk_insert signal, [<Author: Bill Shakespeare>]", ["post_bulk_insert signal, [<Author: Bill Shakespeare>]",
"Is loaded",]) "Is loaded",])