Python MongoBackend._get_connection方法代码示例

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
 def test_get_database_authfailure(self):
     x = MongoBackend(app=self.app)
     x._get_connection = Mock()
     conn = x._get_connection.return_value = {}
     db = conn[x.database_name] = Mock()
     db.authenticate.return_value = False
     x.user = 'jerry'
     x.password = 'cere4l'
     with self.assertRaises(ImproperlyConfigured):
         x._get_database()
     db.authenticate.assert_called_with('jerry', 'cere4l')

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
 def test_get_database_authfailure(self):
     x = MongoBackend()
     x._get_connection = Mock()
     conn = x._get_connection.return_value = {}
     db = conn[x.mongodb_database] = Mock()
     db.authenticate.return_value = False
     x.mongodb_user = "jerry"
     x.mongodb_password = "cere4l"
     with self.assertRaises(ImproperlyConfigured):
         x._get_database()
     db.authenticate.assert_called_with("jerry", "cere4l")

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
class TestBackendMongoDb(Case):

    def setUp(self):
        if pymongo is None:
            raise SkipTest("pymongo is not installed.")
        from pymongo import binary

        R = self._reset = {}
        R["encode"], MongoBackend.encode = MongoBackend.encode, Mock()
        R["decode"], MongoBackend.decode = MongoBackend.decode, Mock()
        R["Binary"], binary.Binary = binary.Binary, Mock()
        R["datetime"], datetime.datetime = datetime.datetime, Mock()

        self.backend = MongoBackend()

    def tearDown(self):
        from pymongo import binary
        MongoBackend.encode = self._reset["encode"]
        MongoBackend.decode = self._reset["decode"]
        binary.Binary = self._reset["Binary"]
        datetime.datetime = self._reset["datetime"]

    def test_get_connection_connection_exists(self):

        @patch("pymongo.connection.Connection")
        def do_test(mock_Connection):
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEquals(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)
        do_test()

    def test_get_connection_no_connection_host(self):

        @patch("pymongo.connection.Connection")
        def do_test(mock_Connection):
            self.backend._connection = None
            self.backend.mongodb_host = MONGODB_HOST
            self.backend.mongodb_port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                MONGODB_HOST, MONGODB_PORT)
            self.assertEquals(sentinel.connection, connection)
        do_test()

    def test_get_connection_no_connection_mongodb_uri(self):

        @patch("pymongo.connection.Connection")
        def do_test(mock_Connection):
            mongodb_uri = "mongodb://%s:%d" % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.mongodb_host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(mongodb_uri)
            self.assertEquals(sentinel.connection, connection)
        do_test()

    @patch("celery.backends.mongodb.MongoBackend._get_connection")
    def test_get_database_no_existing(self, mock_get_connection):
        # Should really check for combinations of these two, to be complete.
        self.backend.mongodb_user = MONGODB_USER
        self.backend.mongodb_password = MONGODB_PASSWORD

        mock_database = Mock()
        mock_connection = MagicMock(spec=['__getitem__'])
        mock_connection.__getitem__.return_value = mock_database
        mock_get_connection.return_value = mock_connection

        database = self.backend.database

        self.assertTrue(database is mock_database)
        self.assertTrue(self.backend.__dict__["database"] is mock_database)
        mock_database.authenticate.assert_called_once_with(
            MONGODB_USER, MONGODB_PASSWORD)

    @patch("celery.backends.mongodb.MongoBackend._get_connection")
    def test_get_database_no_existing_no_auth(self, mock_get_connection):
        # Should really check for combinations of these two, to be complete.
        self.backend.mongodb_user = None
        self.backend.mongodb_password = None

        mock_database = Mock()
        mock_connection = MagicMock(spec=['__getitem__'])
        mock_connection.__getitem__.return_value = mock_database
        mock_get_connection.return_value = mock_connection

        database = self.backend.database

        self.assertTrue(database is mock_database)
        self.assertFalse(mock_database.authenticate.called)
        self.assertTrue(self.backend.__dict__["database"] is mock_database)

    def test_process_cleanup(self):
