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_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', )