Python test_connection.get_connection函数代码示例

    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 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_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 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_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 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_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 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 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": 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 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 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 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)))