#.........这里部分代码省略.........

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
class test_MongoBackend(AppCase):

    def setup(self):
        if pymongo is None:
            raise SkipTest('pymongo is not installed.')

        R = self._reset = {}
        R['encode'], MongoBackend.encode = MongoBackend.encode, Mock()
        R['decode'], MongoBackend.decode = MongoBackend.decode, Mock()
        R['Binary'], module.Binary = module.Binary, Mock()
        R['datetime'], datetime.datetime = datetime.datetime, Mock()

        self.backend = MongoBackend(app=self.app)

    def teardown(self):
        MongoBackend.encode = self._reset['encode']
        MongoBackend.decode = self._reset['decode']
        module.Binary = self._reset['Binary']
        datetime.datetime = self._reset['datetime']

    def test_Bunch(self):
        x = Bunch(foo='foo', bar=2)
        self.assertEqual(x.foo, 'foo')
        self.assertEqual(x.bar, 2)

    def test_init_no_mongodb(self):
        prev, module.pymongo = module.pymongo, None
        try:
            with self.assertRaises(ImproperlyConfigured):
                MongoBackend(app=self.app)
        finally:
            module.pymongo = prev

    def test_init_no_settings(self):
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = []
        with self.assertRaises(ImproperlyConfigured):
            MongoBackend(app=self.app)

    def test_init_settings_is_None(self):
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
        MongoBackend(app=self.app)

    def test_restore_group_no_entry(self):
        x = MongoBackend(app=self.app)
        x.collection = Mock()
        fo = x.collection.find_one = Mock()
        fo.return_value = None
        self.assertIsNone(x._restore_group('1f3fab'))

    @depends_on_current_app
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEqual(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)

    def test_get_connection_no_connection_host(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = None
            self.backend.host = MONGODB_HOST
            self.backend.port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host='mongodb://localhost:27017', ssl=False, max_pool_size=10,
                auto_start_request=False)
            self.assertEqual(sentinel.connection, connection)

    def test_get_connection_no_connection_mongodb_uri(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            mongodb_uri = 'mongodb://%s:%d' % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host=mongodb_uri, ssl=False, max_pool_size=10,
                auto_start_request=False)
            self.assertEqual(sentinel.connection, connection)

    @patch('celery.backends.mongodb.MongoBackend._get_connection')
    def test_get_database_no_existing(self, mock_get_connection):
        # Should really check for combinations of these two, to be complete.
        self.backend.user = MONGODB_USER
        self.backend.password = MONGODB_PASSWORD

        mock_database = Mock()
#.........这里部分代码省略.........

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]

#.........这里部分代码省略.........
        )
        self.assertEqual(mb.user, 'celeryuser')
        self.assertEqual(mb.password, 'celerypassword')
        self.assertEqual(mb.database_name, 'celerydatabase')

        # same uri, change some parameters in backend settings
        self.app.conf.mongodb_backend_settings = {
            'replicaset': 'rs1',
            'user': 'backenduser',
            'database': 'another_db',
            'options': {
                'socketKeepAlive': True,
            },
        }
        mb = MongoBackend(app=self.app, url=uri)
        self.assertEqual(mb.mongo_host, ['mongo1.example.com:27017',
                                         'mongo2.example.com:27017',
                                         'mongo3.example.com:27017'])
        self.assertEqual(
            mb.options, dict(mb._prepare_client_options(),
                             replicaset='rs1', socketKeepAlive=True),
        )
        self.assertEqual(mb.user, 'backenduser')
        self.assertEqual(mb.password, 'celerypassword')
        self.assertEqual(mb.database_name, 'another_db')

        mb = MongoBackend(app=self.app, url='mongodb://')

    @depends_on_current_app
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):
        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEqual(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)

    def test_get_connection_no_connection_host(self):
        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = None
            self.backend.host = MONGODB_HOST
            self.backend.port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host='mongodb://localhost:27017',
                **self.backend._prepare_client_options()
            )
            self.assertEqual(sentinel.connection, connection)

    def test_get_connection_no_connection_mongodb_uri(self):
        with patch('pymongo.MongoClient') as mock_Connection:
            mongodb_uri = 'mongodb://%s:%d' % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
