def mock_module(*names):
prev = {}
class MockModule(ModuleType):
def __getattr__(self, attr):
setattr(self, attr, Mock())
return ModuleType.__getattribute__(self, attr)
mods = []
for name in names:
try:
prev[name] = sys.modules[name]
except KeyError:
pass
mod = sys.modules[name] = MockModule(module_name_t(name))
mods.append(mod)
try:
yield mods
finally:
for name in names:
try:
sys.modules[name] = prev[name]
except KeyError:
try:
del(sys.modules[name])
except KeyError:
pass
def subclass_with_self(self, Class, name=None, attribute='app',
reverse=None, keep_reduce=False, **kw):
"""Subclass an app-compatible class by setting its app attribute
to be this app instance.
App-compatible means that the class has a class attribute that
provides the default app it should use, e.g.
``class Foo: app = None``.
:param Class: The app-compatible class to subclass.
:keyword name: Custom name for the target class.
:keyword attribute: Name of the attribute holding the app,
default is 'app'.
"""
Class = symbol_by_name(Class)
reverse = reverse if reverse else Class.__name__
def __reduce__(self):
return _unpickle_appattr, (reverse, self.__reduce_args__())
attrs = dict({attribute: self}, __module__=Class.__module__,
__doc__=Class.__doc__, **kw)
if not keep_reduce:
attrs['__reduce__'] = __reduce__
return type(module_name_t(name or Class.__name__), (Class,), attrs)
def subclass_with_self(self,
Class,
name=None,
attribute='app',
reverse=None,
keep_reduce=False,
**kw):
"""Subclass an app-compatible class by setting its app attribute
to be this app instance.
App-compatible means that the class has a class attribute that
provides the default app it should use, e.g.
``class Foo: app = None``.
:param Class: The app-compatible class to subclass.
:keyword name: Custom name for the target class.
:keyword attribute: Name of the attribute holding the app,
default is 'app'.
"""
Class = symbol_by_name(Class)
reverse = reverse if reverse else Class.__name__
def __reduce__(self):
return _unpickle_appattr, (reverse, self.__reduce_args__())
attrs = dict({attribute: self},
__module__=Class.__module__,
__doc__=Class.__doc__,
**kw)
if not keep_reduce:
attrs['__reduce__'] = __reduce__
return type(module_name_t(name or Class.__name__), (Class, ), attrs)
def mock_memcache(self):
memcache = types.ModuleType(module_name_t('memcache'))
memcache.Client = MemcachedClient
memcache.Client.__module__ = memcache.__name__
prev, sys.modules['memcache'] = sys.modules.get('memcache'), memcache
try:
yield True
finally:
if prev is not None:
sys.modules['memcache'] = prev
def mock_memcache(self):
memcache = types.ModuleType(module_name_t('memcache'))
memcache.Client = MemcachedClient
memcache.Client.__module__ = memcache.__name__
prev, sys.modules['memcache'] = sys.modules.get('memcache'), memcache
try:
yield True
finally:
if prev is not None:
sys.modules['memcache'] = prev
def mock_pylibmc(self):
pylibmc = types.ModuleType(module_name_t('pylibmc'))
pylibmc.Client = MemcachedClient
pylibmc.Client.__module__ = pylibmc.__name__
prev = sys.modules.get('pylibmc')
sys.modules['pylibmc'] = pylibmc
try:
yield True
finally:
if prev is not None:
sys.modules['pylibmc'] = prev
def mock_pylibmc(self):
pylibmc = types.ModuleType(module_name_t('pylibmc'))
pylibmc.Client = MemcachedClient
pylibmc.Client.__module__ = pylibmc.__name__
prev = sys.modules.get('pylibmc')
sys.modules['pylibmc'] = pylibmc
try:
yield True
finally:
if prev is not None:
sys.modules['pylibmc'] = prev
def patch_modules(*modules):
prev = {}
for mod in modules:
prev[mod] = sys.modules.get(mod)
sys.modules[mod] = ModuleType(module_name_t(mod))
try:
yield
finally:
for name, mod in items(prev):
if mod is None:
sys.modules.pop(name, None)
else:
sys.modules[name] = mod
def test_find_app(self):
cmd = MockCommand(app=self.app)
with patch('celery.bin.base.symbol_by_name') as sbn:
from types import ModuleType
x = ModuleType(module_name_t('proj'))
def on_sbn(*args, **kwargs):
def after(*args, **kwargs):
x.app = 'quick brown fox'
x.__path__ = None
return x
sbn.side_effect = after
return x
sbn.side_effect = on_sbn
x.__path__ = [True]
self.assertEqual(cmd.find_app('proj'), 'quick brown fox')
def test_read_configuration(self):
from types import ModuleType
class ConfigModule(ModuleType):
pass
configname = os.environ.get("CELERY_CONFIG_MODULE") or "celeryconfig"
celeryconfig = ConfigModule(module_name_t(configname))
celeryconfig.imports = ("os", "sys")
prevconfig = sys.modules.get(configname)
sys.modules[configname] = celeryconfig
try:
l = default.Loader(app=self.app)
l.find_module = Mock(name="find_module")
settings = l.read_configuration(fail_silently=False)
self.assertTupleEqual(settings.imports, ("os", "sys"))
settings = l.read_configuration(fail_silently=False)
self.assertTupleEqual(settings.imports, ("os", "sys"))
l.on_worker_init()
finally:
if prevconfig:
sys.modules[configname] = prevconfig
def test_read_configuration(self):
from types import ModuleType
class ConfigModule(ModuleType):
pass
configname = os.environ.get('CELERY_CONFIG_MODULE') or 'celeryconfig'
celeryconfig = ConfigModule(module_name_t(configname))
celeryconfig.imports = ('os', 'sys')
prevconfig = sys.modules.get(configname)
sys.modules[configname] = celeryconfig
try:
l = default.Loader(app=self.app)
l.find_module = Mock(name='find_module')
settings = l.read_configuration(fail_silently=False)
self.assertTupleEqual(settings.imports, ('os', 'sys'))
settings = l.read_configuration(fail_silently=False)
self.assertTupleEqual(settings.imports, ('os', 'sys'))
l.on_worker_init()
finally:
if prevconfig:
sys.modules[configname] = prevconfig
def subclass_exception(name, parent, module): # noqa
return type(module_name_t(name), (parent, ), {'__module__': module})
def test_qualname(self):
Class = type(module_name_t('Fox'), (object,), {
'__module__': 'quick.brown',
})
self.assertEqual(qualname(Class), 'quick.brown.Fox')
self.assertEqual(qualname(Class()), 'quick.brown.Fox')
from celery.result import result_from_tuple
from celery.utils import uuid
from celery.utils.functional import pass1
from celery.tests.case import ANY, AppCase, Case, Mock, call, patch, skip
class wrapobject(object):
def __init__(self, *args, **kwargs):
self.args = args
if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
Oldstyle = None
else:
Oldstyle = types.ClassType(module_name_t('Oldstyle'), (), {})
Unpickleable = subclass_exception(
module_name_t('Unpickleable'), KeyError, 'foo.module',
)
Impossible = subclass_exception(
module_name_t('Impossible'), object, 'foo.module',
)
Lookalike = subclass_exception(
module_name_t('Lookalike'), wrapobject, 'foo.module',
)
class test_nulldict(Case):
def test_nulldict(self):
x = _nulldict()
def test_qualname(self):
Class = type(module_name_t('Fox'), (object, ), {
'__module__': 'quick.brown',
})
self.assertEqual(qualname(Class), 'quick.brown.Fox')
self.assertEqual(qualname(Class()), 'quick.brown.Fox')
def subclass_exception(name, parent, module): # noqa
return type(module_name_t(name), (parent,), {'__module__': module})
from celery.utils.functional import pass1
from celery.tests.case import (
ANY, AppCase, Case, Mock, call, patch, skip_if_python3,
)
class wrapobject(object):
def __init__(self, *args, **kwargs):
self.args = args
if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
Oldstyle = None
else:
Oldstyle = types.ClassType(module_name_t('Oldstyle'), (), {})
Unpickleable = subclass_exception(
module_name_t('Unpickleable'), KeyError, 'foo.module',
)
Impossible = subclass_exception(
module_name_t('Impossible'), object, 'foo.module',
)
Lookalike = subclass_exception(
module_name_t('Lookalike'), wrapobject, 'foo.module',
)
class test_nulldict(Case):
def test_nulldict(self):
x = _nulldict()
from celery.result import result_from_tuple
from celery.utils import uuid
from celery.utils.functional import pass1
from celery.tests.case import ANY, AppCase, Case, Mock, call, patch, skip
class wrapobject(object):
def __init__(self, *args, **kwargs):
self.args = args
if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
Oldstyle = None
else:
Oldstyle = types.ClassType(module_name_t('Oldstyle'), (), {})
Unpickleable = subclass_exception(
module_name_t('Unpickleable'),
KeyError,
'foo.module',
)
Impossible = subclass_exception(
module_name_t('Impossible'),
object,
'foo.module',
)
Lookalike = subclass_exception(
module_name_t('Lookalike'),
wrapobject,
'foo.module',
)
