From 91aa90ad4aa96c912b1a5f6fe5d77a5930978db6 Mon Sep 17 00:00:00 2001 From: Laine Date: Wed, 1 Aug 2012 17:21:48 -0700 Subject: [PATCH] Added Python 3 support to MongoEngine --- mongoengine/base.py | 47 +++- mongoengine/django/shortcuts.py | 3 +- mongoengine/django/tests.py | 22 +- mongoengine/document.py | 32 ++- mongoengine/fields.py | 41 +-- mongoengine/python3_support.py | 29 +++ mongoengine/queryset.py | 8 +- setup.cfg | 4 +- setup.py | 30 ++- tests/test_dereference.py | 28 +- tests/test_django.py | 32 ++- tests/test_document.py | 387 ++++++++++++++-------------- tests/test_dynamic_document.py | 178 ++++++------- tests/test_fields.py | 210 +++++++-------- tests/test_queryset.py | 150 ++++++----- tests/test_replicaset_connection.py | 3 +- tests/test_signals.py | 4 +- 17 files changed, 673 insertions(+), 535 deletions(-) create mode 100644 mongoengine/python3_support.py diff --git a/mongoengine/base.py b/mongoengine/base.py index 6fb26cb7..d4a7b324 100644 --- a/mongoengine/base.py +++ b/mongoengine/base.py @@ -1,18 +1,19 @@ +import operator +import sys import warnings + from collections import defaultdict +from functools import partial from queryset import QuerySet, QuerySetManager from queryset import DoesNotExist, MultipleObjectsReturned from queryset import DO_NOTHING from mongoengine import signals +from mongoengine.python3_support import PY3, txt_type -import sys import pymongo from bson import ObjectId -import operator - -from functools import partial from bson.dbref import DBRef @@ -402,7 +403,7 @@ class ComplexBaseField(BaseField): """ errors = {} if self.field: - if hasattr(value, 'iteritems'): + if hasattr(value, 'iteritems') or hasattr(value, 'items'): sequence = value.iteritems() else: sequence = enumerate(value) @@ -491,7 +492,7 @@ class DocumentMetaclass(type): attrs.update(_get_mixin_fields(p_base)) return attrs - metaclass = attrs.get('__metaclass__') + metaclass = attrs.get('my_metaclass') super_new = super(DocumentMetaclass, cls).__new__ if metaclass and issubclass(metaclass, DocumentMetaclass): 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) 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) module = attrs.get('__module__') @@ -602,6 +605,22 @@ class DocumentMetaclass(type): global _document_registry _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 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 # 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))): # Make sure no base class was non-abstract 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): try: - u = unicode(self).encode('utf-8') + u = txt_type(self) except (UnicodeEncodeError, UnicodeDecodeError): u = '[Bad Unicode data]' return '<%s: %s>' % (self.__class__.__name__, u) def __str__(self): 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__ def __eq__(self, other): @@ -1338,10 +1360,9 @@ class BaseDict(dict): if sys.version_info < (2, 5): # Prior to Python 2.5, Exception was an old-style class - import types def subclass_exception(name, parents, unused): - import types - return types.ClassType(name, parents, {}) + from types import ClassType + return ClassType(name, parents, {}) else: def subclass_exception(name, parents, module): return type(name, parents, {'__module__': module}) diff --git a/mongoengine/django/shortcuts.py b/mongoengine/django/shortcuts.py index 59a20741..637cee15 100644 --- a/mongoengine/django/shortcuts.py +++ b/mongoengine/django/shortcuts.py @@ -1,4 +1,3 @@ -from django.http import Http404 from mongoengine.queryset import QuerySet from mongoengine.base import BaseDocument from mongoengine.base import ValidationError @@ -27,6 +26,7 @@ def get_document_or_404(cls, *args, **kwargs): try: return queryset.get(*args, **kwargs) except (queryset._document.DoesNotExist, ValidationError): + from django.http import Http404 raise Http404('No %s matches the given query.' % queryset._document._class_name) def get_list_or_404(cls, *args, **kwargs): @@ -42,5 +42,6 @@ def get_list_or_404(cls, *args, **kwargs): queryset = _get_queryset(cls) obj_list = list(queryset.filter(*args, **kwargs)) if not obj_list: + from django.http import Http404 raise Http404('No %s matches the given query.' % queryset._document._class_name) return obj_list diff --git a/mongoengine/django/tests.py b/mongoengine/django/tests.py index e91abeb3..566a3984 100644 --- a/mongoengine/django/tests.py +++ b/mongoengine/django/tests.py @@ -1,10 +1,28 @@ #coding: utf-8 -from django.test import TestCase -from django.conf import settings +from nose.plugins.skip import SkipTest +from mongoengine.python3_support import PY3 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): + + def setUp(self): + if PY3: + raise SkipTest('django does not have Python 3 support') + """ TestCase class that clear the collection between the tests """ diff --git a/mongoengine/document.py b/mongoengine/document.py index f8bf769d..35e58d73 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -2,7 +2,7 @@ import pymongo from bson.dbref import DBRef -from mongoengine import signals +from mongoengine import signals, queryset from base import (DocumentMetaclass, TopLevelDocumentMetaclass, BaseDocument, BaseDict, BaseList) from queryset import OperationError @@ -23,6 +23,9 @@ class EmbeddedDocument(BaseDocument): :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 def __init__(self, *args, **kwargs): @@ -91,9 +94,12 @@ class Document(BaseDocument): 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. """ + + # 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 - @apply def pk(): """Primary key alias """ @@ -102,6 +108,7 @@ class Document(BaseDocument): def fset(self, value): return setattr(self, self._meta['id_field'], value) return property(fget, fset) + pk = pk() @classmethod def _get_db(cls): @@ -244,12 +251,11 @@ class Document(BaseDocument): def cascade_save(self, *args, **kwargs): """Recursively saves any references / generic references on an object""" - from fields import ReferenceField, GenericReferenceField + import fields _refs = kwargs.get('_refs', []) or [] for name, cls in self._fields.items(): - - if not isinstance(cls, (ReferenceField, GenericReferenceField)): + if not isinstance(cls, (fields.ReferenceField, fields.GenericReferenceField)): continue ref = getattr(self, name) @@ -304,8 +310,8 @@ class Document(BaseDocument): .. versionadded:: 0.5 """ - from dereference import DeReference - self._data = DeReference()(self._data, max_depth) + import dereference + self._data = dereference.DeReference()(self._data, max_depth) return self def reload(self, max_depth=1): @@ -360,10 +366,9 @@ class Document(BaseDocument): """Drops the entire collection associated with this :class:`~mongoengine.Document` type from the database. """ - from mongoengine.queryset import QuerySet db = cls._get_db() db.drop_collection(cls._get_collection_name()) - QuerySet._reset_already_indexed(cls) + queryset.QuerySet._reset_already_indexed(cls) class DynamicDocument(Document): @@ -379,7 +384,12 @@ class DynamicDocument(Document): 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 + _dynamic = True def __delattr__(self, *args, **kwargs): @@ -398,7 +408,11 @@ class DynamicEmbeddedDocument(EmbeddedDocument): 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 + _dynamic = True def __delattr__(self, *args, **kwargs): diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 82689929..a2947c18 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1,18 +1,23 @@ import datetime -import time import decimal -import gridfs import re +import sys +import time import uuid import warnings +from operator import itemgetter + +import gridfs 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, ValidationError, get_document, BaseDocument) from queryset import DO_NOTHING, QuerySet from document import Document, EmbeddedDocument from connection import get_db, DEFAULT_CONNECTION_NAME -from operator import itemgetter try: @@ -21,12 +26,6 @@ except ImportError: Image = None ImageOps = None -try: - from cStringIO import StringIO -except ImportError: - from StringIO import StringIO - - __all__ = ['StringField', 'IntField', 'FloatField', 'BooleanField', 'DateTimeField', 'EmbeddedDocumentField', 'ListField', 'DictField', 'ObjectIdField', 'ReferenceField', 'ValidationError', 'MapField', @@ -846,8 +845,9 @@ class BinaryField(BaseField): return Binary(value) def validate(self, value): - if not isinstance(value, (basestring, Binary)): - self.error('BinaryField only accepts string or bson Binary values') + if not isinstance(value, (bin_type, txt_type, Binary)): + 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: self.error('Binary value is too long') @@ -903,12 +903,14 @@ class GridFSProxy(object): def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.grid_id) - def __cmp__(self, other): - if not isinstance(other, GridFSProxy): - return -1 - return cmp((self.grid_id, self.collection_name, self.db_alias), - (other.grid_id, other.collection_name, other.db_alias)) - + def __eq__(self, other): + if isinstance(other, GridFSProxy): + return ((self.grid_id == other.grid_id) and + (self.collection_name == other.collection_name) and + (self.db_alias == other.db_alias)) + else: + return False + @property def fs(self): if not self._fs: @@ -1020,7 +1022,8 @@ class FileField(BaseField): def __set__(self, instance, value): 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 grid_file = instance._data.get(self.name) # If a file already exists, delete it @@ -1211,7 +1214,7 @@ class ImageField(FileField): for att_name, att in extra_args.items(): if att and (isinstance(att, tuple) or isinstance(att, list)): setattr(self, att_name, dict( - map(None, params_size, att))) + zip(params_size, att))) else: setattr(self, att_name, None) diff --git a/mongoengine/python3_support.py b/mongoengine/python3_support.py new file mode 100644 index 00000000..0682d873 --- /dev/null +++ b/mongoengine/python3_support.py @@ -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) diff --git a/mongoengine/queryset.py b/mongoengine/queryset.py index b7453c6a..1067e32e 100644 --- a/mongoengine/queryset.py +++ b/mongoengine/queryset.py @@ -3,7 +3,7 @@ import re import copy import itertools import operator - +import functools from functools import partial import pymongo @@ -121,12 +121,12 @@ class QueryTreeTransformerVisitor(QNodeVisitor): # that ANDs the necessary part with the $or part. clauses = [] for or_group in itertools.product(*or_groups): - q_object = 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, and_parts, Q()) + q_object = functools.reduce(lambda a, b: a & b, or_group, q_object) clauses.append(q_object) # Finally, $or the generated clauses in to one query. Each of the # 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: children = [] diff --git a/setup.cfg b/setup.cfg index 51a18682..ad9b9289 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,6 +1,3 @@ -[aliases] -test = nosetests - [nosetests] verbosity = 2 detailed-errors = 1 @@ -10,4 +7,5 @@ detailed-errors = 1 #cover-html-dir = ../htmlcov #cover-package = mongoengine where = tests +py3where = build #tests = test_bugfix.py diff --git a/setup.py b/setup.py index 20f3ea38..5f59b1a4 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,12 @@ from setuptools import setup, find_packages 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" @@ -19,9 +26,10 @@ def get_version(version_tuple): # import it as it depends on PyMongo and PyMongo isn't installed until this # file is read 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])) -print VERSION +print(VERSION) CLASSIFIERS = [ 'Development Status :: 4 - Beta', @@ -29,13 +37,26 @@ CLASSIFIERS = [ 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', + "Programming Language :: Python :: 2", + "Programming Language :: Python :: 3", 'Topic :: Database', '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', version=VERSION, - packages=find_packages(exclude=('tests',)), author='Harry Marr', author_email='harry.marr@{nospam}gmail.com', maintainer="Ross Lawley", @@ -48,5 +69,6 @@ setup(name='mongoengine', platforms=['any'], classifiers=CLASSIFIERS, install_requires=['pymongo'], - tests_require=['nose', 'coverage', 'blinker', 'django>=1.3', 'PIL'] + test_suite='nose.collector', + **extra_opts ) diff --git a/tests/test_dereference.py b/tests/test_dereference.py index 826d4aa7..75daf6a8 100644 --- a/tests/test_dereference.py +++ b/tests/test_dereference.py @@ -109,10 +109,10 @@ class FieldTest(unittest.TestCase): peter = Employee.objects.with_id(peter.id).select_related() self.assertEqual(q, 2) - self.assertEquals(peter.boss, bill) + self.assertEqual(peter.boss, bill) self.assertEqual(q, 2) - self.assertEquals(peter.friends, friends) + self.assertEqual(peter.friends, friends) self.assertEqual(q, 2) # Queryset select_related @@ -123,10 +123,10 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for employee in employees: - self.assertEquals(employee.boss, bill) + self.assertEqual(employee.boss, bill) self.assertEqual(q, 2) - self.assertEquals(employee.friends, friends) + self.assertEqual(employee.friends, friends) self.assertEqual(q, 2) def test_circular_reference(self): @@ -160,7 +160,7 @@ class FieldTest(unittest.TestCase): daughter.relations.append(self_rel) daughter.save() - self.assertEquals("[, ]", "%s" % Person.objects()) + self.assertEqual("[, ]", "%s" % Person.objects()) def test_circular_reference_on_self(self): """Ensure you can handle circular references @@ -186,7 +186,7 @@ class FieldTest(unittest.TestCase): daughter.relations.append(daughter) daughter.save() - self.assertEquals("[, ]", "%s" % Person.objects()) + self.assertEqual("[, ]", "%s" % Person.objects()) def test_circular_tree_reference(self): """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.save() - self.assertEquals( + self.assertEqual( "[, , , ]", "%s" % Person.objects() ) @@ -781,8 +781,8 @@ class FieldTest(unittest.TestCase): root.save() root = root.reload() - self.assertEquals(root.children, [company]) - self.assertEquals(company.parents, [root]) + self.assertEqual(root.children, [company]) + self.assertEqual(company.parents, [root]) def test_dict_in_dbref_instance(self): @@ -808,8 +808,8 @@ class FieldTest(unittest.TestCase): room_101.save() room = Room.objects.first().select_related() - self.assertEquals(room.staffs_with_position[0]['staff'], sarah) - self.assertEquals(room.staffs_with_position[1]['staff'], bob) + self.assertEqual(room.staffs_with_position[0]['staff'], sarah) + self.assertEqual(room.staffs_with_position[1]['staff'], bob) def test_document_reload_no_inheritance(self): class Foo(Document): @@ -839,8 +839,8 @@ class FieldTest(unittest.TestCase): foo.save() foo.reload() - self.assertEquals(type(foo.bar), Bar) - self.assertEquals(type(foo.baz), Baz) + self.assertEqual(type(foo.bar), Bar) + self.assertEqual(type(foo.baz), Baz) def test_list_lookup_not_checked_in_map(self): """Ensure we dereference list data correctly @@ -862,4 +862,4 @@ class FieldTest(unittest.TestCase): msg = Message.objects.get(id=1) self.assertEqual(0, msg.comments[0].id) - self.assertEqual(1, msg.comments[1].id) \ No newline at end of file + self.assertEqual(1, msg.comments[1].id) diff --git a/tests/test_django.py b/tests/test_django.py index f5e96249..ed21f275 100644 --- a/tests/test_django.py +++ b/tests/test_django.py @@ -1,24 +1,34 @@ # -*- coding: utf-8 -*- - import unittest - +from nose.plugins.skip import SkipTest +from mongoengine.python3_support import PY3 from mongoengine import * -from mongoengine.django.shortcuts import get_document_or_404 -from django.http import Http404 -from django.template import Context, Template -from django.conf import settings -from django.core.paginator import Paginator +try: + from mongoengine.django.shortcuts import get_document_or_404 -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 -from mongoengine.django.sessions import SessionStore, MongoSession + settings.configure() + + 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): def setUp(self): + if PY3: + raise SkipTest('django does not have Python 3 support') connect(db='mongoenginetest') class Person(Document): @@ -99,6 +109,8 @@ class MongoDBSessionTest(SessionTestsMixin, unittest.TestCase): backend = SessionStore def setUp(self): + if PY3: + raise SkipTest('django does not have Python 3 support') connect(db='mongoenginetest') MongoSession.drop_collection() super(MongoDBSessionTest, self).setUp() diff --git a/tests/test_document.py b/tests/test_document.py index 6915caff..8eaaceef 100644 --- a/tests/test_document.py +++ b/tests/test_document.py @@ -38,7 +38,7 @@ class DocumentTest(unittest.TestCase): """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): a = IntField() @@ -47,10 +47,10 @@ class DocumentTest(unittest.TestCase): b = IntField() InheritedClass() - self.assertEquals(len(errors), 1) + self.assertEqual(len(errors), 1) warning = errors[0] - self.assertEquals(FutureWarning, warning.category) - self.assertTrue("InheritedClass" in warning.message.message) + self.assertEqual(FutureWarning, warning.category) + self.assertTrue("InheritedClass" in str(warning.message)) def test_drop_collection(self): """Ensure that the collection may be dropped from the database. @@ -105,16 +105,16 @@ class DocumentTest(unittest.TestCase): class DefaultNamingTest(Document): pass - self.assertEquals('default_naming_test', DefaultNamingTest._get_collection_name()) + self.assertEqual('default_naming_test', DefaultNamingTest._get_collection_name()) class CustomNamingTest(Document): 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): 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 class BaseDocument(Document): @@ -125,11 +125,11 @@ class DocumentTest(unittest.TestCase): class OldNamingConvention(BaseDocument): pass - self.assertEquals('oldnamingconvention', OldNamingConvention._get_collection_name()) + self.assertEqual('oldnamingconvention', OldNamingConvention._get_collection_name()) class InheritedAbstractNamingTest(BaseDocument): 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: # Cause all warnings to always be triggered. @@ -142,7 +142,7 @@ class DocumentTest(unittest.TestCase): meta = {'collection': 'fail'} 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 class BaseMixin(object): @@ -152,7 +152,7 @@ class DocumentTest(unittest.TestCase): class OldMixinNamingConvention(Document, BaseMixin): pass - self.assertEquals('oldmixinnamingconvention', OldMixinNamingConvention._get_collection_name()) + self.assertEqual('oldmixinnamingconvention', OldMixinNamingConvention._get_collection_name()) class BaseMixin(object): meta = { @@ -165,7 +165,7 @@ class DocumentTest(unittest.TestCase): class MyDocument(BaseDocument): pass - self.assertEquals('basedocument', MyDocument._get_collection_name()) + self.assertEqual('basedocument', MyDocument._get_collection_name()) def test_get_superclasses(self): """Ensure that the correct list of superclasses is assembled. @@ -212,10 +212,10 @@ class DocumentTest(unittest.TestCase): h = Human() h.save() - self.assertEquals(Human.objects.count(), 1) - self.assertEquals(Mammal.objects.count(), 1) - self.assertEquals(Animal.objects.count(), 1) - self.assertEquals(Base.objects.count(), 1) + self.assertEqual(Human.objects.count(), 1) + self.assertEqual(Mammal.objects.count(), 1) + self.assertEqual(Animal.objects.count(), 1) + self.assertEqual(Base.objects.count(), 1) Base.drop_collection() def test_polymorphic_queries(self): @@ -427,7 +427,7 @@ class DocumentTest(unittest.TestCase): info = collection.index_information() 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 class Animal(Document): @@ -445,7 +445,7 @@ class DocumentTest(unittest.TestCase): info = collection.index_information() 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() 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 = [value['key'] for key, value in info.iteritems()] - self.assertEquals([[(u'_id', 1)]], info) + self.assertEqual([[(u'_id', 1)]], info) # Recreate indexes dog = Animal.objects.first() dog.save() info = collection.index_information() 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() @@ -681,8 +681,8 @@ class DocumentTest(unittest.TestCase): Person(name="Fred").save() - self.assertEquals(Person.objects.get(name="Jack").rank, "Corporal") - self.assertEquals(Person.objects.get(name="Fred").rank, "Private") + self.assertEqual(Person.objects.get(name="Jack").rank, "Corporal") + self.assertEqual(Person.objects.get(name="Fred").rank, "Private") def test_db_embedded_doc_field_load(self): """Ensure we load embedded document data correctly @@ -704,8 +704,8 @@ class DocumentTest(unittest.TestCase): Person(name="Fred").save() - self.assertEquals(Person.objects.get(name="Jack").rank, "Corporal") - self.assertEquals(Person.objects.get(name="Fred").rank, "Private") + self.assertEqual(Person.objects.get(name="Jack").rank, "Corporal") + self.assertEqual(Person.objects.get(name="Fred").rank, "Private") def test_explicit_geo2d_index(self): """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.save() - self.assertEquals(1, Person.objects.count()) + self.assertEqual(1, Person.objects.count()) info = Person.objects._collection.index_information() self.assertEqual(info.keys(), ['_types_1_user_guid_1', '_id_', '_types_1_name_1']) Person.drop_collection() @@ -804,7 +804,7 @@ class DocumentTest(unittest.TestCase): u = User(user_guid='123') u.save() - self.assertEquals(1, User.objects.count()) + self.assertEqual(1, User.objects.count()) info = User.objects._collection.index_information() self.assertEqual(info.keys(), ['_id_']) User.drop_collection() @@ -890,8 +890,8 @@ class DocumentTest(unittest.TestCase): self.assertFalse('location_2d' in info) - self.assertEquals(len(Parent._geo_indices()), 0) - self.assertEquals(len(Location._geo_indices()), 1) + self.assertEqual(len(Parent._geo_indices()), 0) + self.assertEqual(len(Location._geo_indices()), 1) def test_covered_index(self): """Ensure that covered indexes can be used @@ -938,7 +938,7 @@ class DocumentTest(unittest.TestCase): BlogPost.drop_collection() 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)]) def test_hint(self): @@ -957,11 +957,11 @@ class DocumentTest(unittest.TestCase): tags = [("tag %i" % n) for n in xrange(0, i % 2)] BlogPost(tags=tags).save() - self.assertEquals(BlogPost.objects.count(), 10) - self.assertEquals(BlogPost.objects.hint().count(), 10) - self.assertEquals(BlogPost.objects.hint([('tags', 1)]).count(), 10) + self.assertEqual(BlogPost.objects.count(), 10) + self.assertEqual(BlogPost.objects.hint().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(): BlogPost.objects.hint('tags') @@ -1255,32 +1255,32 @@ class DocumentTest(unittest.TestCase): doc.embedded_field.list_field.append(1) 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', 'embedded_field.dict_field']) doc.save() doc = doc.reload(10) - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(len(doc.list_field), 4) - self.assertEquals(len(doc.dict_field), 2) - self.assertEquals(len(doc.embedded_field.list_field), 4) - self.assertEquals(len(doc.embedded_field.dict_field), 2) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(len(doc.list_field), 4) + self.assertEqual(len(doc.dict_field), 2) + self.assertEqual(len(doc.embedded_field.list_field), 4) + self.assertEqual(len(doc.embedded_field.dict_field), 2) def test_dictionary_access(self): """Ensure that dictionary-style field access works properly. """ 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.__setitem__, 'salary', 50) person['name'] = 'Another User' - self.assertEquals(person['name'], 'Another User') + self.assertEqual(person['name'], 'Another User') # Length = length(assigned fields + id) - self.assertEquals(len(person), 3) + self.assertEqual(len(person), 3) self.assertTrue('age' in person) person.age = None @@ -1330,7 +1330,7 @@ class DocumentTest(unittest.TestCase): doc = Doc.objects.first() doc.validate() - self.assertEquals([None, 'e'], doc._data.keys()) + self.assertEqual([None, 'e'], doc._data.keys()) def test_save(self): """Ensure that a document may be saved in the database. @@ -1373,7 +1373,7 @@ class DocumentTest(unittest.TestCase): user.save() user.reload() - self.assertEquals(user.thing.count, 0) + self.assertEqual(user.thing.count, 0) def test_save_max_recursion_not_hit(self): @@ -1414,16 +1414,17 @@ class DocumentTest(unittest.TestCase): a.save() a.bar = a - a.picture = open(TEST_IMAGE_PATH, 'rb') - a.save() + with open(TEST_IMAGE_PATH, 'rb') as test_image: + a.picture = test_image + a.save() - # Confirm can save and it resets the changed fields without hitting - # max recursion error - b = Foo.objects.with_id(a.id) - b.name='world' - b.save() + # Confirm can save and it resets the changed fields without hitting + # max recursion error + b = Foo.objects.with_id(a.id) + b.name='world' + 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): @@ -1446,7 +1447,7 @@ class DocumentTest(unittest.TestCase): p.save() p1.reload() - self.assertEquals(p1.name, p.parent.name) + self.assertEqual(p1.name, p.parent.name) def test_save_cascade_kwargs(self): @@ -1469,7 +1470,7 @@ class DocumentTest(unittest.TestCase): p.save() p1.reload() - self.assertEquals(p1.name, p.parent.name) + self.assertEqual(p1.name, p.parent.name) def test_save_cascade_meta(self): @@ -1494,11 +1495,11 @@ class DocumentTest(unittest.TestCase): p.save() p1.reload() - self.assertNotEquals(p1.name, p.parent.name) + self.assertNotEqual(p1.name, p.parent.name) p.save(cascade=True) p1.reload() - self.assertEquals(p1.name, p.parent.name) + self.assertEqual(p1.name, p.parent.name) def test_save_cascades_generically(self): @@ -1520,7 +1521,7 @@ class DocumentTest(unittest.TestCase): p.save() p1.reload() - self.assertEquals(p1.name, p.parent.name) + self.assertEqual(p1.name, p.parent.name) def test_update(self): """Ensure that an existing document is updated instead of be overwritten. @@ -1535,7 +1536,7 @@ class DocumentTest(unittest.TestCase): same_person.save() # Confirm only one object - self.assertEquals(self.Person.objects.count(), 1) + self.assertEqual(self.Person.objects.count(), 1) # reload person.reload() @@ -1621,7 +1622,7 @@ class DocumentTest(unittest.TestCase): author.reload() p1 = self.Person.objects.first() - self.assertEquals(p1.name, author.name) + self.assertEqual(p1.name, author.name) def update_no_value_raises(): person = self.Person.objects.first() @@ -1714,8 +1715,8 @@ class DocumentTest(unittest.TestCase): p = Person.objects[0].select_related() o = Organization.objects.first() - self.assertEquals(p.owns[0], o) - self.assertEquals(o.owner, p) + self.assertEqual(p.owns[0], o) + self.assertEqual(o.owner, p) def test_circular_reference_deltas_2(self): @@ -1755,9 +1756,9 @@ class DocumentTest(unittest.TestCase): e = Person.objects.get(name="employee") o = Organization.objects.first() - self.assertEquals(p.owns[0], o) - self.assertEquals(o.owner, p) - self.assertEquals(e.employer, o) + self.assertEqual(p.owns[0], o) + self.assertEqual(o.owner, p) + self.assertEqual(e.employer, o) def test_delta(self): @@ -1772,40 +1773,40 @@ class DocumentTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(doc._delta(), ({}, {})) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._delta(), ({}, {})) doc.string_field = 'hello' - self.assertEquals(doc._get_changed_fields(), ['string_field']) - self.assertEquals(doc._delta(), ({'string_field': 'hello'}, {})) + self.assertEqual(doc._get_changed_fields(), ['string_field']) + self.assertEqual(doc._delta(), ({'string_field': 'hello'}, {})) doc._changed_fields = [] doc.int_field = 1 - self.assertEquals(doc._get_changed_fields(), ['int_field']) - self.assertEquals(doc._delta(), ({'int_field': 1}, {})) + self.assertEqual(doc._get_changed_fields(), ['int_field']) + self.assertEqual(doc._delta(), ({'int_field': 1}, {})) doc._changed_fields = [] dict_value = {'hello': 'world', 'ping': 'pong'} doc.dict_field = dict_value - self.assertEquals(doc._get_changed_fields(), ['dict_field']) - self.assertEquals(doc._delta(), ({'dict_field': dict_value}, {})) + self.assertEqual(doc._get_changed_fields(), ['dict_field']) + self.assertEqual(doc._delta(), ({'dict_field': dict_value}, {})) doc._changed_fields = [] list_value = ['1', 2, {'hello': 'world'}] doc.list_field = list_value - self.assertEquals(doc._get_changed_fields(), ['list_field']) - self.assertEquals(doc._delta(), ({'list_field': list_value}, {})) + self.assertEqual(doc._get_changed_fields(), ['list_field']) + self.assertEqual(doc._delta(), ({'list_field': list_value}, {})) # Test unsetting doc._changed_fields = [] doc.dict_field = {} - self.assertEquals(doc._get_changed_fields(), ['dict_field']) - self.assertEquals(doc._delta(), ({}, {'dict_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['dict_field']) + self.assertEqual(doc._delta(), ({}, {'dict_field': 1})) doc._changed_fields = [] doc.list_field = [] - self.assertEquals(doc._get_changed_fields(), ['list_field']) - self.assertEquals(doc._delta(), ({}, {'list_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['list_field']) + self.assertEqual(doc._delta(), ({}, {'list_field': 1})) def test_delta_recursive(self): @@ -1827,8 +1828,8 @@ class DocumentTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(doc._delta(), ({}, {})) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._delta(), ({}, {})) embedded_1 = Embedded() embedded_1.string_field = 'hello' @@ -1837,7 +1838,7 @@ class DocumentTest(unittest.TestCase): embedded_1.list_field = ['1', 2, {'hello': 'world'}] doc.embedded_field = embedded_1 - self.assertEquals(doc._get_changed_fields(), ['embedded_field']) + self.assertEqual(doc._get_changed_fields(), ['embedded_field']) embedded_delta = { 'string_field': 'hello', @@ -1845,31 +1846,31 @@ class DocumentTest(unittest.TestCase): 'dict_field': {'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({ '_types': ['Embedded'], '_cls': 'Embedded', }) - self.assertEquals(doc._delta(), ({'embedded_field': embedded_delta}, {})) + self.assertEqual(doc._delta(), ({'embedded_field': embedded_delta}, {})) doc.save() doc = doc.reload(10) doc.embedded_field.dict_field = {} - self.assertEquals(doc._get_changed_fields(), ['embedded_field.dict_field']) - self.assertEquals(doc.embedded_field._delta(), ({}, {'dict_field': 1})) - self.assertEquals(doc._delta(), ({}, {'embedded_field.dict_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['embedded_field.dict_field']) + self.assertEqual(doc.embedded_field._delta(), ({}, {'dict_field': 1})) + self.assertEqual(doc._delta(), ({}, {'embedded_field.dict_field': 1})) doc.save() doc = doc.reload(10) - self.assertEquals(doc.embedded_field.dict_field, {}) + self.assertEqual(doc.embedded_field.dict_field, {}) doc.embedded_field.list_field = [] - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) - self.assertEquals(doc.embedded_field._delta(), ({}, {'list_field': 1})) - self.assertEquals(doc._delta(), ({}, {'embedded_field.list_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field']) + self.assertEqual(doc.embedded_field._delta(), ({}, {'list_field': 1})) + self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field': 1})) doc.save() doc = doc.reload(10) - self.assertEquals(doc.embedded_field.list_field, []) + self.assertEqual(doc.embedded_field.list_field, []) embedded_2 = Embedded() embedded_2.string_field = 'hello' @@ -1878,8 +1879,8 @@ class DocumentTest(unittest.TestCase): embedded_2.list_field = ['1', 2, {'hello': 'world'}] doc.embedded_field.list_field = ['1', 2, embedded_2] - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) - self.assertEquals(doc.embedded_field._delta(), ({ + self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field']) + self.assertEqual(doc.embedded_field._delta(), ({ 'list_field': ['1', 2, { '_cls': '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, { '_cls': 'Embedded', '_types': ['Embedded'], @@ -1903,24 +1904,24 @@ class DocumentTest(unittest.TestCase): doc.save() doc = doc.reload(10) - self.assertEquals(doc.embedded_field.list_field[0], '1') - self.assertEquals(doc.embedded_field.list_field[1], 2) + self.assertEqual(doc.embedded_field.list_field[0], '1') + self.assertEqual(doc.embedded_field.list_field[1], 2) 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' - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field.2.string_field']) - self.assertEquals(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._get_changed_fields(), ['embedded_field.list_field.2.string_field']) + self.assertEqual(doc.embedded_field._delta(), ({'list_field.2.string_field': 'world'}, {})) + self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.string_field': 'world'}, {})) doc.save() 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 doc.embedded_field.list_field[2].string_field = 'hello world' doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2] - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) - self.assertEquals(doc.embedded_field._delta(), ({ + self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field']) + self.assertEqual(doc.embedded_field._delta(), ({ 'list_field': ['1', 2, { '_types': ['Embedded'], '_cls': 'Embedded', @@ -1928,7 +1929,7 @@ class DocumentTest(unittest.TestCase): 'int_field': 1, 'list_field': ['1', 2, {'hello': 'world'}], 'dict_field': {'hello': 'world'}}]}, {})) - self.assertEquals(doc._delta(), ({ + self.assertEqual(doc._delta(), ({ 'embedded_field.list_field': ['1', 2, { '_types': ['Embedded'], '_cls': 'Embedded', @@ -1939,32 +1940,32 @@ class DocumentTest(unittest.TestCase): ]}, {})) doc.save() 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 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 = doc.reload(10) 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 = 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 = 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']) - 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 = doc.reload(10) 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 = doc.reload(10) @@ -1974,8 +1975,8 @@ class DocumentTest(unittest.TestCase): doc = doc.reload(10) doc.dict_field['Embedded'].string_field = 'Hello World' - self.assertEquals(doc._get_changed_fields(), ['dict_field.Embedded.string_field']) - self.assertEquals(doc._delta(), ({'dict_field.Embedded.string_field': 'Hello World'}, {})) + self.assertEqual(doc._get_changed_fields(), ['dict_field.Embedded.string_field']) + self.assertEqual(doc._delta(), ({'dict_field.Embedded.string_field': 'Hello World'}, {})) def test_delta_db_field(self): @@ -1991,40 +1992,40 @@ class DocumentTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(doc._delta(), ({}, {})) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._delta(), ({}, {})) doc.string_field = 'hello' - self.assertEquals(doc._get_changed_fields(), ['db_string_field']) - self.assertEquals(doc._delta(), ({'db_string_field': 'hello'}, {})) + self.assertEqual(doc._get_changed_fields(), ['db_string_field']) + self.assertEqual(doc._delta(), ({'db_string_field': 'hello'}, {})) doc._changed_fields = [] doc.int_field = 1 - self.assertEquals(doc._get_changed_fields(), ['db_int_field']) - self.assertEquals(doc._delta(), ({'db_int_field': 1}, {})) + self.assertEqual(doc._get_changed_fields(), ['db_int_field']) + self.assertEqual(doc._delta(), ({'db_int_field': 1}, {})) doc._changed_fields = [] dict_value = {'hello': 'world', 'ping': 'pong'} doc.dict_field = dict_value - self.assertEquals(doc._get_changed_fields(), ['db_dict_field']) - self.assertEquals(doc._delta(), ({'db_dict_field': dict_value}, {})) + self.assertEqual(doc._get_changed_fields(), ['db_dict_field']) + self.assertEqual(doc._delta(), ({'db_dict_field': dict_value}, {})) doc._changed_fields = [] list_value = ['1', 2, {'hello': 'world'}] doc.list_field = list_value - self.assertEquals(doc._get_changed_fields(), ['db_list_field']) - self.assertEquals(doc._delta(), ({'db_list_field': list_value}, {})) + self.assertEqual(doc._get_changed_fields(), ['db_list_field']) + self.assertEqual(doc._delta(), ({'db_list_field': list_value}, {})) # Test unsetting doc._changed_fields = [] doc.dict_field = {} - self.assertEquals(doc._get_changed_fields(), ['db_dict_field']) - self.assertEquals(doc._delta(), ({}, {'db_dict_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['db_dict_field']) + self.assertEqual(doc._delta(), ({}, {'db_dict_field': 1})) doc._changed_fields = [] doc.list_field = [] - self.assertEquals(doc._get_changed_fields(), ['db_list_field']) - self.assertEquals(doc._delta(), ({}, {'db_list_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['db_list_field']) + self.assertEqual(doc._delta(), ({}, {'db_list_field': 1})) # Test it saves that data doc = Doc() @@ -2037,10 +2038,10 @@ class DocumentTest(unittest.TestCase): doc.save() doc = doc.reload(10) - self.assertEquals(doc.string_field, 'hello') - self.assertEquals(doc.int_field, 1) - self.assertEquals(doc.dict_field, {'hello': 'world'}) - self.assertEquals(doc.list_field, ['1', 2, {'hello': 'world'}]) + self.assertEqual(doc.string_field, 'hello') + self.assertEqual(doc.int_field, 1) + self.assertEqual(doc.dict_field, {'hello': 'world'}) + self.assertEqual(doc.list_field, ['1', 2, {'hello': 'world'}]) def test_delta_recursive_db_field(self): @@ -2062,8 +2063,8 @@ class DocumentTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(doc._delta(), ({}, {})) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._delta(), ({}, {})) embedded_1 = Embedded() embedded_1.string_field = 'hello' @@ -2072,7 +2073,7 @@ class DocumentTest(unittest.TestCase): embedded_1.list_field = ['1', 2, {'hello': 'world'}] 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 = { 'db_string_field': 'hello', @@ -2080,31 +2081,31 @@ class DocumentTest(unittest.TestCase): 'db_dict_field': {'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({ '_types': ['Embedded'], '_cls': 'Embedded', }) - self.assertEquals(doc._delta(), ({'db_embedded_field': embedded_delta}, {})) + self.assertEqual(doc._delta(), ({'db_embedded_field': embedded_delta}, {})) doc.save() doc = doc.reload(10) doc.embedded_field.dict_field = {} - self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_dict_field']) - self.assertEquals(doc.embedded_field._delta(), ({}, {'db_dict_field': 1})) - self.assertEquals(doc._delta(), ({}, {'db_embedded_field.db_dict_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_dict_field']) + self.assertEqual(doc.embedded_field._delta(), ({}, {'db_dict_field': 1})) + self.assertEqual(doc._delta(), ({}, {'db_embedded_field.db_dict_field': 1})) doc.save() doc = doc.reload(10) - self.assertEquals(doc.embedded_field.dict_field, {}) + self.assertEqual(doc.embedded_field.dict_field, {}) doc.embedded_field.list_field = [] - self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) - self.assertEquals(doc.embedded_field._delta(), ({}, {'db_list_field': 1})) - self.assertEquals(doc._delta(), ({}, {'db_embedded_field.db_list_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) + self.assertEqual(doc.embedded_field._delta(), ({}, {'db_list_field': 1})) + self.assertEqual(doc._delta(), ({}, {'db_embedded_field.db_list_field': 1})) doc.save() doc = doc.reload(10) - self.assertEquals(doc.embedded_field.list_field, []) + self.assertEqual(doc.embedded_field.list_field, []) embedded_2 = Embedded() embedded_2.string_field = 'hello' @@ -2113,8 +2114,8 @@ class DocumentTest(unittest.TestCase): embedded_2.list_field = ['1', 2, {'hello': 'world'}] doc.embedded_field.list_field = ['1', 2, embedded_2] - self.assertEquals(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) - self.assertEquals(doc.embedded_field._delta(), ({ + self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) + self.assertEqual(doc.embedded_field._delta(), ({ 'db_list_field': ['1', 2, { '_cls': '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, { '_cls': 'Embedded', '_types': ['Embedded'], @@ -2138,24 +2139,24 @@ class DocumentTest(unittest.TestCase): doc.save() doc = doc.reload(10) - self.assertEquals(doc.embedded_field.list_field[0], '1') - self.assertEquals(doc.embedded_field.list_field[1], 2) + self.assertEqual(doc.embedded_field.list_field[0], '1') + self.assertEqual(doc.embedded_field.list_field[1], 2) 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' - self.assertEquals(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.assertEquals(doc._delta(), ({'db_embedded_field.db_list_field.2.db_string_field': 'world'}, {})) + self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field.2.db_string_field']) + self.assertEqual(doc.embedded_field._delta(), ({'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 = 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 doc.embedded_field.list_field[2].string_field = 'hello world' 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.assertEquals(doc.embedded_field._delta(), ({ + self.assertEqual(doc._get_changed_fields(), ['db_embedded_field.db_list_field']) + self.assertEqual(doc.embedded_field._delta(), ({ 'db_list_field': ['1', 2, { '_types': ['Embedded'], '_cls': 'Embedded', @@ -2163,7 +2164,7 @@ class DocumentTest(unittest.TestCase): 'db_int_field': 1, 'db_list_field': ['1', 2, {'hello': 'world'}], 'db_dict_field': {'hello': 'world'}}]}, {})) - self.assertEquals(doc._delta(), ({ + self.assertEqual(doc._delta(), ({ 'db_embedded_field.db_list_field': ['1', 2, { '_types': ['Embedded'], '_cls': 'Embedded', @@ -2174,32 +2175,32 @@ class DocumentTest(unittest.TestCase): ]}, {})) doc.save() 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 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 = doc.reload(10) 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 = 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 = 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']) - 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 = doc.reload(10) 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): """Ensure save only sets / unsets changed fields @@ -2227,9 +2228,9 @@ class DocumentTest(unittest.TestCase): same_person.save() person = self.Person.objects.get() - self.assertEquals(person.name, 'User') - self.assertEquals(person.age, 21) - self.assertEquals(person.active, False) + self.assertEqual(person.name, 'User') + self.assertEqual(person.age, 21) + self.assertEqual(person.active, False) def test_save_only_changed_fields_recursive(self): """Ensure save only sets / unsets changed fields @@ -2485,16 +2486,16 @@ class DocumentTest(unittest.TestCase): p = Person(name="Rozza") p.save() - self.assertEquals(p._fields.keys(), ['name', 'id']) + self.assertEqual(p._fields.keys(), ['name', 'id']) collection = self.db[Person._get_collection_name()] obj = collection.find_one() - self.assertEquals(obj['_cls'], 'Person') - self.assertEquals(obj['_types'], ['Person']) + self.assertEqual(obj['_cls'], 'Person') + self.assertEqual(obj['_types'], ['Person']) - self.assertEquals(Person.objects.count(), 1) + self.assertEqual(Person.objects.count(), 1) rozza = Person.objects.get(name="Rozza") Person.drop_collection() @@ -2518,10 +2519,10 @@ class DocumentTest(unittest.TestCase): t = TestDoc.objects.first() - self.assertEquals(t.age, 19) - self.assertEquals(t.comment, "great!") - self.assertEquals(t.data, "test") - self.assertEquals(t.count, 12) + self.assertEqual(t.age, 19) + self.assertEqual(t.comment, "great!") + self.assertEqual(t.data, "test") + self.assertEqual(t.count, 12) def test_save_reference(self): """Ensure that a document reference field may be saved in the database. @@ -2802,8 +2803,8 @@ class DocumentTest(unittest.TestCase): A().save() B(foo=True).save() - self.assertEquals(A.objects.count(), 2) - self.assertEquals(B.objects.count(), 1) + self.assertEqual(A.objects.count(), 2) + self.assertEqual(B.objects.count(), 1) A.drop_collection() B.drop_collection() @@ -2864,13 +2865,13 @@ class DocumentTest(unittest.TestCase): pickled_doc = pickle.dumps(pickle_doc) resurrected = pickle.loads(pickled_doc) - self.assertEquals(resurrected, pickle_doc) + self.assertEqual(resurrected, pickle_doc) resurrected.string = "Two" resurrected.save() pickle_doc = pickle_doc.reload() - self.assertEquals(resurrected, pickle_doc) + self.assertEqual(resurrected, pickle_doc) def test_throw_invalid_document_error(self): @@ -2893,7 +2894,7 @@ class DocumentTest(unittest.TestCase): a = A() a.save() a.reload() - self.assertEquals(a.b.field1, 'field1') + self.assertEqual(a.b.field1, 'field1') class C(EmbeddedDocument): c_field = StringField(default='cfield') @@ -2910,7 +2911,7 @@ class DocumentTest(unittest.TestCase): a.save() 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): """Ensures you can save False values on save""" @@ -2924,7 +2925,7 @@ class DocumentTest(unittest.TestCase): d.archived = False 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): @@ -2938,7 +2939,7 @@ class DocumentTest(unittest.TestCase): d.archived = False 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): """Ensures cascading saves dont auto update""" @@ -3037,7 +3038,7 @@ class DocumentTest(unittest.TestCase): class B(A): 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): """ DB Ref usage in __raw__ queries """ @@ -3118,12 +3119,12 @@ class ValidatorErrorTest(unittest.TestCase): """Ensure a ValidationError handles error to_dict correctly. """ error = ValidationError('root') - self.assertEquals(error.to_dict(), {}) + self.assertEqual(error.to_dict(), {}) # 1st level error schema error.errors = {'1st': ValidationError('bad 1st'), } 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 error.errors = {'1st': ValidationError('bad 1st', errors={ @@ -3132,7 +3133,7 @@ class ValidatorErrorTest(unittest.TestCase): self.assertTrue('1st' in error.to_dict()) self.assertTrue(isinstance(error.to_dict()['1st'], dict)) 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 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('3rd' in error.to_dict()['1st']['2nd']) 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') - 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): @@ -3161,8 +3162,8 @@ class ValidatorErrorTest(unittest.TestCase): User().validate() except ValidationError, e: expected_error_message = """ValidationError(Field is required: ['username', 'name'])""" - self.assertEquals(e.message, expected_error_message) - self.assertEquals(e.to_dict(), { + self.assertEqual(e.message, expected_error_message) + self.assertEqual(e.to_dict(), { 'username': 'Field is required', 'name': 'Field is required'}) diff --git a/tests/test_dynamic_document.py b/tests/test_dynamic_document.py index 6ff199a0..866af7d3 100644 --- a/tests/test_dynamic_document.py +++ b/tests/test_dynamic_document.py @@ -25,14 +25,14 @@ class DynamicDocTest(unittest.TestCase): p.name = "James" p.age = 34 - self.assertEquals(p.to_mongo(), + self.assertEqual(p.to_mongo(), {"_types": ["Person"], "_cls": "Person", "name": "James", "age": 34} ) p.save() - self.assertEquals(self.Person.objects.first().age, 34) + self.assertEqual(self.Person.objects.first().age, 34) # Confirm no changes to self.Person self.assertFalse(hasattr(self.Person, 'age')) @@ -40,11 +40,11 @@ class DynamicDocTest(unittest.TestCase): def test_dynamic_document_delta(self): """Ensures simple dynamic documents can delta correctly""" 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 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): """Test changing the scope of a dynamic field has no adverse effects""" @@ -58,7 +58,7 @@ class DynamicDocTest(unittest.TestCase): p.save() p = self.Person.objects.get() - self.assertEquals(p.misc, {'hello': 'world'}) + self.assertEqual(p.misc, {'hello': 'world'}) def test_delete_dynamic_field(self): """Test deleting a dynamic field works""" @@ -73,10 +73,10 @@ class DynamicDocTest(unittest.TestCase): p.save() 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()] 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) p.save() @@ -85,7 +85,7 @@ class DynamicDocTest(unittest.TestCase): self.assertFalse(hasattr(p, 'misc')) 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): """Ensure we can query dynamic fields""" @@ -94,10 +94,10 @@ class DynamicDocTest(unittest.TestCase): p.age = 22 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 = p.get() - self.assertEquals(22, p.age) + self.assertEqual(22, p.age) def test_complex_dynamic_document_queries(self): class Person(DynamicDocument): @@ -117,8 +117,8 @@ class DynamicDocTest(unittest.TestCase): p2.age = 10 p2.save() - self.assertEquals(Person.objects(age__icontains='ten').count(), 2) - self.assertEquals(Person.objects(age__gte=10).count(), 1) + self.assertEqual(Person.objects(age__icontains='ten').count(), 2) + self.assertEqual(Person.objects(age__gte=10).count(), 1) def test_complex_data_lookups(self): """Ensure you can query dynamic document dynamic fields""" @@ -126,7 +126,7 @@ class DynamicDocTest(unittest.TestCase): p.misc = {'hello': 'world'} 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): """Ensure that dynamic document plays nice with inheritance""" @@ -146,8 +146,8 @@ class DynamicDocTest(unittest.TestCase): joe_bloggs.age = 20 joe_bloggs.save() - self.assertEquals(1, self.Person.objects(age=20).count()) - self.assertEquals(1, Employee.objects(age=20).count()) + self.assertEqual(1, self.Person.objects(age=20).count()) + self.assertEqual(1, Employee.objects(age=20).count()) joe_bloggs = self.Person.objects.first() self.assertTrue(isinstance(joe_bloggs, Employee)) @@ -170,7 +170,7 @@ class DynamicDocTest(unittest.TestCase): embedded_1.list_field = ['1', 2, {'hello': 'world'}] 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": { "_types": ['Embedded'], "_cls": "Embedded", "string_field": "hello", @@ -182,11 +182,11 @@ class DynamicDocTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc.embedded_field.__class__, Embedded) - self.assertEquals(doc.embedded_field.string_field, "hello") - self.assertEquals(doc.embedded_field.int_field, 1) - self.assertEquals(doc.embedded_field.dict_field, {'hello': 'world'}) - self.assertEquals(doc.embedded_field.list_field, ['1', 2, {'hello': 'world'}]) + self.assertEqual(doc.embedded_field.__class__, Embedded) + self.assertEqual(doc.embedded_field.string_field, "hello") + self.assertEqual(doc.embedded_field.int_field, 1) + self.assertEqual(doc.embedded_field.dict_field, {'hello': 'world'}) + self.assertEqual(doc.embedded_field.list_field, ['1', 2, {'hello': 'world'}]) def test_complex_embedded_documents(self): """Test complex dynamic embedded documents setups""" @@ -213,7 +213,7 @@ class DynamicDocTest(unittest.TestCase): embedded_1.list_field = ['1', 2, embedded_2] 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": { "_types": ['Embedded'], "_cls": "Embedded", "string_field": "hello", @@ -230,20 +230,20 @@ class DynamicDocTest(unittest.TestCase): }) doc.save() doc = Doc.objects.first() - self.assertEquals(doc.embedded_field.__class__, Embedded) - self.assertEquals(doc.embedded_field.string_field, "hello") - self.assertEquals(doc.embedded_field.int_field, 1) - self.assertEquals(doc.embedded_field.dict_field, {'hello': 'world'}) - self.assertEquals(doc.embedded_field.list_field[0], '1') - self.assertEquals(doc.embedded_field.list_field[1], 2) + self.assertEqual(doc.embedded_field.__class__, Embedded) + self.assertEqual(doc.embedded_field.string_field, "hello") + self.assertEqual(doc.embedded_field.int_field, 1) + self.assertEqual(doc.embedded_field.dict_field, {'hello': 'world'}) + self.assertEqual(doc.embedded_field.list_field[0], '1') + self.assertEqual(doc.embedded_field.list_field[1], 2) embedded_field = doc.embedded_field.list_field[2] - self.assertEquals(embedded_field.__class__, Embedded) - self.assertEquals(embedded_field.string_field, "hello") - self.assertEquals(embedded_field.int_field, 1) - self.assertEquals(embedded_field.dict_field, {'hello': 'world'}) - self.assertEquals(embedded_field.list_field, ['1', 2, {'hello': 'world'}]) + self.assertEqual(embedded_field.__class__, Embedded) + self.assertEqual(embedded_field.string_field, "hello") + self.assertEqual(embedded_field.int_field, 1) + self.assertEqual(embedded_field.dict_field, {'hello': 'world'}) + self.assertEqual(embedded_field.list_field, ['1', 2, {'hello': 'world'}]) def test_delta_for_dynamic_documents(self): p = self.Person() @@ -252,18 +252,18 @@ class DynamicDocTest(unittest.TestCase): p.save() p.age = 24 - self.assertEquals(p.age, 24) - self.assertEquals(p._get_changed_fields(), ['age']) - self.assertEquals(p._delta(), ({'age': 24}, {})) + self.assertEqual(p.age, 24) + self.assertEqual(p._get_changed_fields(), ['age']) + self.assertEqual(p._delta(), ({'age': 24}, {})) p = self.Person.objects(age=22).get() p.age = 24 - self.assertEquals(p.age, 24) - self.assertEquals(p._get_changed_fields(), ['age']) - self.assertEquals(p._delta(), ({'age': 24}, {})) + self.assertEqual(p.age, 24) + self.assertEqual(p._get_changed_fields(), ['age']) + self.assertEqual(p._delta(), ({'age': 24}, {})) p.save() - self.assertEquals(1, self.Person.objects(age=24).count()) + self.assertEqual(1, self.Person.objects(age=24).count()) def test_delta(self): @@ -275,40 +275,40 @@ class DynamicDocTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(doc._delta(), ({}, {})) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._delta(), ({}, {})) doc.string_field = 'hello' - self.assertEquals(doc._get_changed_fields(), ['string_field']) - self.assertEquals(doc._delta(), ({'string_field': 'hello'}, {})) + self.assertEqual(doc._get_changed_fields(), ['string_field']) + self.assertEqual(doc._delta(), ({'string_field': 'hello'}, {})) doc._changed_fields = [] doc.int_field = 1 - self.assertEquals(doc._get_changed_fields(), ['int_field']) - self.assertEquals(doc._delta(), ({'int_field': 1}, {})) + self.assertEqual(doc._get_changed_fields(), ['int_field']) + self.assertEqual(doc._delta(), ({'int_field': 1}, {})) doc._changed_fields = [] dict_value = {'hello': 'world', 'ping': 'pong'} doc.dict_field = dict_value - self.assertEquals(doc._get_changed_fields(), ['dict_field']) - self.assertEquals(doc._delta(), ({'dict_field': dict_value}, {})) + self.assertEqual(doc._get_changed_fields(), ['dict_field']) + self.assertEqual(doc._delta(), ({'dict_field': dict_value}, {})) doc._changed_fields = [] list_value = ['1', 2, {'hello': 'world'}] doc.list_field = list_value - self.assertEquals(doc._get_changed_fields(), ['list_field']) - self.assertEquals(doc._delta(), ({'list_field': list_value}, {})) + self.assertEqual(doc._get_changed_fields(), ['list_field']) + self.assertEqual(doc._delta(), ({'list_field': list_value}, {})) # Test unsetting doc._changed_fields = [] doc.dict_field = {} - self.assertEquals(doc._get_changed_fields(), ['dict_field']) - self.assertEquals(doc._delta(), ({}, {'dict_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['dict_field']) + self.assertEqual(doc._delta(), ({}, {'dict_field': 1})) doc._changed_fields = [] doc.list_field = [] - self.assertEquals(doc._get_changed_fields(), ['list_field']) - self.assertEquals(doc._delta(), ({}, {'list_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['list_field']) + self.assertEqual(doc._delta(), ({}, {'list_field': 1})) def test_delta_recursive(self): """Testing deltaing works with dynamic documents""" @@ -323,8 +323,8 @@ class DynamicDocTest(unittest.TestCase): doc.save() doc = Doc.objects.first() - self.assertEquals(doc._get_changed_fields(), []) - self.assertEquals(doc._delta(), ({}, {})) + self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._delta(), ({}, {})) embedded_1 = Embedded() embedded_1.string_field = 'hello' @@ -333,7 +333,7 @@ class DynamicDocTest(unittest.TestCase): embedded_1.list_field = ['1', 2, {'hello': 'world'}] doc.embedded_field = embedded_1 - self.assertEquals(doc._get_changed_fields(), ['embedded_field']) + self.assertEqual(doc._get_changed_fields(), ['embedded_field']) embedded_delta = { 'string_field': 'hello', @@ -341,28 +341,28 @@ class DynamicDocTest(unittest.TestCase): 'dict_field': {'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({ '_types': ['Embedded'], '_cls': 'Embedded', }) - self.assertEquals(doc._delta(), ({'embedded_field': embedded_delta}, {})) + self.assertEqual(doc._delta(), ({'embedded_field': embedded_delta}, {})) doc.save() doc.reload() doc.embedded_field.dict_field = {} - self.assertEquals(doc._get_changed_fields(), ['embedded_field.dict_field']) - self.assertEquals(doc.embedded_field._delta(), ({}, {'dict_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['embedded_field.dict_field']) + 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.reload() doc.embedded_field.list_field = [] - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) - self.assertEquals(doc.embedded_field._delta(), ({}, {'list_field': 1})) - self.assertEquals(doc._delta(), ({}, {'embedded_field.list_field': 1})) + self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field']) + self.assertEqual(doc.embedded_field._delta(), ({}, {'list_field': 1})) + self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field': 1})) doc.save() doc.reload() @@ -373,8 +373,8 @@ class DynamicDocTest(unittest.TestCase): embedded_2.list_field = ['1', 2, {'hello': 'world'}] doc.embedded_field.list_field = ['1', 2, embedded_2] - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) - self.assertEquals(doc.embedded_field._delta(), ({ + self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field']) + self.assertEqual(doc.embedded_field._delta(), ({ 'list_field': ['1', 2, { '_cls': '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, { '_cls': 'Embedded', '_types': ['Embedded'], @@ -398,25 +398,25 @@ class DynamicDocTest(unittest.TestCase): doc.save() doc.reload() - self.assertEquals(doc.embedded_field.list_field[2]._changed_fields, []) - self.assertEquals(doc.embedded_field.list_field[0], '1') - self.assertEquals(doc.embedded_field.list_field[1], 2) + self.assertEqual(doc.embedded_field.list_field[2]._changed_fields, []) + self.assertEqual(doc.embedded_field.list_field[0], '1') + self.assertEqual(doc.embedded_field.list_field[1], 2) 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' - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field.2.string_field']) - self.assertEquals(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._get_changed_fields(), ['embedded_field.list_field.2.string_field']) + self.assertEqual(doc.embedded_field._delta(), ({'list_field.2.string_field': 'world'}, {})) + self.assertEqual(doc._delta(), ({'embedded_field.list_field.2.string_field': 'world'}, {})) doc.save() 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 doc.embedded_field.list_field[2].string_field = 'hello world' doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2] - self.assertEquals(doc._get_changed_fields(), ['embedded_field.list_field']) - self.assertEquals(doc.embedded_field._delta(), ({ + self.assertEqual(doc._get_changed_fields(), ['embedded_field.list_field']) + self.assertEqual(doc.embedded_field._delta(), ({ 'list_field': ['1', 2, { '_types': ['Embedded'], '_cls': 'Embedded', @@ -424,7 +424,7 @@ class DynamicDocTest(unittest.TestCase): 'int_field': 1, 'list_field': ['1', 2, {'hello': 'world'}], 'dict_field': {'hello': 'world'}}]}, {})) - self.assertEquals(doc._delta(), ({ + self.assertEqual(doc._delta(), ({ 'embedded_field.list_field': ['1', 2, { '_types': ['Embedded'], '_cls': 'Embedded', @@ -435,32 +435,32 @@ class DynamicDocTest(unittest.TestCase): ]}, {})) doc.save() 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 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.reload() 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.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.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']) - 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.reload() 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.reload() @@ -470,8 +470,8 @@ class DynamicDocTest(unittest.TestCase): doc.reload() doc.dict_field['embedded'].string_field = 'Hello World' - self.assertEquals(doc._get_changed_fields(), ['dict_field.embedded.string_field']) - self.assertEquals(doc._delta(), ({'dict_field.embedded.string_field': 'Hello World'}, {})) + self.assertEqual(doc._get_changed_fields(), ['dict_field.embedded.string_field']) + self.assertEqual(doc._delta(), ({'dict_field.embedded.string_field': 'Hello World'}, {})) def test_indexes(self): """Ensure that indexes are used when meta[indexes] is specified. diff --git a/tests/test_fields.py b/tests/test_fields.py index c4013c10..dca4f21e 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -2,20 +2,21 @@ import datetime import os import unittest import uuid -import StringIO import tempfile -import gridfs -from bson import Binary from decimal import Decimal +from bson import Binary +import gridfs + +from nose.plugins.skip import SkipTest from mongoengine import * from mongoengine.connection import get_db 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') - class FieldTest(unittest.TestCase): def setUp(self): @@ -124,7 +125,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(ret.int_fld, None) self.assertEqual(ret.flt_fld, 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) @@ -356,7 +357,7 @@ class FieldTest(unittest.TestCase): log.date = datetime.date.today() log.save() log.reload() - self.assertEquals(log.date.date(), datetime.date.today()) + self.assertEqual(log.date.date(), datetime.date.today()) LogEntry.drop_collection() @@ -367,8 +368,8 @@ class FieldTest(unittest.TestCase): log.date = d1 log.save() log.reload() - self.assertNotEquals(log.date, d1) - self.assertEquals(log.date, d2) + self.assertNotEqual(log.date, d1) + self.assertEqual(log.date, d2) # Post UTC - microseconds are rounded (down) nearest millisecond d1 = datetime.datetime(1970, 01, 01, 00, 00, 01, 9999) @@ -376,17 +377,19 @@ class FieldTest(unittest.TestCase): log.date = d1 log.save() log.reload() - self.assertNotEquals(log.date, d1) - self.assertEquals(log.date, d2) + self.assertNotEqual(log.date, d1) + self.assertEqual(log.date, d2) - # Pre UTC dates microseconds below 1000 are dropped - d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999) - d2 = datetime.datetime(1969, 12, 31, 23, 59, 59) - log.date = d1 - log.save() - log.reload() - self.assertNotEquals(log.date, d1) - self.assertEquals(log.date, d2) + if not PY3: + # Pre UTC dates microseconds below 1000 are dropped + # This does not seem to be true in PY3 + d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999) + d2 = datetime.datetime(1969, 12, 31, 23, 59, 59) + log.date = d1 + log.save() + log.reload() + self.assertNotEqual(log.date, d1) + self.assertEqual(log.date, d2) LogEntry.drop_collection() @@ -405,21 +408,21 @@ class FieldTest(unittest.TestCase): log.date = d1 log.save() log.reload() - self.assertEquals(log.date, d1) + self.assertEqual(log.date, d1) # Post UTC - microseconds are rounded (down) nearest millisecond - with default datetimefields d1 = datetime.datetime(1970, 01, 01, 00, 00, 01, 9999) log.date = d1 log.save() log.reload() - self.assertEquals(log.date, d1) + self.assertEqual(log.date, d1) # Pre UTC dates microseconds below 1000 are dropped - with default datetimefields d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999) log.date = d1 log.save() log.reload() - self.assertEquals(log.date, d1) + self.assertEqual(log.date, d1) # Pre UTC microseconds above 1000 is wonky - with default datetimefields # log.date has an invalid microsecond value so I can't construct @@ -429,7 +432,7 @@ class FieldTest(unittest.TestCase): log.date = d1 log.save() log.reload() - self.assertEquals(log.date, d1) + self.assertEqual(log.date, d1) log1 = LogEntry.objects.get(date=d1) self.assertEqual(log, log1) @@ -450,7 +453,7 @@ class FieldTest(unittest.TestCase): log.save() log1 = LogEntry.objects.get(date=d1) - self.assertEquals(log, log1) + self.assertEqual(log, log1) LogEntry.drop_collection() @@ -638,13 +641,13 @@ class FieldTest(unittest.TestCase): post.info = [{'test': 3}] post.save() - self.assertEquals(BlogPost.objects.count(), 3) - self.assertEquals(BlogPost.objects.filter(info__exact='test').count(), 1) - self.assertEquals(BlogPost.objects.filter(info__0__test='test').count(), 1) + self.assertEqual(BlogPost.objects.count(), 3) + self.assertEqual(BlogPost.objects.filter(info__exact='test').count(), 1) + self.assertEqual(BlogPost.objects.filter(info__0__test='test').count(), 1) # Confirm handles non strings or non existing keys - self.assertEquals(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__0__test__exact='5').count(), 0) + self.assertEqual(BlogPost.objects.filter(info__100__test__exact='test').count(), 0) BlogPost.drop_collection() def test_list_field_passed_in_value(self): @@ -659,7 +662,7 @@ class FieldTest(unittest.TestCase): foo = Foo(bars=[]) foo.bars.append(bar) - self.assertEquals(repr(foo.bars), '[]') + self.assertEqual(repr(foo.bars), '[]') def test_list_field_strict(self): @@ -744,20 +747,20 @@ class FieldTest(unittest.TestCase): self.assertTrue(isinstance(e2.mapping[1], IntegerSetting)) # Test querying - self.assertEquals(Simple.objects.filter(mapping__1__value=42).count(), 1) - self.assertEquals(Simple.objects.filter(mapping__2__number=1).count(), 1) - self.assertEquals(Simple.objects.filter(mapping__2__complex__value=42).count(), 1) - self.assertEquals(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__1__value=42).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__2__number=1).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__2__complex__value=42).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__2__list__0__value=42).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__2__list__1__value='foo').count(), 1) # Confirm can update 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( set__mapping__2__list__1=StringSetting(value='Boo')) - self.assertEquals(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='foo').count(), 0) + self.assertEqual(Simple.objects.filter(mapping__2__list__1__value='Boo').count(), 1) Simple.drop_collection() @@ -796,19 +799,19 @@ class FieldTest(unittest.TestCase): post.info = {'details': {'test': 3}} post.save() - self.assertEquals(BlogPost.objects.count(), 3) - self.assertEquals(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.count(), 3) + self.assertEqual(BlogPost.objects.filter(info__title__exact='test').count(), 1) + self.assertEqual(BlogPost.objects.filter(info__details__test__exact='test').count(), 1) # Confirm handles non strings or non existing keys - self.assertEquals(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__details__test__exact=5).count(), 0) + self.assertEqual(BlogPost.objects.filter(info__made_up__test__exact='test').count(), 0) post = BlogPost.objects.create(info={'title': 'original'}) post.info.update({'title': 'updated'}) post.save() post.reload() - self.assertEquals('updated', post.info['title']) + self.assertEqual('updated', post.info['title']) BlogPost.drop_collection() @@ -861,19 +864,19 @@ class FieldTest(unittest.TestCase): self.assertTrue(isinstance(e2.mapping['someint'], IntegerSetting)) # Test querying - self.assertEquals(Simple.objects.filter(mapping__someint__value=42).count(), 1) - self.assertEquals(Simple.objects.filter(mapping__nested_dict__number=1).count(), 1) - self.assertEquals(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.assertEquals(Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 1) + self.assertEqual(Simple.objects.filter(mapping__someint__value=42).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__nested_dict__number=1).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__nested_dict__complex__value=42).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__0__value=42).count(), 1) + self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 1) # Confirm can update Simple.objects().update( set__mapping={"someint": IntegerSetting(value=10)}) Simple.objects().update( set__mapping__nested_dict__list__1=StringSetting(value='Boo')) - self.assertEquals(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='foo').count(), 0) + self.assertEqual(Simple.objects.filter(mapping__nested_dict__list__1__value='Boo').count(), 1) Simple.drop_collection() @@ -1383,7 +1386,7 @@ class FieldTest(unittest.TestCase): Person.drop_collection() Person(name="Wilson Jr").save() - self.assertEquals(repr(Person.objects(city=None)), + self.assertEqual(repr(Person.objects(city=None)), "[]") @@ -1461,7 +1464,7 @@ class FieldTest(unittest.TestCase): content_type = StringField() blob = BinaryField() - BLOB = '\xe6\x00\xc4\xff\x07' + BLOB = b('\xe6\x00\xc4\xff\x07') MIME_TYPE = 'application/octet-stream' Attachment.drop_collection() @@ -1471,7 +1474,7 @@ class FieldTest(unittest.TestCase): attachment_1 = Attachment.objects().first() 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() @@ -1498,12 +1501,12 @@ class FieldTest(unittest.TestCase): attachment_required = AttachmentRequired() 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_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) - attachment_size_limit.blob = '\xe6\x00\xc4\xff' + attachment_size_limit.blob = b('\xe6\x00\xc4\xff') attachment_size_limit.validate() Attachment.drop_collection() @@ -1630,8 +1633,8 @@ class FieldTest(unittest.TestCase): class SetFile(Document): the_file = FileField() - text = 'Hello, World!' - more_text = 'Foo Bar' + text = b('Hello, World!') + more_text = b('Foo Bar') content_type = 'text/plain' PutFile.drop_collection() @@ -1644,14 +1647,14 @@ class FieldTest(unittest.TestCase): putfile.validate() result = PutFile.objects.first() self.assertTrue(putfile == result) - self.assertEquals(result.the_file.read(), text) - self.assertEquals(result.the_file.content_type, content_type) + self.assertEqual(result.the_file.read(), text) + self.assertEqual(result.the_file.content_type, content_type) result.the_file.delete() # Remove file from GridFS PutFile.objects.delete() # Ensure file-like objects are stored putfile = PutFile() - putstring = StringIO.StringIO() + putstring = StringIO() putstring.write(text) putstring.seek(0) putfile.the_file.put(putstring, content_type=content_type) @@ -1659,8 +1662,8 @@ class FieldTest(unittest.TestCase): putfile.validate() result = PutFile.objects.first() self.assertTrue(putfile == result) - self.assertEquals(result.the_file.read(), text) - self.assertEquals(result.the_file.content_type, content_type) + self.assertEqual(result.the_file.read(), text) + self.assertEqual(result.the_file.content_type, content_type) result.the_file.delete() streamfile = StreamFile() @@ -1675,11 +1678,11 @@ class FieldTest(unittest.TestCase): self.assertEquals(result.the_file.read(), text + more_text) self.assertEquals(result.the_file.content_type, content_type) result.the_file.seek(0) - self.assertEquals(result.the_file.tell(), 0) - self.assertEquals(result.the_file.read(len(text)), text) - self.assertEquals(result.the_file.tell(), len(text)) - self.assertEquals(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(), 0) + self.assertEqual(result.the_file.read(len(text)), text) + self.assertEqual(result.the_file.tell(), len(text)) + self.assertEqual(result.the_file.read(len(more_text)), more_text) + self.assertEqual(result.the_file.tell(), len(text + more_text)) result.the_file.delete() # Ensure deleted file returns None @@ -1691,7 +1694,7 @@ class FieldTest(unittest.TestCase): setfile.validate() result = SetFile.objects.first() self.assertTrue(setfile == result) - self.assertEquals(result.the_file.read(), text) + self.assertEqual(result.the_file.read(), text) # Try replacing file with new one result.the_file.replace(more_text) @@ -1699,7 +1702,7 @@ class FieldTest(unittest.TestCase): result.validate() result = SetFile.objects.first() self.assertTrue(setfile == result) - self.assertEquals(result.the_file.read(), more_text) + self.assertEqual(result.the_file.read(), more_text) result.the_file.delete() PutFile.drop_collection() @@ -1720,7 +1723,7 @@ class FieldTest(unittest.TestCase): GridDocument.drop_collection() with tempfile.TemporaryFile() as f: - f.write("Hello World!") + f.write(b("Hello World!")) f.flush() # Test without default @@ -1731,28 +1734,28 @@ class FieldTest(unittest.TestCase): doc_b = GridDocument.objects.with_id(doc_a.id) doc_b.the_file.replace(f, filename='doc_b') doc_b.save() - self.assertNotEquals(doc_b.the_file.grid_id, None) + self.assertNotEqual(doc_b.the_file.grid_id, None) # Test it matches 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 - doc_d = GridDocument(the_file='') + doc_d = GridDocument(the_file=b('')) doc_d.save() 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.save() 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() 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): """Ensure that each instance of a FileField is unique @@ -1764,7 +1767,7 @@ class FieldTest(unittest.TestCase): # First instance test_file = TestFile() test_file.name = "Hello, World!" - test_file.the_file.put('Hello, World!') + test_file.the_file.put(b('Hello, World!')) test_file.save() # Second instance @@ -1784,7 +1787,7 @@ class FieldTest(unittest.TestCase): test_file = TestFile() 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.save() self.assertTrue(bool(test_file.the_file)) @@ -1800,6 +1803,8 @@ class FieldTest(unittest.TestCase): self.assertFalse(test_file.the_file in [{"test": 1}]) def test_image_field(self): + if PY3: + raise SkipTest('PIL does not have Python 3 support') class TestImage(Document): image = ImageField() @@ -1821,6 +1826,8 @@ class FieldTest(unittest.TestCase): t.image.delete() def test_image_field_resize(self): + if PY3: + raise SkipTest('PIL does not have Python 3 support') class TestImage(Document): image = ImageField(size=(185, 37)) @@ -1842,6 +1849,8 @@ class FieldTest(unittest.TestCase): t.image.delete() def test_image_field_thumbnail(self): + if PY3: + raise SkipTest('PIL does not have Python 3 support') class TestImage(Document): image = ImageField(thumbnail_size=(92, 18)) @@ -1860,7 +1869,6 @@ class FieldTest(unittest.TestCase): t.image.delete() - def test_file_multidb(self): register_connection('test_files', 'test_files') class TestFile(Document): @@ -1877,7 +1885,7 @@ class FieldTest(unittest.TestCase): # First instance test_file = TestFile() test_file.name = "Hello, World!" - test_file.the_file.put('Hello, World!', + test_file.the_file.put(b('Hello, World!'), name="hello.txt") test_file.save() @@ -1885,8 +1893,8 @@ class FieldTest(unittest.TestCase): self.assertEquals(data.get('name'), 'hello.txt') test_file = TestFile.objects.first() - self.assertEquals(test_file.the_file.read(), - 'Hello, World!') + self.assertEqual(test_file.the_file.read(), + b('Hello, World!')) def test_geo_indexes(self): """Ensure that indexes are created automatically for GeoPointFields. @@ -2146,28 +2154,28 @@ class FieldTest(unittest.TestCase): post = Post(title='hello world') post.comments.append(Comment(content='hello', author=bob)) post.comments.append(Comment(author=bob)) - + + self.assertRaises(ValidationError, post.validate) try: post.validate() - except ValidationError, error: - pass + except ValidationError, error: + # 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 - 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.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.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.validate() diff --git a/tests/test_queryset.py b/tests/test_queryset.py index b4ae805b..1960fc62 100644 --- a/tests/test_queryset.py +++ b/tests/test_queryset.py @@ -1,16 +1,19 @@ # -*- coding: utf-8 -*- import unittest -import pymongo -from bson import ObjectId + 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, MultipleObjectsReturned, DoesNotExist, QueryFieldList) -from mongoengine import * -from mongoengine.connection import get_connection -from mongoengine.tests import query_counter - class QuerySetTest(unittest.TestCase): @@ -239,11 +242,11 @@ class QuerySetTest(unittest.TestCase): self.Person.objects.update(set__name='Ross', write_options=write_options) 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) 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): """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) post = BlogPost.objects.first() - self.assertEquals(post.comments[1].by, 'jane') - self.assertEquals(post.comments[1].votes, 8) + self.assertEqual(post.comments[1].by, 'jane') + self.assertEqual(post.comments[1].votes, 8) # Currently the $ operator only applies to the first matched item in # the query @@ -346,7 +349,7 @@ class QuerySetTest(unittest.TestCase): Simple.objects(x=2).update(inc__x__S=1) simple = Simple.objects.first() - self.assertEquals(simple.x, [1, 3, 3, 2]) + self.assertEqual(simple.x, [1, 3, 3, 2]) Simple.drop_collection() # You can set multiples @@ -358,10 +361,10 @@ class QuerySetTest(unittest.TestCase): Simple.objects(x=3).update(set__x__S=0) s = Simple.objects() - self.assertEquals(s[0].x, [1, 2, 0, 4]) - self.assertEquals(s[1].x, [2, 0, 4, 5]) - self.assertEquals(s[2].x, [0, 4, 5, 6]) - self.assertEquals(s[3].x, [4, 5, 6, 7]) + self.assertEqual(s[0].x, [1, 2, 0, 4]) + self.assertEqual(s[1].x, [2, 0, 4, 5]) + self.assertEqual(s[2].x, [0, 4, 5, 6]) + self.assertEqual(s[3].x, [4, 5, 6, 7]) # Using "$unset" with an expression like this "array.$" will result in # 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.objects(x=3).update(unset__x__S=1) 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.. def update_nested(): Simple.drop_collection() Simple(x=[{'test': [1, 2, 3, 4]}]).save() 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) Simple.drop_collection() @@ -406,8 +409,8 @@ class QuerySetTest(unittest.TestCase): BlogPost.objects(comments__by="joe").update(set__comments__S__votes=Vote(score=4)) post = BlogPost.objects.first() - self.assertEquals(post.comments[0].by, 'joe') - self.assertEquals(post.comments[0].votes.score, 4) + self.assertEqual(post.comments[0].by, 'joe') + self.assertEqual(post.comments[0].votes.score, 4) def test_mapfield_update(self): """Ensure that the MapField can be updated.""" @@ -561,7 +564,7 @@ class QuerySetTest(unittest.TestCase): Blog.drop_collection() blog1 = Blog(title="code", posts=[post1, post2]) 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() post3 = Post(comments=[comment1, comment1]) @@ -710,20 +713,20 @@ class QuerySetTest(unittest.TestCase): docs = Doc.objects.order_by('number') - self.assertEquals(docs.count(), 1000) - self.assertEquals(len(docs), 1000) + self.assertEqual(docs.count(), 1000) + self.assertEqual(len(docs), 1000) docs_string = "%s" % docs self.assertTrue("Doc: 0" in docs_string) - self.assertEquals(docs.count(), 1000) - self.assertEquals(len(docs), 1000) + self.assertEqual(docs.count(), 1000) + self.assertEqual(len(docs), 1000) # Limit and skip - self.assertEquals('[, , ]', "%s" % docs[1:4]) + self.assertEqual('[, , ]', "%s" % docs[1:4]) - self.assertEquals(docs.count(), 3) - self.assertEquals(len(docs), 3) + self.assertEqual(docs.count(), 3) + self.assertEqual(len(docs), 3) for doc in docs: self.assertEqual('.. queryset mid-iteration ..', repr(docs)) @@ -1082,27 +1085,27 @@ class QuerySetTest(unittest.TestCase): # first three numbers = Numbers.objects.fields(slice__n=3).get() - self.assertEquals(numbers.n, [0, 1, 2]) + self.assertEqual(numbers.n, [0, 1, 2]) # last three 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 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 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 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 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): """Ensure that query slicing an embedded array works. @@ -1122,27 +1125,27 @@ class QuerySetTest(unittest.TestCase): # first three 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 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 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 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 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 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): """Ensure that an embedded document is properly returned from a query. @@ -1383,7 +1386,7 @@ class QuerySetTest(unittest.TestCase): # Test template style code = "{{~comments.content}}" sub_code = BlogPost.objects._sub_js_fields(code) - self.assertEquals("cmnts.body", sub_code) + self.assertEqual("cmnts.body", sub_code) BlogPost.drop_collection() @@ -1446,13 +1449,13 @@ class QuerySetTest(unittest.TestCase): child_child.save() tree_size = 1 + num_children + (num_children * num_children) - self.assertEquals(tree_size, Category.objects.count()) - self.assertEquals(num_children, Category.objects(parent=base).count()) + self.assertEqual(tree_size, Category.objects.count()) + self.assertEqual(num_children, Category.objects(parent=base).count()) # The delete should effectively wipe out the Category collection # without resulting in infinite parent-child cascade recursion base.delete() - self.assertEquals(0, Category.objects.count()) + self.assertEqual(0, Category.objects.count()) def test_reverse_delete_rule_nullify(self): """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") 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) post.reload() @@ -1740,7 +1743,7 @@ class QuerySetTest(unittest.TestCase): set__authors__S=Author(name="Ross")) message = message.reload() - self.assertEquals(message.authors[0].name, "Ross") + self.assertEqual(message.authors[0].name, "Ross") Message.objects(authors__name="Ross").update_one( set__authors=[Author(name="Harry"), @@ -1748,9 +1751,9 @@ class QuerySetTest(unittest.TestCase): Author(name="Adam")]) message = message.reload() - self.assertEquals(message.authors[0].name, "Harry") - self.assertEquals(message.authors[1].name, "Ross") - self.assertEquals(message.authors[2].name, "Adam") + self.assertEqual(message.authors[0].name, "Harry") + self.assertEqual(message.authors[1].name, "Ross") + self.assertEqual(message.authors[2].name, "Adam") def test_order_by(self): """Ensure that QuerySets may be ordered. @@ -1830,10 +1833,10 @@ class QuerySetTest(unittest.TestCase): results = list(results) 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) - film = filter(lambda r: r.key == "film", results)[0] + film = list(filter(lambda r: r.key == "film", results))[0] self.assertEqual(film.value, 3) BlogPost.drop_collection() @@ -2133,15 +2136,15 @@ class QuerySetTest(unittest.TestCase): Person(name="Wilson Jr").save() 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) - 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) - 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) - 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): class Data(EmbeddedDocument): @@ -2166,10 +2169,10 @@ class QuerySetTest(unittest.TestCase): p.save() 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) - 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): class Test(Document): @@ -2181,9 +2184,9 @@ class QuerySetTest(unittest.TestCase): t.save() 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) - self.assertEquals(ot, {0: 1}) + self.assertEqual(ot, {0: 1}) def test_item_frequencies_with_False_values(self): class Test(Document): @@ -2195,9 +2198,9 @@ class QuerySetTest(unittest.TestCase): t.save() 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) - self.assertEquals(ot, {False: 1}) + self.assertEqual(ot, {False: 1}) def test_item_frequencies_normalize(self): class Test(Document): @@ -2212,10 +2215,10 @@ class QuerySetTest(unittest.TestCase): Test(val=2).save() 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) - 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): """Ensure that field can be averaged correctly. @@ -2275,7 +2278,7 @@ class QuerySetTest(unittest.TestCase): foo = Foo(bar=bar) foo.save() - self.assertEquals(Foo.objects.distinct("bar"), [bar]) + self.assertEqual(Foo.objects.distinct("bar"), [bar]) def test_custom_manager(self): """Ensure that custom QuerySetManager instances work as expected. @@ -2735,8 +2738,8 @@ class QuerySetTest(unittest.TestCase): Post().save() Post(is_published=True).save() - self.assertEquals(Post.objects.count(), 2) - self.assertEquals(Post.published.count(), 1) + self.assertEqual(Post.objects.count(), 2) + self.assertEqual(Post.published.count(), 1) Post.drop_collection() @@ -2902,10 +2905,10 @@ class QuerySetTest(unittest.TestCase): Number(n=3).save() 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')] - self.assertEquals([1, 2, 3], numbers) + self.assertEqual([1, 2, 3], numbers) Number.drop_collection() @@ -3227,15 +3230,22 @@ class QuerySetTest(unittest.TestCase): 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.scalar('name').order_by('name')[0]) - 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]) + if PY3: + 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 person = self.Person.objects.order_by('name').first() self.assertEqual("A0", "%s" % self.Person.objects.scalar('name').with_id(person.id)) 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): diff --git a/tests/test_replicaset_connection.py b/tests/test_replicaset_connection.py index 22978143..3118c5a4 100644 --- a/tests/test_replicaset_connection.py +++ b/tests/test_replicaset_connection.py @@ -1,4 +1,5 @@ import unittest + import pymongo from pymongo import ReadPreference, ReplicaSetConnection @@ -26,7 +27,7 @@ class ConnectionTest(unittest.TestCase): if not isinstance(conn, ReplicaSetConnection): return - self.assertEquals(conn.read_preference, ReadPreference.SECONDARY_ONLY) + self.assertEqual(conn.read_preference, ReadPreference.SECONDARY_ONLY) if __name__ == '__main__': unittest.main() diff --git a/tests/test_signals.py b/tests/test_signals.py index 4dc683e8..d1199248 100644 --- a/tests/test_signals.py +++ b/tests/test_signals.py @@ -212,9 +212,9 @@ class SignalTests(unittest.TestCase): # 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 - self.assertEquals(signal_output[3], + self.assertEqual(signal_output[3], "pre_bulk_insert signal, []") - self.assertEquals(signal_output[-2:], + self.assertEqual(signal_output[-2:], ["post_bulk_insert signal, []", "Is loaded",])