class test_MongoBackend(AppCase):
    def setup(self):
        if pymongo is None:
            raise SkipTest("pymongo is not installed.")

        R = self._reset = {}
        R["encode"], MongoBackend.encode = MongoBackend.encode, Mock()
        R["decode"], MongoBackend.decode = MongoBackend.decode, Mock()
        R["Binary"], module.Binary = module.Binary, Mock()
        R["datetime"], datetime.datetime = datetime.datetime, Mock()

        self.backend = MongoBackend(app=self.app)

    def teardown(self):
        MongoBackend.encode = self._reset["encode"]
        MongoBackend.decode = self._reset["decode"]
        module.Binary = self._reset["Binary"]
        datetime.datetime = self._reset["datetime"]

    def test_Bunch(self):
        x = Bunch(foo="foo", bar=2)
        self.assertEqual(x.foo, "foo")
        self.assertEqual(x.bar, 2)

    def test_init_no_mongodb(self):
        prev, module.pymongo = module.pymongo, None
        try:
            with self.assertRaises(ImproperlyConfigured):
                MongoBackend(app=self.app)
        finally:
            module.pymongo = prev

    def test_init_no_settings(self):
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = []
        with self.assertRaises(ImproperlyConfigured):
            MongoBackend(app=self.app)

    def test_init_settings_is_None(self):
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
        MongoBackend(app=self.app)

    def test_restore_group_no_entry(self):
        x = MongoBackend(app=self.app)
        x.collection = Mock()
        fo = x.collection.find_one = Mock()
        fo.return_value = None
        self.assertIsNone(x._restore_group("1f3fab"))

    @depends_on_current_app
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):

        with patch("pymongo.MongoClient") as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEqual(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)

    def test_get_connection_no_connection_host(self):

        with patch("pymongo.MongoClient") as mock_Connection:
            self.backend._connection = None
            self.backend.host = MONGODB_HOST
            self.backend.port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host="mongodb://localhost:27017", **self.backend._prepare_client_options()
            )
            self.assertEqual(sentinel.connection, connection)

    def test_get_connection_no_connection_mongodb_uri(self):

        with patch("pymongo.MongoClient") as mock_Connection:
            mongodb_uri = "mongodb://%s:%d" % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(host=mongodb_uri, **self.backend._prepare_client_options())
            self.assertEqual(sentinel.connection, connection)

    @patch("celery.backends.mongodb.MongoBackend._get_connection")
    def test_get_database_no_existing(self, mock_get_connection):
        # Should really check for combinations of these two, to be complete.
        self.backend.user = MONGODB_USER
        self.backend.password = MONGODB_PASSWORD

        mock_database = Mock()
        mock_connection = MagicMock(spec=["__getitem__"])
        mock_connection.__getitem__.return_value = mock_database
        mock_get_connection.return_value = mock_connection
