Python utils.rs_or_single_client_noauth函数代码示例

    def test_make_user_readonly(self):
        # "self.client" is logged in as root.
        auth_db = self.client.pymongo_test

        # Make a read-write user.
        auth_db.add_user('jesse', 'pw')
        self.addCleanup(remove_all_users, auth_db)

        # Check that we're read-write by default.
        c = rs_or_single_client_noauth(username='jesse',
                                       password='pw',
                                       authSource='pymongo_test')

        c.pymongo_test.collection.insert_one({})

        # Make the user read-only.
        auth_db.add_user('jesse', 'pw', read_only=True)

        c = rs_or_single_client_noauth(username='jesse',
                                       password='pw',
                                       authSource='pymongo_test')

        self.assertRaises(OperationFailure,
                          c.pymongo_test.collection.insert_one,
                          {})

    def test_db_authenticate_threaded(self):

        db = client_context.client.db
        coll = db.test
        coll.drop()
        coll.insert_one({'_id': 1})

        client_context.create_user(
            'db',
            'user',
            'pass',
            roles=['dbOwner'])
        self.addCleanup(db.command, 'dropUser', 'user')

        db = rs_or_single_client_noauth().db
        db.authenticate('user', 'pass')
        # No error.
        db.authenticate('user', 'pass')

        db = rs_or_single_client_noauth().db
        threads = []
        for _ in range(4):
            threads.append(DBAuthenticateThread(db, 'user', 'pass'))
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()
            self.assertTrue(thread.success)

    def test_auth_from_uri(self):
        self.client.admin.add_user("admin", "pass", roles=["root"])
        self.addCleanup(self.client.admin.remove_user, "admin")
        self.addCleanup(remove_all_users, self.client.pymongo_test)

        self.client.pymongo_test.add_user("user", "pass", roles=["userAdmin", "readWrite"])

        with self.assertRaises(OperationFailure):
            connected(rs_or_single_client("mongodb://a:[email protected]%s:%d" % (host, port)))

        # No error.
        connected(rs_or_single_client_noauth("mongodb://admin:[email protected]%s:%d" % (host, port)))

        # Wrong database.
        uri = "mongodb://admin:[email protected]%s:%d/pymongo_test" % (host, port)
        with self.assertRaises(OperationFailure):
            connected(rs_or_single_client(uri))

        # No error.
        connected(rs_or_single_client_noauth("mongodb://user:[email protected]%s:%d/pymongo_test" % (host, port)))

        # Auth with lazy connection.
        rs_or_single_client(
            "mongodb://user:[email protected]%s:%d/pymongo_test" % (host, port), connect=False
        ).pymongo_test.test.find_one()

        # Wrong password.
        bad_client = rs_or_single_client("mongodb://user:[email protected]%s:%d/pymongo_test" % (host, port), connect=False)

        self.assertRaises(OperationFailure, bad_client.pymongo_test.test.find_one)

    def test_uri_options(self):
        # Test default to admin
        host, port = client_context.host, client_context.port
        client = rs_or_single_client_noauth(
            'mongodb://admin:[email protected]%s:%d' % (host, port))
        self.assertTrue(client.admin.command('dbstats'))

        if client_context.is_rs:
            uri = ('mongodb://admin:[email protected]%s:%d/?replicaSet=%s' % (
                host, port, client_context.replica_set_name))
            client = single_client_noauth(uri)
            self.assertTrue(client.admin.command('dbstats'))
            db = client.get_database(
                'admin', read_preference=ReadPreference.SECONDARY)
            self.assertTrue(db.command('dbstats'))

        # Test explicit database
        uri = 'mongodb://user:[email protected]%s:%d/pymongo_test' % (host, port)
        client = rs_or_single_client_noauth(uri)
        self.assertRaises(OperationFailure, client.admin.command, 'dbstats')
        self.assertTrue(client.pymongo_test.command('dbstats'))

        if client_context.is_rs:
            uri = ('mongodb://user:[email protected]%s:%d/pymongo_test?replicaSet=%s' % (
                host, port, client_context.replica_set_name))
            client = single_client_noauth(uri)
            self.assertRaises(OperationFailure,
                              client.admin.command, 'dbstats')
            self.assertTrue(client.pymongo_test.command('dbstats'))
            db = client.get_database(
                'pymongo_test', read_preference=ReadPreference.SECONDARY)
            self.assertTrue(db.command('dbstats'))

        # Test authSource
        uri = ('mongodb://user:[email protected]%s:%d'
               '/pymongo_test2?authSource=pymongo_test' % (host, port))
        client = rs_or_single_client_noauth(uri)
        self.assertRaises(OperationFailure,
                          client.pymongo_test2.command, 'dbstats')
        self.assertTrue(client.pymongo_test.command('dbstats'))

        if client_context.is_rs:
            uri = ('mongodb://user:[email protected]%s:%d/pymongo_test2?replicaSet='
                   '%s;authSource=pymongo_test' % (
                host, port, client_context.replica_set_name))
            client = single_client_noauth(uri)
            self.assertRaises(OperationFailure,
                              client.pymongo_test2.command, 'dbstats')
            self.assertTrue(client.pymongo_test.command('dbstats'))
            db = client.get_database(
                'pymongo_test', read_preference=ReadPreference.SECONDARY)
            self.assertTrue(db.command('dbstats'))

 def test_delegated_auth(self):
     self.client.pymongo_test2.foo.drop()
     self.client.pymongo_test2.foo.insert_one({})
     # User definition with no roles in pymongo_test.
     self.client.pymongo_test.add_user('user', 'pass', roles=[])
     # Delegate auth to pymongo_test.
     self.client.pymongo_test2.add_user('user',
                                        userSource='pymongo_test',
                                        roles=['read'])
     auth_c = rs_or_single_client_noauth()
     self.assertRaises(OperationFailure,
                       auth_c.pymongo_test2.foo.find_one)
     # Auth must occur on the db where the user is defined.
     self.assertRaises(OperationFailure,
                       auth_c.pymongo_test2.authenticate,
                       'user', 'pass')
     # Auth directly
     self.assertTrue(auth_c.pymongo_test.authenticate('user', 'pass'))
     self.assertTrue(auth_c.pymongo_test2.foo.find_one())
     auth_c.pymongo_test.logout()
     self.assertRaises(OperationFailure,
                       auth_c.pymongo_test2.foo.find_one)
     # Auth using source
     self.assertTrue(auth_c.pymongo_test2.authenticate(
         'user', 'pass', source='pymongo_test'))
     self.assertTrue(auth_c.pymongo_test2.foo.find_one())
     # Must logout from the db authenticate was called on.
     auth_c.pymongo_test2.logout()
     self.assertRaises(OperationFailure,
                       auth_c.pymongo_test2.foo.find_one)

    def test_multiple_logins(self):
        self.client.pymongo_test.add_user('user1', 'pass', roles=['readWrite'])
        self.client.pymongo_test.add_user('user2', 'pass', roles=['readWrite'])
        self.addCleanup(remove_all_users, self.client.pymongo_test)

        client = rs_or_single_client_noauth(
            "mongodb://user1:[email protected]%s:%d/pymongo_test" % (host, port))

        client.pymongo_test.test.find_one()
        with self.assertRaises(OperationFailure):
            # Can't log in to the same database with multiple users.
            client.pymongo_test.authenticate('user2', 'pass')

        client.pymongo_test.test.find_one()
        client.pymongo_test.logout()
        with self.assertRaises(OperationFailure):
            client.pymongo_test.test.find_one()

        client.pymongo_test.authenticate('user2', 'pass')
        client.pymongo_test.test.find_one()

        with self.assertRaises(OperationFailure):
            client.pymongo_test.authenticate('user1', 'pass')

        client.pymongo_test.test.find_one()

        def check_auth(username, password):
            c = rs_or_single_client_noauth(
                username=username,
                password=password,
                authSource="pymongo_test")

            c.pymongo_test.collection.find_one()

 def test_readonly(self):
     # We test that an authorization failure aborts the batch and is raised
     # as OperationFailure.
     cli = rs_or_single_client_noauth(username='readonly', password='pw',
                                      authSource='pymongo_test')
     coll = cli.pymongo_test.test
     coll.find_one()
     self.assertRaises(OperationFailure, coll.bulk_write,
                       [InsertOne({'x': 1})])

 def test_readonly(self):
     # We test that an authorization failure aborts the batch and is raised
     # as OperationFailure.
     cli = rs_or_single_client_noauth()
     db = cli.pymongo_test
     coll = db.test
     db.authenticate('readonly', 'pw')
     bulk = coll.initialize_ordered_bulk_op()
     bulk.insert({'x': 1})
     self.assertRaises(OperationFailure, bulk.execute)

    def test_gridfs_readonly(self):
        # "self.client" is logged in as root. Make a read-only user.
        auth_db = self.client.test_gridfs_readonly
        auth_db.add_user('readonly', 'pw', readOnly=True)
        self.addCleanup(remove_all_users, auth_db)

        db = rs_or_single_client_noauth().test_gridfs_readonly
        db.authenticate('readonly', 'pw')

        fs = gridfs.GridFS(db)
        file = fs.new_file()
        file._ensure_index()
        fs.list()

    def test_scram_sha1(self):
        host, port = client_context.host, client_context.port
        client = rs_or_single_client_noauth()
        self.assertTrue(client.pymongo_test.authenticate(
            'user', 'pass', mechanism='SCRAM-SHA-1'))
        client.pymongo_test.command('dbstats')

        client = rs_or_single_client_noauth(
            'mongodb://user:[email protected]%s:%d/pymongo_test?authMechanism=SCRAM-SHA-1'
            % (host, port))
        client.pymongo_test.command('dbstats')

        if client_context.is_rs:
            uri = ('mongodb://user:pass'
                   '@%s:%d/pymongo_test?authMechanism=SCRAM-SHA-1'
                   '&replicaSet=%s' % (host, port,
                                       client_context.replica_set_name))
            client = single_client_noauth(uri)
            client.pymongo_test.command('dbstats')
            db = client.get_database(
                'pymongo_test', read_preference=ReadPreference.SECONDARY)
            db.command('dbstats')

    def test_authenticate_multiple(self):
        # "self.client" is logged in as root.
        self.client.drop_database("pymongo_test")
        self.client.drop_database("pymongo_test1")
        admin_db_auth = self.client.admin
        users_db_auth = self.client.pymongo_test

        # Non-root client.
        client = rs_or_single_client_noauth()
        admin_db = client.admin
        users_db = client.pymongo_test
        other_db = client.pymongo_test1

        self.assertRaises(OperationFailure, users_db.test.find_one)

        if client_context.version.at_least(2, 5, 3, -1):
            admin_db_auth.add_user('ro-admin', 'pass',
                                   roles=["userAdmin", "readAnyDatabase"])
        else:
            admin_db_auth.add_user('ro-admin', 'pass', read_only=True)

        self.addCleanup(admin_db_auth.remove_user, 'ro-admin')
        users_db_auth.add_user('user', 'pass',
                               roles=["userAdmin", "readWrite"])
        self.addCleanup(remove_all_users, users_db_auth)

        # Regular user should be able to query its own db, but
        # no other.
        users_db.authenticate('user', 'pass')
        self.assertEqual(0, users_db.test.count())
        self.assertRaises(OperationFailure, other_db.test.find_one)

        # Admin read-only user should be able to query any db,
        # but not write.
        admin_db.authenticate('ro-admin', 'pass')
        self.assertEqual(None, other_db.test.find_one())
        self.assertRaises(OperationFailure,
                          other_db.test.insert_one, {})

        # Close all sockets.
        client.close()

        # We should still be able to write to the regular user's db.
        self.assertTrue(users_db.test.delete_many({}))

        # And read from other dbs...
        self.assertEqual(0, other_db.test.count())

        # But still not write to other dbs.
        self.assertRaises(OperationFailure,
                          other_db.test.insert_one, {})

 def test_no_remove(self):
     # We test that an authorization failure aborts the batch and is raised
     # as OperationFailure.
     cli = rs_or_single_client_noauth()
     db = cli.pymongo_test
     coll = db.test
     db.authenticate('noremove', 'pw')
     bulk = coll.initialize_ordered_bulk_op()
     bulk.insert({'x': 1})
     bulk.find({'x': 2}).upsert().replace_one({'x': 2})
     bulk.find({}).remove()  # Prohibited.
     bulk.insert({'x': 3})   # Never attempted.
     self.assertRaises(OperationFailure, bulk.execute)
     self.assertEqual(set([1, 2]), set(self.coll.distinct('x')))

 def test_no_remove(self):
     # We test that an authorization failure aborts the batch and is raised
     # as OperationFailure.
     cli = rs_or_single_client_noauth(username='noremove', password='pw',
                                      authSource='pymongo_test')
     coll = cli.pymongo_test.test
     coll.find_one()
     requests = [
         InsertOne({'x': 1}),
         ReplaceOne({'x': 2}, {'x': 2}, upsert=True),
         DeleteMany({}),       # Prohibited.
         InsertOne({'x': 3}),  # Never attempted.
     ]
     self.assertRaises(OperationFailure, coll.bulk_write, requests)
     self.assertEqual(set([1, 2]), set(self.coll.distinct('x')))

    def setUp(self):
        client = rs_or_single_client_noauth()
        client_context.client.admin.add_user('admin', 'pass',
                                             roles=['userAdminAnyDatabase',
                                                    'dbAdminAnyDatabase',
                                                    'readWriteAnyDatabase',
                                                    'clusterAdmin'])
        client.admin.authenticate('admin', 'pass')
        client.pymongo_test.add_user('user', 'pass',
                                     roles=['userAdmin', 'readWrite'])

        if client_context.is_rs:
            # Make sure the admin user is replicated after calling add_user
            # above. This avoids a race in the replica set tests below.
            client.admin.command('getLastError', w=client_context.w)
        self.client = client