def test_multiple_connections(self): a = get_connection() b = get_connection() self.assertEqual(0, len(a._Connection__pool.sockets)) self.assertEqual(0, len(b._Connection__pool.sockets)) a.test.test.find_one() a.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(0, len(b._Connection__pool.sockets)) a_sock = a._Connection__pool.sockets[0] b.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(0, len(b._Connection__pool.sockets)) b.test.test.find_one() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(0, len(b._Connection__pool.sockets)) b.end_request() b_sock = b._Connection__pool.sockets[0] b.test.test.find_one() a.test.test.find_one() self.assertEqual(b_sock, b._Connection__pool.socket()) self.assertEqual(a_sock, a._Connection__pool.socket())
def test_multiple_connections(self): a = get_connection() b = get_connection() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(1, len(b._Connection__pool.sockets)) a.test.test.find_one() a.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(1, len(b._Connection__pool.sockets)) a_sock = a._Connection__pool.sockets[0] b.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(1, len(b._Connection__pool.sockets)) b.test.test.find_one() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(0, len(b._Connection__pool.sockets)) b.end_request() b_sock = b._Connection__pool.sockets[0] b.test.test.find_one() a.test.test.find_one() self.assertEqual(b_sock, b._Connection__pool.get_socket(b.host, b.port)) self.assertEqual(a_sock, a._Connection__pool.get_socket(a.host, a.port))
def test_multiple_connections(self): a = get_connection(auto_start_request=False) b = get_connection(auto_start_request=False) self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(1, len(b._Connection__pool.sockets)) a.start_request() a.test.test.find_one() self.assertEqual(0, len(a._Connection__pool.sockets)) a.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(1, len(b._Connection__pool.sockets)) a_sock = one(a._Connection__pool.sockets) b.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(1, len(b._Connection__pool.sockets)) b.start_request() b.test.test.find_one() self.assertEqual(1, len(a._Connection__pool.sockets)) self.assertEqual(0, len(b._Connection__pool.sockets)) b.end_request() b_sock = one(b._Connection__pool.sockets) b.test.test.find_one() a.test.test.find_one() self.assertEqual(b_sock, b._Connection__pool.get_socket((b.host, b.port))) self.assertEqual(a_sock, a._Connection__pool.get_socket((a.host, a.port)))
def test_auto_auth_login(self): conn = get_connection() self.assertRaises(OperationFailure, conn.auth_test.test.find_one) # Admin auth conn = get_connection() conn.admin.authenticate("admin-user", "password") threads = [] for _ in xrange(10): t = AutoAuthenticateThreads(conn.auth_test.test, 100) t.start() threads.append(t) for t in threads: t.join() self.assertTrue(t.success) # Database-specific auth conn = get_connection() conn.auth_test.authenticate("test-user", "password") threads = [] for _ in xrange(10): t = AutoAuthenticateThreads(conn.auth_test.test, 100) t.start() threads.append(t) for t in threads: t.join() self.assertTrue(t.success)
def setUp(self): self.db = get_connection().pymongo_test self.db.drop_collection("fs.files") self.db.drop_collection("fs.chunks") self.db.drop_collection("pymongo_test.files") self.db.drop_collection("pymongo_test.chunks") self.fs = gridfs.GridFS(self.db)
def test_auto_auth_login(self): conn = get_connection() try: conn.auth_test.test.find_one() assert False # Find should have failed except OperationFailure, e: pass
def test_uuid_queries(self): if not should_test_uuid: raise SkipTest() c = get_connection() coll = c.pymongo_test.test coll.drop() uu = uuid.uuid4() coll.insert({'uuid': Binary(uu.bytes, 3)}) self.assertEqual(1, coll.count()) # Test UUIDLegacy queries. coll.uuid_subtype = 4 self.assertEqual(0, coll.find({'uuid': uu}).count()) cur = coll.find({'uuid': UUIDLegacy(uu)}) self.assertEqual(1, cur.count()) retrieved = cur.next()['uuid'] self.assertEqual(uu, retrieved) # Test regular UUID queries (using subtype 4). coll.insert({'uuid': uu}) self.assertEqual(2, coll.count()) cur = coll.find({'uuid': uu}) self.assertEqual(1, cur.count()) self.assertEqual(uu, cur.next()['uuid']) # Test both. cur = coll.find({'uuid': {'$in': [uu, UUIDLegacy(uu)]}}) self.assertEqual(2, cur.count()) coll.drop()
def setUp(self): self.c = get_connection() # reset the db self.c.drop_database(DB) self.c[DB].unique.insert({"_id": "mike"}) self.c[DB].unique.find_one()
def loop(pipe): c = get_connection() self.assertEqual(0, len(c._Connection__pool.sockets)) c.test.test.find_one() c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) pipe.send(c._Connection__pool.sockets[0].getsockname())
def setUp(self): self.c = get_connection(auto_start_request=False) # reset the db self.c.drop_database(DB) self.c[DB].unique.insert({"_id": "mike"}) self.c[DB].test.insert([{} for i in range(1000)])
def test_pool_with_greenlets(self): try: from greenlet import greenlet except ImportError: raise SkipTest() c = get_connection() c.test.test.find_one() c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) a_sock = c._Connection__pool.sockets[0] def loop(name, pipe): c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets)) greenlet.getcurrent().parent.switch() c.end_request() pipe.append(c._Connection__pool.sockets[-1]) ga1 = [] ga2 = [] g1 = greenlet(loop) g2 = greenlet(loop) g1.switch('g1', ga1) g2.switch('g2', ga2) g1.switch() g2.switch() b_sock = ga1[0] c_sock = ga2[0] self.assert_(a_sock is b_sock) self.assert_(a_sock is not c_sock) self.assert_(b_sock is not c_sock)
def test_uuid_queries(self): if not should_test_uuid: raise SkipTest() c = get_connection() coll = c.pymongo_test.test coll.drop() uu = uuid.uuid4() coll.insert({"uuid": uuid.uuid4()}) coll.insert({"uuid": uuid.uuid4()}) coll.insert({"uuid": Binary(uu.bytes, 3)}) # Test UUIDLegacy queries. self.assertEquals(0, coll.find({"uuid": uu}).count()) cur = coll.find({"uuid": UUIDLegacy(uu)}) self.assertEquals(1, cur.count()) retrieved = cur.next()["uuid"] self.assertEquals(uu, retrieved) # Test regular UUID queries. coll.insert({"uuid": uu}) cur = coll.find({"uuid": uu}) self.assertEquals(1, cur.count()) self.assertEquals(uu, cur.next()["uuid"]) # Test both. cur = coll.find({"uuid": {"$in": [uu, UUIDLegacy(uu)]}}) self.assertEquals(2, cur.count()) coll.drop()
def teardown(): c = get_connection() c.drop_database("pymongo-pooling-tests") c.drop_database("pymongo_test") c.drop_database("pymongo_test1") c.drop_database("pymongo_test2") c.drop_database("pymongo_test_mike")
def _get_connection(self): """ Intended for overriding in TestThreadsAuthReplicaSet. This method returns a Connection here, and a ReplicaSetConnection in test_threads_replica_set_connection.py. """ # Regular test connection return get_connection()
def loop(pipe): c = get_connection() self.assertEqual(1, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets)) c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) pipe.send(c._Connection__pool.sockets[0].getsockname())
def setUp(self): self.c = get_connection(auto_start_request=False) # reset the db db = self.c[DB] db.unique.drop() db.test.drop() db.unique.insert({"_id": "mike"}) db.test.insert([{} for i in range(1000)])
def test_pool_with_fork(self): # Test that separate Connections have separate Pools, and that the # driver can create a new Connection after forking if sys.platform == "win32": raise SkipTest("Can't test forking on Windows") try: from multiprocessing import Process, Pipe except ImportError: raise SkipTest("No multiprocessing module") a = get_connection(auto_start_request=False) a.test.test.remove(safe=True) a.test.test.insert({'_id':1}, safe=True) a.test.test.find_one() self.assertEqual(1, len(a._Connection__pool.sockets)) a_sock = one(a._Connection__pool.sockets) def loop(pipe): c = get_connection(auto_start_request=False) self.assertEqual(1,len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(1,len(c._Connection__pool.sockets)) pipe.send(one(c._Connection__pool.sockets).sock.getsockname()) cp1, cc1 = Pipe() cp2, cc2 = Pipe() p1 = Process(target=loop, args=(cc1,)) p2 = Process(target=loop, args=(cc2,)) p1.start() p2.start() p1.join(1) p2.join(1) p1.terminate() p2.terminate() p1.join() p2.join() cc1.close() cc2.close() b_sock = cp1.recv() c_sock = cp2.recv() self.assertTrue(a_sock.sock.getsockname() != b_sock) self.assertTrue(a_sock.sock.getsockname() != c_sock) self.assertTrue(b_sock != c_sock) self.assertEqual(a_sock, a._Connection__pool.get_socket((a.host, a.port)))
def test_pool_with_fork(self): if sys.platform == "win32": raise SkipTest() try: from multiprocessing import Process, Pipe except ImportError: raise SkipTest() a = get_connection() a.test.test.find_one() a.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) a_sock = a._Connection__pool.sockets[0] def loop(pipe): c = get_connection() self.assertEqual(1, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets)) c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) pipe.send(c._Connection__pool.sockets[0].getsockname()) cp1, cc1 = Pipe() cp2, cc2 = Pipe() p1 = Process(target=loop, args=(cc1, )) p2 = Process(target=loop, args=(cc2, )) p1.start() p2.start() p1.join(1) p2.join(1) p1.terminate() p2.terminate() p1.join() p2.join() cc1.close() cc2.close() b_sock = cp1.recv() c_sock = cp2.recv() self.assert_(a_sock.getsockname() != b_sock) self.assert_(a_sock.getsockname() != c_sock) self.assert_(b_sock != c_sock) self.assertEqual(a_sock, a._Connection__pool.get_socket(a.host, a.port))
def test_pool_with_fork(self): if sys.platform == "win32": raise SkipTest() try: from multiprocessing import Process, Pipe except ImportError: raise SkipTest() a = get_connection() a.test.test.find_one() a.end_request() self.assertEqual(1, len(a._Connection__pool.sockets)) a_sock = a._Connection__pool.sockets[0] def loop(pipe): c = get_connection() self.assertEqual(1, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets)) c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) pipe.send(c._Connection__pool.sockets[0].getsockname()) cp1, cc1 = Pipe() cp2, cc2 = Pipe() p1 = Process(target=loop, args=(cc1,)) p2 = Process(target=loop, args=(cc2,)) p1.start() p2.start() p1.join(1) p2.join(1) p1.terminate() p2.terminate() p1.join() p2.join() cc1.close() cc2.close() b_sock = cp1.recv() c_sock = cp2.recv() self.assert_(a_sock.getsockname() != b_sock) self.assert_(a_sock.getsockname() != c_sock) self.assert_(b_sock != c_sock) self.assertEqual(a_sock, a._Connection__pool.get_socket(a.host, a.port)[0])
def test_max_pool_size(self): c = get_connection() threads = [] for i in range(40): t = CreateAndReleaseSocket(c) t.start() threads.append(t) for t in threads: t.join() # There's a race condition, so be lenient self.assert_(abs(10 - len(c._Connection__pool.sockets)) < 10)
def test_max_pool_size(self): c = get_connection(max_pool_size=4) threads = [] for i in range(40): t = CreateAndReleaseSocket(c) t.start() threads.append(t) for t in threads: t.join() # There's a race condition, so be lenient self.assert_(abs(4 - len(c._Connection__pool.sockets)) < 4)
def test_dependent_pools(self): c = get_connection() self.assertEqual(1, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets)) c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) t = OneOp(c) t.start() t.join() self.assertEqual(1, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets))
def test_dependent_pools(self): c = get_connection() self.assertEqual(0, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets)) c.end_request() self.assertEqual(1, len(c._Connection__pool.sockets)) t = OneOp(c) t.start() t.join() self.assertEqual(1, len(c._Connection__pool.sockets)) c.test.test.find_one() self.assertEqual(0, len(c._Connection__pool.sockets))
def setUp(self): conn = get_connection() self.conn = conn # Setup auth users conn.admin.system.users.remove({}) conn.admin.add_user("admin-user", "password") try: conn.admin.system.users.find_one() # If we reach here auth must be disabled in server self.tearDown() raise SkipTest() except OperationFailure: pass conn.admin.authenticate("admin-user", "password") conn.auth_test.system.users.remove({}) conn.auth_test.add_user("test-user", "password")
def setUp(self): self.conn = get_connection() # Setup auth users self.conn.admin.system.users.remove({}) self.conn.admin.add_user('admin-user', 'password') try: self.conn.admin.system.users.find_one() # If we reach here mongod was likely started # without --auth. Skip this test since it's # pointless without auth enabled. self.tearDown() raise SkipTest() except OperationFailure: pass self.conn.admin.authenticate("admin-user", "password") self.conn.auth_test.system.users.remove({}) self.conn.auth_test.add_user("test-user", "password")
def test_low_network_timeout(self): db = None i = 0 n = 10 while db is None and i < n: try: db = get_connection(network_timeout=0.0001).pymongo_test except AutoReconnect: i += 1 if i == n: raise SkipTest() threads = [] for _ in range(4): t = IgnoreAutoReconnect(db.test, 100) t.start() threads.append(t) for t in threads: t.join()
def setUp(self): self.db = get_connection().pymongo_test
def do_test(): if use_greenlets: try: from gevent import Greenlet from gevent import monkey # Note we don't do patch_thread() or patch_all() - we're # testing here that patch_thread() is unnecessary for # the connection pool to work properly. monkey.patch_socket() except ImportError: outcome.value = SKIP return cx = get_connection( use_greenlets=use_greenlets, auto_start_request=False ) db = cx.pymongo_test db.test.remove(safe=True) db.test.insert({'_id': 1}) history = [] def find_fast(): if use_request: cx.start_request() history.append('find_fast start') # With the old connection._Pool, this would throw # AssertionError: "This event is already used by another # greenlet" results['find_fast_result'] = list(db.test.find()) history.append('find_fast done') if use_request: cx.end_request() def find_slow(): if use_request: cx.start_request() history.append('find_slow start') # Javascript function that pauses for half a second where = delay(0.5) results['find_slow_result'] = list(db.test.find( {'$where': where} )) history.append('find_slow done') if use_request: cx.end_request() if use_greenlets: gr0, gr1 = Greenlet(find_slow), Greenlet(find_fast) gr0.start() gr1.start_later(.1) else: gr0 = threading.Thread(target=find_slow) gr1 = threading.Thread(target=find_fast) gr0.start() time.sleep(0.1) gr1.start() gr0.join() gr1.join() self.assertEqual([{'_id': 1}], results['find_slow_result']) # Fails, since find_fast doesn't complete self.assertEqual([{'_id': 1}], results['find_fast_result']) self.assertEqual([ 'find_slow start', 'find_fast start', 'find_fast done', 'find_slow done', ], history) outcome.value = SUCCESS
def setUp(self): self.db = get_connection().pymongo_test self.db.fs.files.remove({}) self.db.fs.chunks.remove({})
def setUp(self): self.db = get_connection(timeout=-1).pymongo_test
def setUp(self): self.connection = get_connection() self.db = self.connection.pymongo_test
def test_max_pool_size_with_end_request_only(self): # Call end_request() but not start_request() c = get_connection(max_pool_size=4, auto_start_request=False) self._test_max_pool_size(c, 0, 1)
def setUp(self): self.connection = get_connection()
def test_max_pool_size_with_leaked_request(self): # Call start_request() but not end_request() -- when threads die, they # should return their request sockets to the pool. c = get_connection(max_pool_size=4, auto_start_request=False) self._test_max_pool_size(c, 1, 0)
def setUp(self): self.db = Database(get_connection(), "pymongo_test")