#.........这里部分代码省略.........

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
class test_MongoBackend(AppCase):

    default_url = 'mongodb://uuuu:[email protected]/database'
    replica_set_url = (
        'mongodb://uuuu:[email protected],'
        'hostname.dom/database?replicaSet=rs'
    )
    sanitized_default_url = 'mongodb://uuuu:**@hostname.dom/database'
    sanitized_replica_set_url = (
        'mongodb://uuuu:**@hostname.dom/,'
        'hostname.dom/database?replicaSet=rs'
    )

    def setup(self):
        if pymongo is None:
            raise SkipTest('pymongo is not installed.')

        R = self._reset = {}
        R['encode'], MongoBackend.encode = MongoBackend.encode, Mock()
        R['decode'], MongoBackend.decode = MongoBackend.decode, Mock()
        R['Binary'], module.Binary = module.Binary, Mock()
        R['datetime'], datetime.datetime = datetime.datetime, Mock()

        self.backend = MongoBackend(app=self.app, url=self.default_url)

    def teardown(self):
        MongoBackend.encode = self._reset['encode']
        MongoBackend.decode = self._reset['decode']
        module.Binary = self._reset['Binary']
        datetime.datetime = self._reset['datetime']

    def test_init_no_mongodb(self):
        prev, module.pymongo = module.pymongo, None
        try:
            with self.assertRaises(ImproperlyConfigured):
                MongoBackend(app=self.app)
        finally:
            module.pymongo = prev

    def test_init_no_settings(self):
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = []
        with self.assertRaises(ImproperlyConfigured):
            MongoBackend(app=self.app)

    def test_init_settings_is_None(self):
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
        MongoBackend(app=self.app)

    def test_restore_group_no_entry(self):
        x = MongoBackend(app=self.app)
        x.collection = Mock()
        fo = x.collection.find_one = Mock()
        fo.return_value = None
        self.assertIsNone(x._restore_group('1f3fab'))

    @depends_on_current_app
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEqual(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)

    def test_get_connection_no_connection_host(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = None
            self.backend.host = MONGODB_HOST
            self.backend.port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host='mongodb://localhost:27017',
                **self.backend._prepare_client_options()
            )
            self.assertEqual(sentinel.connection, connection)

    def test_get_connection_no_connection_mongodb_uri(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            mongodb_uri = 'mongodb://%s:%d' % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host=mongodb_uri, **self.backend._prepare_client_options()
            )
            self.assertEqual(sentinel.connection, connection)

#.........这里部分代码省略.........

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]

#.........这里部分代码省略.........
        assert mb.database_name == 'celerydatabase'

        # same uri, change some parameters in backend settings
        self.app.conf.mongodb_backend_settings = {
            'replicaset': 'rs1',
            'user': 'backenduser',
            'database': 'another_db',
            'options': {
                'socketKeepAlive': True,
            },
        }
        mb = MongoBackend(app=self.app, url=uri)
        assert mb.mongo_host == [
            'mongo1.example.com:27017',
            'mongo2.example.com:27017',
            'mongo3.example.com:27017',
        ]
        assert mb.options == dict(
            mb._prepare_client_options(),
            replicaset='rs1',
            socketKeepAlive=True,
        )
        assert mb.user == 'backenduser'
        assert mb.password == 'celerypassword'
        assert mb.database_name == 'another_db'

        mb = MongoBackend(app=self.app, url='mongodb://')

    @pytest.mark.usefixtures('depends_on_current_app')
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        assert loads(dumps(x))

    def test_get_connection_connection_exists(self):
        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            assert sentinel._connection == connection
            mock_Connection.assert_not_called()

    def test_get_connection_no_connection_host(self):
        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = None
            self.backend.host = MONGODB_HOST
            self.backend.port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host='mongodb://localhost:27017',
                **self.backend._prepare_client_options()
            )
            assert sentinel.connection == connection

    def test_get_connection_no_connection_mongodb_uri(self):
        with patch('pymongo.MongoClient') as mock_Connection:
            mongodb_uri = 'mongodb://%s:%d' % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
