def test_setup_logger_no_handlers_file(self, *args): tempfile = mktemp(suffix='unittest', prefix='celery') _open = ('builtins.open' if sys.version_info[0] == 3 else '__builtin__.open') with patch(_open) as osopen: with restore_logging(): files = defaultdict(StringIO) def open_file(filename, *args, **kwargs): f = files[filename] f.fileno = Mock() f.fileno.return_value = 99 return f osopen.side_effect = open_file l = self.get_logger() l.handlers = [] l = self.setup_logger( logfile=tempfile, loglevel=logging.INFO, root=False, ) self.assertIsInstance( get_handlers(l)[0], logging.FileHandler, ) self.assertIn(tempfile, files)
def test_process_initializer(self, set_mp_process_title, _signals): with restore_logging(): from celery import signals from celery._state import _tls from celery.concurrency.processes import process_initializer, WORKER_SIGRESET, WORKER_SIGIGNORE def on_worker_process_init(**kwargs): on_worker_process_init.called = True on_worker_process_init.called = False signals.worker_process_init.connect(on_worker_process_init) def Loader(*args, **kwargs): loader = Mock(*args, **kwargs) loader.conf = {} loader.override_backends = {} return loader with self.Celery(loader=Loader) as app: app.conf = AttributeDict(DEFAULTS) process_initializer(app, "awesome.worker.com") _signals.ignore.assert_any_call(*WORKER_SIGIGNORE) _signals.reset.assert_any_call(*WORKER_SIGRESET) self.assertTrue(app.loader.init_worker.call_count) self.assertTrue(on_worker_process_init.called) self.assertIs(_tls.current_app, app) set_mp_process_title.assert_called_with("celeryd", hostname="awesome.worker.com") with patch("celery.app.trace.setup_worker_optimizations") as S: os.environ["FORKED_BY_MULTIPROCESSING"] = "1" try: process_initializer(app, "luke.worker.com") S.assert_called_with(app) finally: os.environ.pop("FORKED_BY_MULTIPROCESSING", None)
def test_setup_logging_subsystem_misc2(self): with restore_logging(): self.app.conf.CELERYD_HIJACK_ROOT_LOGGER = True try: self.app.log.setup_logging_subsystem() finally: self.app.conf.CELERYD_HIJACK_ROOT_LOGGER = False
def test_logging_proxy(self): with restore_logging(): logger = self.setup_logger(loglevel=logging.ERROR, logfile=None, root=False) with wrap_logger(logger) as sio: p = LoggingProxy(logger, loglevel=logging.ERROR) p.close() p.write('foo') self.assertNotIn('foo', sio.getvalue()) p.closed = False p.write('foo') self.assertIn('foo', sio.getvalue()) lines = ['baz', 'xuzzy'] p.writelines(lines) for line in lines: self.assertIn(line, sio.getvalue()) p.flush() p.close() self.assertFalse(p.isatty()) with override_stdouts() as (stdout, stderr): with in_sighandler(): p.write('foo') self.assertTrue(stderr.getvalue())
def test_logs_errors(self, logger, stdout, stderr): with restore_logging(): b = MockBeat3( app=self.app, redirect_stdouts=False, socket_timeout=None, ) b.start_scheduler() self.assertTrue(logger.critical.called)
def test_setup_logger_no_handlers_file(self): with restore_logging(): l = self.get_logger() l.handlers = [] tempfile = mktemp(suffix='unittest', prefix='celery') l = self.setup_logger(logfile=tempfile, loglevel=0, root=False) self.assertIsInstance(get_handlers(l)[0], logging.FileHandler)
def test_setup_logging_subsystem_no_mputil(self): from celery.utils import log as logtools with restore_logging(): mputil, logtools.mputil = logtools.mputil, None try: self.app.log.setup_logging_subsystem() finally: logtools.mputil = mputil
def test_evcam(self): with restore_logging(): evcam(Polaroid, timer=timer, app=self.app) evcam(Polaroid, timer=timer, loglevel='CRITICAL', app=self.app) self.MockReceiver.raise_keyboard_interrupt = True try: with self.assertRaises(SystemExit): evcam(Polaroid, timer=timer, app=self.app) finally: self.MockReceiver.raise_keyboard_interrupt = False
def test_logging_proxy_recurse_protection(self): with restore_logging(): logger = self.setup_logger(loglevel=logging.ERROR, logfile=None, root=False) p = LoggingProxy(logger, loglevel=logging.ERROR) p._thread.recurse_protection = True try: self.assertIsNone(p.write('FOOFO')) finally: p._thread.recurse_protection = False
def test_setup_logger_no_handlers_stream(self): with restore_logging(): l = self.get_logger() l.handlers = [] with override_stdouts() as outs: stdout, stderr = outs l = self.setup_logger(logfile=sys.stderr, loglevel=logging.INFO, root=False) l.info('The quick brown fox...') self.assertIn('The quick brown fox...', stderr.getvalue())
def test_setup_logger(self): with restore_logging(): logger = self.setup_logger(loglevel=logging.ERROR, logfile=None, root=False, colorize=True) logger.handlers = [] self.app.log.already_setup = False logger = self.setup_logger(loglevel=logging.ERROR, logfile=None, root=False, colorize=None) self.assertIs( get_handlers(logger)[0].stream, sys.__stderr__, 'setup_logger logs to stderr without logfile argument.', )
def test_setup_logging(self): with restore_logging(): try: # py3k delattr(sys.stdout, 'logger') except AttributeError: pass b = beatapp.Beat(app=self.app) b.redirect_stdouts = False b.app.log.__class__._setup = False b.setup_logging() with self.assertRaises(AttributeError): sys.stdout.logger
def test_process_initializer(self, set_mp_process_title, _signals): with restore_logging(): from celery import signals from celery._state import _tls from celery.concurrency.prefork import ( process_initializer, WORKER_SIGRESET, WORKER_SIGIGNORE, ) def on_worker_process_init(**kwargs): on_worker_process_init.called = True on_worker_process_init.called = False signals.worker_process_init.connect(on_worker_process_init) def Loader(*args, **kwargs): loader = Mock(*args, **kwargs) loader.conf = {} loader.override_backends = {} return loader with self.Celery(loader=Loader) as app: app.conf = AttributeDict(DEFAULTS) process_initializer(app, 'awesome.worker.com') _signals.ignore.assert_any_call(*WORKER_SIGIGNORE) _signals.reset.assert_any_call(*WORKER_SIGRESET) self.assertTrue(app.loader.init_worker.call_count) self.assertTrue(on_worker_process_init.called) self.assertIs(_tls.current_app, app) set_mp_process_title.assert_called_with( 'celeryd', hostname='awesome.worker.com', ) with patch('celery.app.trace.setup_worker_optimizations') as S: os.environ['FORKED_BY_MULTIPROCESSING'] = "1" try: process_initializer(app, 'luke.worker.com') S.assert_called_with(app, 'luke.worker.com') finally: os.environ.pop('FORKED_BY_MULTIPROCESSING', None) os.environ['CELERY_LOG_FILE'] = 'worker%I.log' app.log.setup = Mock(name='log_setup') try: process_initializer(app, 'luke.worker.com') finally: os.environ.pop('CELERY_LOG_FILE', None)
def test_redirect_stdouts(self): with restore_logging(): logger = self.setup_logger(loglevel=logging.ERROR, logfile=None, root=False) try: with wrap_logger(logger) as sio: self.app.log.redirect_stdouts_to_logger( logger, loglevel=logging.ERROR, ) logger.error('foo') self.assertIn('foo', sio.getvalue()) self.app.log.redirect_stdouts_to_logger( logger, stdout=False, stderr=False, ) finally: sys.stdout, sys.stderr = sys.__stdout__, sys.__stderr__
def test_process_initializer(self, set_mp_process_title, _signals): with restore_logging(): from celery import signals from celery._state import _tls from celery.concurrency.prefork import ( process_initializer, WORKER_SIGRESET, WORKER_SIGIGNORE, ) def on_worker_process_init(**kwargs): on_worker_process_init.called = True on_worker_process_init.called = False signals.worker_process_init.connect(on_worker_process_init) def Loader(*args, **kwargs): loader = Mock(*args, **kwargs) loader.conf = {} loader.override_backends = {} return loader with self.Celery(loader=Loader) as app: app.conf = AttributeDict(DEFAULTS) process_initializer(app, 'awesome.worker.com') _signals.ignore.assert_any_call(*WORKER_SIGIGNORE) _signals.reset.assert_any_call(*WORKER_SIGRESET) self.assertTrue(app.loader.init_worker.call_count) self.assertTrue(on_worker_process_init.called) self.assertIs(_tls.current_app, app) set_mp_process_title.assert_called_with( 'celeryd', hostname='awesome.worker.com', ) with patch('celery.app.trace.setup_worker_optimizations') as S: os.environ['FORKED_BY_MULTIPROCESSING'] = '1' try: process_initializer(app, 'luke.worker.com') S.assert_called_with(app, 'luke.worker.com') finally: os.environ.pop('FORKED_BY_MULTIPROCESSING', None) os.environ['CELERY_LOG_FILE'] = 'worker%I.log' app.log.setup = Mock(name='log_setup') try: process_initializer(app, 'luke.worker.com') finally: os.environ.pop('CELERY_LOG_FILE', None)
def test_process_initializer(self, set_mp_process_title, _signals): with restore_logging(): from celery import Celery from celery import signals from celery._state import _tls from celery.concurrency.processes import process_initializer from celery.concurrency.processes import (WORKER_SIGRESET, WORKER_SIGIGNORE) def on_worker_process_init(**kwargs): on_worker_process_init.called = True on_worker_process_init.called = False signals.worker_process_init.connect(on_worker_process_init) loader = Mock() loader.override_backends = {} app = Celery(loader=loader, set_as_current=False) app.loader = loader app.conf = AttributeDict(DEFAULTS) process_initializer(app, 'awesome.worker.com') _signals.ignore.assert_any_call(*WORKER_SIGIGNORE) _signals.reset.assert_any_call(*WORKER_SIGRESET) self.assertTrue(app.loader.init_worker.call_count) self.assertTrue(on_worker_process_init.called) self.assertIs(_tls.current_app, app) set_mp_process_title.assert_called_with( 'celeryd', hostname='awesome.worker.com', ) with patch('celery.app.trace.setup_worker_optimizations') as swo: os.environ['FORKED_BY_MULTIPROCESSING'] = "1" try: process_initializer(app, 'luke.worker.com') swo.assert_called_with(app) finally: os.environ.pop('FORKED_BY_MULTIPROCESSING', None)
def test_setup_logging_subsystem_no_mputil(self): from celery.utils import log as logtools with restore_logging(): with mask_modules('billiard.util'): self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_colorize(self): with restore_logging(): self.app.log.setup_logging_subsystem(colorize=None) self.app.log.setup_logging_subsystem(colorize=True)
def test_setup_logging_subsystem_misc2(self): with restore_logging(): self.app.conf.worker_hijack_root_logger = True self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_no_mputil(self): with restore_logging(): with mask_modules('billiard.util'): self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_misc(self): with restore_logging(): self.app.log.setup_logging_subsystem(loglevel=None)