cleanup tests, use one MongoClient

Author: eguven

requirements-test.txt

@@ -3,5 +3,6 @@
 coverage
 flake8
 mock
+motor
 nose
 tornado

requirements.txt

@@ -1,3 +1,2 @@
-motor
 pymongo
 six

test/test_document.py

@@ -4,6 +4,8 @@
 import unittest
 import sys
 
+import bson
+import pymongo
 import six
 
 from nanomongo.field import Field
@@ -12,13 +14,7 @@
     ConfigurationError, DBRefNotSetError, ExtraFieldError, UnsupportedOperation, ValidationError,
 )
 
-try:
-    import pymongo
-    import bson
-    pymongo.MongoClient()
-    PYMONGO_OK = True
-except ImportError:
-    PYMONGO_OK = False
+from . import PYMONGO_CLIENT
 
 
 class DocumentTestCase(unittest.TestCase):
@@ -161,19 +157,18 @@ class Doc(BaseDocument):
         [self.assertRaises(TypeError, func) for func in (bad_client, bad_db, bad_col)]
         self.assertRaises(ConfigurationError, db_before_client)
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_document_client(self):
         """Pymongo: Test correct client input and document configuration"""
-        mclient = pymongo.MongoClient()
 
         class Doc(BaseDocument):
-            client = mclient
+            client = PYMONGO_CLIENT
             db = 'nanomongotest'
             dot_notation = True
             foo = Field(six.text_type)
 
         class Doc2(Doc):
-            client = mclient
+            client = PYMONGO_CLIENT
             db = 'nanomongotest'
             collection = 'othercollection'
             dot_notation = True
@@ -186,27 +181,26 @@ class Doc3(Doc):
         dd = Doc2()
         ddd = Doc3()
         self.assertEqual(d.nanomongo.client, dd.nanomongo.client)
-        self.assertEqual(mclient['nanomongotest'], d.nanomongo.database)
-        self.assertEqual(mclient['nanomongotest'], dd.nanomongo.database)
+        self.assertEqual(PYMONGO_CLIENT['nanomongotest'], d.nanomongo.database)
+        self.assertEqual(PYMONGO_CLIENT['nanomongotest'], dd.nanomongo.database)
         self.assertEqual('doc', d.nanomongo.collection)
         self.assertEqual('othercollection', dd.nanomongo.collection)
         self.assertNotEqual(d.nanomongo.client, ddd.nanomongo.client)
         self.assertFalse(hasattr(dd, 'client') or hasattr(dd, 'db') or
                          hasattr(dd, 'collection'))
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_document_configuration(self):
         """Pymongo: Test document misconfiguration eg. client, db, collection"""
-        mclient = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             pass
 
         class Doc2(BaseDocument):
-            client = mclient
+            client = PYMONGO_CLIENT
 
         class Doc3(BaseDocument):  # autoset
-            client = mclient
+            client = PYMONGO_CLIENT
             db = 'nanotestdb'
 
         self.assertRaises(ConfigurationError, Doc.get_collection)
@@ -216,34 +210,33 @@ class Doc3(BaseDocument):  # autoset
         self.assertRaises(ConfigurationError, Doc3.get_collection)
         # register
         self.assertRaises(ConfigurationError, Doc.register)
-        self.assertRaises(ConfigurationError, Doc.register, **{'client': mclient})
+        self.assertRaises(ConfigurationError, Doc.register, **{'client': PYMONGO_CLIENT})
         self.assertRaises(TypeError, Doc.register,
-                          **{'client': mclient, 'db': mclient['nanotestdb']})
+                          **{'client': PYMONGO_CLIENT, 'db': PYMONGO_CLIENT['nanotestdb']})
         self.assertFalse(Doc.nanomongo.registered)
-        Doc.register(client=mclient, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
         self.assertTrue(Doc.nanomongo.registered)
         self.assertRaises(ConfigurationError, Doc.register,
-                          **{'client': mclient, 'db': 'nanotestdb'})
+                          **{'client': PYMONGO_CLIENT, 'db': 'nanotestdb'})
         m_count = len(Doc.get_collection().database.outgoing_copying_manipulators)
         self.assertEqual(1, m_count)
 
-        Doc2.register(client=mclient, db='nanotestdb', collection='doc2_collection')
+        Doc2.register(client=PYMONGO_CLIENT, db='nanotestdb', collection='doc2_collection')
 
 
 class MongoDocumentTestCase(unittest.TestCase):
     def setUp(self):