class test_MongoBackend(AppCase):

    def setUp(self):
        if pymongo is None:
            raise SkipTest("pymongo is not installed.")
        from pymongo import binary

        R = self._reset = {}
        R["encode"], MongoBackend.encode = MongoBackend.encode, Mock()
        R["decode"], MongoBackend.decode = MongoBackend.decode, Mock()
        R["Binary"], binary.Binary = binary.Binary, Mock()
        R["datetime"], datetime.datetime = datetime.datetime, Mock()

        self.backend = MongoBackend()

    def tearDown(self):
        from pymongo import binary
        MongoBackend.encode = self._reset["encode"]
        MongoBackend.decode = self._reset["decode"]
        binary.Binary = self._reset["Binary"]
        datetime.datetime = self._reset["datetime"]

    def test_Bunch(self):
        x = Bunch(foo="foo", bar=2)
        self.assertEqual(x.foo, "foo")
        self.assertEqual(x.bar, 2)

    def test_init_no_mongodb(self):
        prev, module.pymongo = module.pymongo, None
        try:
            with self.assertRaises(ImproperlyConfigured):
                MongoBackend()
        finally:
            module.pymongo = prev

    def test_init_no_settings(self):
        celery = Celery(set_as_current=False)
        celery.conf.CELERY_MONGODB_BACKEND_SETTINGS = []
        with self.assertRaises(ImproperlyConfigured):
            MongoBackend(app=celery)

    def test_init_settings_is_None(self):
        celery = Celery(set_as_current=False)
        celery.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
        MongoBackend(app=celery)

    def test_restore_taskset_no_entry(self):
        x = MongoBackend()
        x.collection = Mock()
        fo = x.collection.find_one = Mock()
        fo.return_value = None
        self.assertIsNone(x._restore_taskset("1f3fab"))

    def test_reduce(self):
        x = MongoBackend()
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):

        with patch("pymongo.connection.Connection") as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEquals(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)

    def test_get_connection_no_connection_host(self):

        with patch("pymongo.connection.Connection") as mock_Connection:
            self.backend._connection = None
            self.backend.mongodb_host = MONGODB_HOST
            self.backend.mongodb_port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                MONGODB_HOST, MONGODB_PORT)
            self.assertEquals(sentinel.connection, connection)

    def test_get_connection_no_connection_mongodb_uri(self):

        with patch("pymongo.connection.Connection") as mock_Connection:
            mongodb_uri = "mongodb://%s:%d" % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.mongodb_host = mongodb_uri

            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(mongodb_uri)
            self.assertEquals(sentinel.connection, connection)

    @patch("celery.backends.mongodb.MongoBackend._get_connection")
    def test_get_database_no_existing(self, mock_get_connection):
        # Should really check for combinations of these two, to be complete.
        self.backend.mongodb_user = MONGODB_USER
        self.backend.mongodb_password = MONGODB_PASSWORD

        mock_database = Mock()
#.........这里部分代码省略.........

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]
class test_MongoBackend(AppCase):
    def setup(self):
        if pymongo is None:
            raise SkipTest("pymongo is not installed.")

        R = self._reset = {}
        R["encode"], MongoBackend.encode = MongoBackend.encode, Mock()
        R["decode"], MongoBackend.decode = MongoBackend.decode, Mock()
        R["Binary"], module.Binary = module.Binary, Mock()
        R["datetime"], datetime.datetime = datetime.datetime, Mock()

        self.backend = MongoBackend(app=self.app)

    def teardown(self):
        MongoBackend.encode = self._reset["encode"]
        MongoBackend.decode = self._reset["decode"]
        module.Binary = self._reset["Binary"]
        datetime.datetime = self._reset["datetime"]

    def test_Bunch(self):
        x = Bunch(foo="foo", bar=2)
        self.assertEqual(x.foo, "foo")
        self.assertEqual(x.bar, 2)

    def test_init_no_mongodb(self):
        prev, module.pymongo = module.pymongo, None
        try:
            with self.assertRaises(ImproperlyConfigured):
                MongoBackend(app=self.app)
        finally:
            module.pymongo = prev

    def test_init_no_settings(self):
        self.app.conf.mongodb_backend_settings = []
        with self.assertRaises(ImproperlyConfigured):
            MongoBackend(app=self.app)

    def test_init_settings_is_None(self):
        self.app.conf.mongodb_backend_settings = None
        MongoBackend(app=self.app)

    def test_init_with_settings(self):
        self.app.conf.mongodb_backend_settings = None
        # empty settings
        mb = MongoBackend(app=self.app)

        # uri
        uri = "mongodb://localhost:27017"
        mb = MongoBackend(app=self.app, url=uri)
        self.assertEqual(mb.mongo_host, ["localhost:27017"])
        self.assertEqual(mb.options, mb._prepare_client_options())
        self.assertEqual(mb.database_name, "celery")

        # uri with database name
        uri = "mongodb://localhost:27017/celerydb"
        mb = MongoBackend(app=self.app, url=uri)
        self.assertEqual(mb.database_name, "celerydb")

        # uri with user, password, database name, replica set
        uri = (
            "mongodb://"
            "celeryuser:[email protected]"
            "mongo1.example.com:27017,"
            "mongo2.example.com:27017,"
            "mongo3.example.com:27017/"
            "celerydatabase?replicaSet=rs0"
        )
        mb = MongoBackend(app=self.app, url=uri)
        self.assertEqual(
            mb.mongo_host, ["mongo1.example.com:27017", "mongo2.example.com:27017", "mongo3.example.com:27017"]
        )
        self.assertEqual(mb.options, dict(mb._prepare_client_options(), replicaset="rs0"))
        self.assertEqual(mb.user, "celeryuser")
        self.assertEqual(mb.password, "celerypassword")
        self.assertEqual(mb.database_name, "celerydatabase")

        # same uri, change some parameters in backend settings
        self.app.conf.mongodb_backend_settings = {
            "replicaset": "rs1",
            "user": "backenduser",
            "database": "another_db",
            "options": {"socketKeepAlive": True},
        }
        mb = MongoBackend(app=self.app, url=uri)
        self.assertEqual(
            mb.mongo_host, ["mongo1.example.com:27017", "mongo2.example.com:27017", "mongo3.example.com:27017"]
        )
        self.assertEqual(mb.options, dict(mb._prepare_client_options(), replicaset="rs1", socketKeepAlive=True))
        self.assertEqual(mb.user, "backenduser")
        self.assertEqual(mb.password, "celerypassword")
        self.assertEqual(mb.database_name, "another_db")

        mb = MongoBackend(app=self.app, url="mongodb://")

    @depends_on_current_app
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):
#.........这里部分代码省略.........

