def test_init_with_settings(self):
self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
# empty settings
mb = MongoBackend(app=self.app)
# uri
uri = 'mongodb://*****:*****@'
'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.CELERY_MONGODB_BACKEND_SETTINGS = {
'replicaset': 'rs1',
'user': '******',
'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')
def create_mongo_backend(serializer):
# NOTE: `bson` is a only mongodb-specific type and can be set only directly on MongoBackend instance.
if serializer == "bson":
beckend = MongoBackend(app=app)
beckend.serializer = serializer
else:
app.conf.accept_content = ['json', 'pickle', 'msgpack', 'yaml']
app.conf.result_serializer = serializer
beckend = MongoBackend(app=app)
return beckend
def test_encode_decode(self, app):
backend = MongoBackend(app=app)
data = {'foo': 1}
assert backend.decode(backend.encode(data))
backend.serializer = 'bson'
assert backend.encode(data) == data
assert backend.decode(data) == data
def perform_seedlist_assertions(self):
mb = MongoBackend(app=self.app, url=MONGODB_SEEDLIST_URI)
assert mb.mongo_host == MONGODB_BACKEND_HOST
assert mb.user == CELERY_USER
assert mb.password == CELERY_PASSWORD
assert mb.database_name == CELERY_DATABASE
return mb
def test_encode_decode(self):
backend = MongoBackend(app=self.app)
data = {'foo': 1}
self.assertTrue(backend.decode(backend.encode(data)))
backend.serializer = 'bson'
self.assertEquals(backend.encode(data), data)
self.assertEquals(backend.decode(data), data)
def test_init_no_mongodb(self):
prev, module.pymongo = module.pymongo, None
try:
with self.assertRaises(ImproperlyConfigured):
MongoBackend()
finally:
module.pymongo = prev
def setup(self):
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 test_ensure_mongodb_uri_compliance(self):
mb = MongoBackend(app=self.app, url=None)
compliant_uri = mb._ensure_mongodb_uri_compliance
assert compliant_uri('mongodb://') == 'mongodb://localhost'
assert compliant_uri('mongodb+something://host') == \
'mongodb+something://host'
assert compliant_uri('something://host') == 'mongodb+something://host'
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()
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()
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 = '******'
x.mongodb_password = '******'
with self.assertRaises(ImproperlyConfigured):
x._get_database()
db.authenticate.assert_called_with('jerry', 'cere4l')
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 = '******'
x.password = '******'
with pytest.raises(ImproperlyConfigured):
x._get_database()
db.authenticate.assert_called_with('jerry', 'cere4l',
source=x.database_name)
def test_get_connection_with_authmechanism_no_username(self):
with patch('pymongo.MongoClient') as mock_Connection:
self.app.conf.mongodb_backend_settings = None
uri = ('mongodb://'
'localhost:27017/'
'celerydatabase?authMechanism=SCRAM-SHA-256')
mb = MongoBackend(app=self.app, url=uri)
mock_Connection.side_effect = ConfigurationError(
'SCRAM-SHA-256 requires a username.')
with pytest.raises(ConfigurationError):
mb._get_connection()
mock_Connection.assert_called_once_with(
host=['localhost:27017'],
authmechanism='SCRAM-SHA-256',
**mb._prepare_client_options())
def get_mongo_or_SkipTest():
def emit_no_mongo_msg(reason):
global _no_mongo_msg_emitted
if not _no_mongo_msg_emitted:
sys.stderr.write("\n" + _no_mongo_msg % reason + "\n")
_no_mongo_msg_emitted = True
try:
tb = MongoBackend()
try:
tb._get_database()
except AutoReconnect, exc:
emit_no_mongo_msg("not running")
raise SkipTest("Can't connect to MongoDB: %s" % (exc, ))
return tb
def test_init_with_settings(self):
self.app.conf.mongodb_backend_settings = None
# empty settings
mb = MongoBackend(app=self.app)
# uri
uri = 'mongodb://*****:*****@'
'mongo1.example.com:27017,'
'mongo2.example.com:27017,'
'mongo3.example.com:27017/'
'celerydatabase?replicaSet=rs0')
mb = MongoBackend(app=self.app, url=uri)
assert mb.mongo_host == MONGODB_BACKEND_HOST
assert mb.options == dict(
mb._prepare_client_options(),
replicaset='rs0',
)
assert mb.user == CELERY_USER
assert mb.password == CELERY_PASSWORD
assert mb.database_name == CELERY_DATABASE
# same uri, change some parameters in backend settings
self.app.conf.mongodb_backend_settings = {
'replicaset': 'rs1',
'user': '******',
'database': 'another_db',
'options': {
'socketKeepAlive': True,
},
}
mb = MongoBackend(app=self.app, url=uri)
assert mb.mongo_host == MONGODB_BACKEND_HOST
assert mb.options == dict(
mb._prepare_client_options(),
replicaset='rs1',
socketKeepAlive=True,
)
assert mb.user == 'backenduser'
assert mb.password == CELERY_PASSWORD
assert mb.database_name == 'another_db'
mb = MongoBackend(app=self.app, url='mongodb://')
def test_get_connection_with_authmechanism(self):
with patch('pymongo.MongoClient') as mock_Connection:
self.app.conf.mongodb_backend_settings = None
uri = ('mongodb://'
'celeryuser:celerypassword@'
'localhost:27017/'
'celerydatabase?authMechanism=SCRAM-SHA-256')
mb = MongoBackend(app=self.app, url=uri)
mock_Connection.return_value = sentinel.connection
connection = mb._get_connection()
mock_Connection.assert_called_once_with(
host=['localhost:27017'],
username='******',
password='******',
authmechanism='SCRAM-SHA-256',
**mb._prepare_client_options())
assert sentinel.connection == connection
def test_init_mongodb_dns_seedlist(self, dns_resolver_query):
from dns.name import Name
from dns.rdtypes.ANY.TXT import TXT
from dns.rdtypes.IN.SRV import SRV
self.app.conf.mongodb_backend_settings = None
def mock_resolver(_, rdtype, rdclass=None, lifetime=None, **kwargs):
if rdtype == 'SRV':
return [
SRV(0, 0, 0, 0, 27017, Name(labels=hostname))
for hostname in [
b'mongo1.example.com'.split(b'.'),
b'mongo2.example.com'.split(b'.'),
b'mongo3.example.com'.split(b'.')
]
]
elif rdtype == 'TXT':
return [TXT(0, 0, [b'replicaSet=rs0'])]
dns_resolver_query.side_effect = mock_resolver
# uri with user, password, database name, replica set,
# DNS seedlist format
uri = ('srv://'
'celeryuser:celerypassword@'
'dns-seedlist-host.example.com/'
'celerydatabase')
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='rs0',
ssl=True
)
assert mb.user == 'celeryuser'
assert mb.password == 'celerypassword'
assert mb.database_name == 'celerydatabase'
def test_as_uri_exclude_password_replica_set(self):
backend = MongoBackend(app=self.app, url=self.replica_set_url)
assert backend.as_uri() == self.sanitized_replica_set_url
def test_reduce(self):
x = MongoBackend(app=self.app)
assert loads(dumps(x))
def test_init_settings_is_None(self):
self.app.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
MongoBackend(app=self.app)
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.mongodb_backend_settings = None
MongoBackend(app=self.app)
def test_init_no_settings(self):
self.app.conf.mongodb_backend_settings = []
with pytest.raises(ImproperlyConfigured):
MongoBackend(app=self.app)
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_as_uri_include_password_replica_set(self):
backend = MongoBackend(app=self.app, url=self.replica_set_url)
assert backend.as_uri(True) == self.replica_set_url
def test_restore_group_no_entry(self):
x = MongoBackend()
x.collection = Mock()
fo = x.collection.find_one = Mock()
fo.return_value = None
self.assertIsNone(x._restore_group('1f3fab'))
def test_init_settings_is_None(self):
celery = Celery(set_as_current=False)
celery.conf.CELERY_MONGODB_BACKEND_SETTINGS = None
MongoBackend(app=celery)
def setup(self):
self.patching('celery.backends.mongodb.MongoBackend.encode')
self.patching('celery.backends.mongodb.MongoBackend.decode')
self.patching('celery.backends.mongodb.Binary')
self.patching('datetime.datetime')
self.backend = MongoBackend(app=self.app, url=self.default_url)
def test_reduce(self):
x = MongoBackend()
self.assertTrue(loads(dumps(x)))
def test_init_no_mongodb(self, patching):
patching('celery.backends.mongodb.pymongo', None)
with pytest.raises(ImproperlyConfigured):
MongoBackend(app=self.app)