-        pymongo.MongoClient().drop_database('nanotestdb')
+        PYMONGO_CLIENT.drop_database('nanotestdb')
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_insert_find(self):
         """Pymongo: Test document insert, find, find_one"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             dot_notation = True
             foo = Field(six.text_type)
             bar = Field(int, required=False)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         self.assertEqual(None, Doc.find_one())
         d = Doc(foo=six.u('foo value'))
@@ -255,17 +248,16 @@ class Doc(BaseDocument):
         self.assertEqual(1, Doc.find({'foo': 'foo value'}).count())
         self.assertEqual(d, Doc.find_one())
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_partial_update(self):
         """Pymongo: Test partial atomic update with save"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             dot_notation = True
             foo = Field(six.text_type)
             bar = Field(int, required=False)
             moo = Field(list)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         d = Doc(foo=six.u('foo value'), bar=42)
         self.assertRaises(ValidationError, d.save)  # no _id yet
@@ -298,17 +290,16 @@ class Doc(BaseDocument):
         del d.foo
         self.assertRaises(ValidationError, d.save)
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_partial_update_addToSet(self):
         """Pymongo: addToSet functionality with `save`"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             dot_notation = True
             foo = Field(list)
             bar = Field(dict)
             moo = Field(six.text_type)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         self.assertRaises(ValidationError, Doc().addToSet, *('$fail', 42))
         self.assertRaises(ValidationError, Doc().addToSet, *('bar.$1', 42))
@@ -362,7 +353,7 @@ class Doc2(BaseDocument):
             dot_notation = True
             optional = Field(dict, required=False)
 
-        Doc2.register(client=client, db='nanotestdb')
+        Doc2.register(client=PYMONGO_CLIENT, db='nanotestdb')
         dd = Doc2()
         dd.insert()
         # addToSet on unset field
@@ -372,16 +363,15 @@ class Doc2(BaseDocument):
         dd.save()
         self.assertEqual(1, Doc2.find({'optional.sub': 42}).count())
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_sub_diff(self):
         """Test embedded document diff"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             dot_notation = True
             foo = Field(six.text_type)
             bar = Field(dict)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         d = Doc()
         d.foo = six.u('foo value')
@@ -401,17 +391,16 @@ class Doc(BaseDocument):
                     'bar': {'sub_b': 'b', 'sub_c': 'c'}}
         self.assertTrue(expected == d == Doc.find_one())
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_auto_update(self):
         """Test auto_update keyword workings"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             dot_notation = True
             foo = Field(six.text_type)
             bar = Field(datetime.datetime, auto_update=True)
             moo = Field(int, required=False)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         dt = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
         d = Doc(foo=six.u('foo value'), bar=dt)
@@ -422,14 +411,13 @@ class Doc(BaseDocument):
         d.save()
         self.assertNotEqual(d.bar, dt_after_insert)
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_document_dbref(self):
         """Test get_dbref functionality"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             pass
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         d = Doc()
         self.assertRaises(AssertionError, d.get_dbref)