# 需要导入模块: from celery.backends.mongodb import MongoBackend [as 别名]
# 或者: from celery.backends.mongodb.MongoBackend import _get_connection [as 别名]

#.........这里部分代码省略.........
        self.assertEqual(mb.options, {'auto_start_request': False,
                                      'max_pool_size': 10,
                                      'replicaset': 'rs0'})
        self.assertEqual(mb.user, 'celeryuser')
        self.assertEqual(mb.password, 'celerypassword')
        self.assertEqual(mb.database_name, 'celerydatabase')

        # same uri, change some parameters in backend settings
        self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = {
            'replicaset': 'rs1',
            'user': 'backenduser',
            'database': 'another_db',
            'options': {
                'socketKeepAlive': True,
            },
        }
        mb = MongoBackend(app=self.app, url=uri)
        self.assertEqual(mb.mongo_host, ['mongo1.example.com:27017',
                                         'mongo2.example.com:27017',
                                         'mongo3.example.com:27017'])
        self.assertEqual(mb.options, {'auto_start_request': False,
                                      'max_pool_size': 10,
                                      'replicaset': 'rs1',
                                      'socketKeepAlive': True})
        self.assertEqual(mb.user, 'backenduser')
        self.assertEqual(mb.password, 'celerypassword')
        self.assertEqual(mb.database_name, 'another_db')

    @depends_on_current_app
    def test_reduce(self):
        x = MongoBackend(app=self.app)
        self.assertTrue(loads(dumps(x)))

    def test_get_connection_connection_exists(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = sentinel._connection

            connection = self.backend._get_connection()

            self.assertEqual(sentinel._connection, connection)
            self.assertFalse(mock_Connection.called)

    def test_get_connection_no_connection_host(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            self.backend._connection = None
            self.backend.host = MONGODB_HOST
            self.backend.port = MONGODB_PORT
            mock_Connection.return_value = sentinel.connection

            connection = self.backend._get_connection()
            mock_Connection.assert_called_once_with(
                host='mongodb://localhost:27017', max_pool_size=10,
                auto_start_request=False)
            self.assertEqual(sentinel.connection, connection)

    def test_get_connection_no_connection_mongodb_uri(self):

        with patch('pymongo.MongoClient') as mock_Connection:
            mongodb_uri = 'mongodb://%s:%d' % (MONGODB_HOST, MONGODB_PORT)
            self.backend._connection = None
            self.backend.host = mongodb_uri

            mock_Connection.return_value = sentinel.connection