@@ -439,16 +427,15 @@ class Doc(BaseDocument):
         dd = d.get_collection().database.dereference(dbref)
         self.assertEqual(d['_id'], dd['_id'])
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     @unittest.skipUnless(six.PY2, 'test irrelevant on PY3')
     def test_string_types(self):
         """Test text type case (as mongodb-pymongo returned string type is always unicode)"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             foo = Field(six.binary_type)
             bar = Field(six.text_type)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
         d = Doc(foo=six.binary_type('value \xc3\xbc'), bar=six.u('value \xfc'))
         d.insert()
         dd = Doc.find_one(d['_id'])
@@ -458,22 +445,21 @@ class Doc(BaseDocument):
 
     def test_dbref_getter_methods(self):
         """Test the creation and function of ``get_<field_name>_field`` methods"""
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             foo = Field(six.text_type)
             self = Field(bson.DBRef, required=False, document_class='Doc')
             self2 = Field(bson.DBRef, required=False, document_class='test.test_document.Doc')
             other = Field(bson.DBRef, required=False)
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
         # temporarily attach Doc to module so document class import can find it
         sys.modules[__name__].Doc = Doc
 
         # to test DBRef document class auto discover
         # different naming so it wont clash with other Doc2 defined here
         class XDoc2(BaseDocument):
             pass
-        XDoc2.register(client=client, db='nanotestdb')
+        XDoc2.register(client=PYMONGO_CLIENT, db='nanotestdb')
 
         d = Doc(foo=six.text_type('1337'))
         self.assertTrue(hasattr(d, 'get_self_field'))
@@ -494,7 +480,7 @@ class XDoc2(BaseDocument):
         # new subclass using same collection as XDoc2 to test undecided discover
         class Doc3(BaseDocument):
             pass
-        Doc3.register(client=client, db='nanotestdb', collection='xdoc2')
+        Doc3.register(client=PYMONGO_CLIENT, db='nanotestdb', collection='xdoc2')
 
         self.assertRaises(UnsupportedOperation, d.get_other_field)
 
@@ -504,12 +490,11 @@ class Doc3(BaseDocument):
 
 class IndexTestCase(unittest.TestCase):
     def setUp(self):
-        if PYMONGO_OK:
-            pymongo.MongoClient().drop_database('nanotestdb')
+        if PYMONGO_CLIENT:
+            PYMONGO_CLIENT.drop_database('nanotestdb')
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_index_definitions(self):
-        client = pymongo.MongoClient()
 
         class Doc(BaseDocument):
             dot_notation = True
@@ -521,7 +506,7 @@ class Doc(BaseDocument):
                     [('bar', pymongo.ASCENDING), ('foo', pymongo.DESCENDING)],
                     unique=True),
             ]
-        Doc.register(client=client, db='nanotestdb')
+        Doc.register(client=PYMONGO_CLIENT, db='nanotestdb')
         self.assertEqual(3, len(Doc.get_collection().index_information()))  # 2 + _id
 
         # compare defines indexes vs indexes retured from the database
@@ -537,5 +522,5 @@ class Doc2(Doc):
             __indexes__ = [
                 pymongo.IndexModel('bar'),  # index test on superclass field
             ]
-        Doc2.register(client=client, db='nanotestdb')
+        Doc2.register(client=PYMONGO_CLIENT, db='nanotestdb')
         self.assertEqual(2, len(Doc2.get_collection().index_information()))  # 1 + _id

test/test_document_motor.py

@@ -10,6 +10,8 @@
 from nanomongo.field import Field
 from nanomongo.document import BaseDocument
 
+from . import PYMONGO_CLIENT
+
 try:
     import motor
     MOTOR_CLIENT = motor.MotorClient()
@@ -23,7 +25,7 @@ class MotorDocumentTestCase(tornado.testing.AsyncTestCase):
 
     def setUp(self):
         self.io_loop = tornado.ioloop.IOLoop.current()
-        pymongo.MongoClient().drop_database('nanotestdb')
+        PYMONGO_CLIENT.drop_database('nanotestdb')
 
     @unittest.skipUnless(MOTOR_CLIENT, 'motor not installed or connection refused')
     @unittest.skipIf(SKIP_MOTOR, 'NANOMONGO_SKIP_MOTOR is set')

test/test_py3_sugar.py

@@ -3,12 +3,7 @@
 from nanomongo.document import BaseDocument, Field
 from nanomongo.errors import ConfigurationError
 
-try:
-    import pymongo
-    pymongo.MongoClient()
-    PYMONGO_OK = True
-except ImportError:
-    PYMONGO_OK = False
+from . import PYMONGO_CLIENT
 
 
 class PY3SugarTestCase(unittest.TestCase):
@@ -24,21 +19,19 @@ class Doc(BaseDocument, dot_notation=True):
         d.foo = 'bar'
         self.assertTrue('foo' in d and 'bar' is d.foo)
 
-    @unittest.skipUnless(PYMONGO_OK, 'pymongo not installed or connection refused')
+    @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
     def test_document_register_configuration(self):
         """Test MongoDB client/db/collection config as class kwargs
         """
-        client = pymongo.MongoClient()
 
-        class Doc(BaseDocument, client=client, db='nanomongotest'):
+        class Doc(BaseDocument, client=PYMONGO_CLIENT, db='nanomongotest'):
             pass
 
-        class Doc2(Doc, dot_notation=True, client=client, db='nanomongotest',
-                   collection='othercollection'):
+        class Doc2(Doc, dot_notation=True, client=PYMONGO_CLIENT, db='nanomongotest', collection='othercollection'):
             pass
 
         self.assertTrue(Doc.nanomongo.registered)
-        self.assertEqual(client.nanomongotest.doc, Doc.get_collection())
+        self.assertEqual(PYMONGO_CLIENT.nanomongotest.doc, Doc.get_collection())
         self.assertRaises(ConfigurationError, Doc.register,
-                          **{'client': client, 'db': 'nanomongotest'})
-        self.assertEqual(client.nanomongotest.othercollection, Doc2.get_collection())
+                          **{'client': PYMONGO_CLIENT, 'db': 'nanomongotest'})
+        self.assertEqual(PYMONGO_CLIENT.nanomongotest.othercollection, Doc2.get_collection())