def test_patch_time_exceed(self):
        '''
        check package.patched when patch time exceed
        '''
        print 'test_patch_time_exceed'

        old_log_len = len(waagent.GetFileContents(log_file))
        def patch_package(self):
            time.sleep(11)
            return 0
        MyPatching.patch_package = patch_package
        # 5 minutes reserved for reboot
        protect_settings['installDuration'] = '00:06'
        
        with self.assertRaises(SystemExit) as cm:
            download()
        self.assertEqual(cm.exception.code, 0)
        with self.assertRaises(SystemExit) as cm:
            patch()
        self.assertEqual(cm.exception.code, 0)

        patch_list = get_patch_list(MyPatching.package_patched_path)
        self.assertEqual(patch_list, ['a', 'b', 'c', 'd', 'e', '1'])
        log_contents = waagent.GetFileContents(log_file)[old_log_len:]
        self.assertTrue('Patching time exceeded' in log_contents)
def main():
    if len(sys.argv) == 1:
        unittest.main()
        return

    waagent.LoggerInit('/var/log/waagent.log', '/dev/stdout')
    waagent.Log("%s started to handle." %(ExtensionShortName))

    global hutil
    hutil = Util.HandlerUtility(waagent.Log, waagent.Error,
                                ExtensionShortName)
    hutil.do_parse_context('TEST')
    global MyPatching
    MyPatching = FakePatching(hutil)

    if MyPatching == None:
        sys.exit(1)

    for a in sys.argv[1:]:
        if re.match("^([-/]*)(disable)", a):
            disable()
        elif re.match("^([-/]*)(uninstall)", a):
            uninstall()
        elif re.match("^([-/]*)(install)", a):
            install()
        elif re.match("^([-/]*)(enable)", a):
            enable()
        elif re.match("^([-/]*)(update)", a):
            update()
        elif re.match("^([-/]*)(download)", a):
            download()
        elif re.match("^([-/]*)(patch)", a):
            patch()
        elif re.match("^([-/]*)(oneoff)", a):
            oneoff()
示例#3
0
def main():
    waagent.LoggerInit("/var/log/waagent.log", "/dev/stdout")
    waagent.Log("%s started to handle." % (ExtensionShortName))

    global hutil
    hutil = Util.HandlerUtility(waagent.Log, waagent.Error, ExtensionShortName)

    global MyPatching
    MyPatching = GetMyPatching(hutil)
    if MyPatching is None:
        sys.exit(1)

    for a in sys.argv[1:]:
        if re.match("^([-/]*)(disable)", a):
            disable()
        elif re.match("^([-/]*)(uninstall)", a):
            uninstall()
        elif re.match("^([-/]*)(install)", a):
            install()
        elif re.match("^([-/]*)(enable)", a):
            enable()
        elif re.match("^([-/]*)(update)", a):
            update()
        elif re.match("^([-/]*)(download)", a):
            download()
        elif re.match("^([-/]*)(patch)", a):
            patch()
        elif re.match("^([-/]*)(oneoff)", a):
            oneoff()
    def test_patch_time_exceed(self):
        '''
        check package.patched when patch time exceed
        '''
        print 'test_patch_time_exceed'
        global settings
        settings = {
            "category" : "importantandrecommended",
            "installDuration" : "00:06"        # 5 minutes reserved for reboot
        }

        old_log_len = len(waagent.GetFileContents(log_file))
        def patch_package(self):
            time.sleep(11)
            return 0
        MyPatching.patch_package = patch_package
        
        with self.assertRaises(SystemExit) as cm:
            download()
        self.assertEqual(cm.exception.code, 0)
        with self.assertRaises(SystemExit) as cm:
            patch()
        self.assertEqual(cm.exception.code, 0)

        patch_list = get_patch_list(MyPatching.package_patched_path)
        self.assertEqual(patch_list, ['a', 'b', 'c', 'd', 'e', '1'])
        log_contents = waagent.GetFileContents(log_file)[old_log_len:]
        self.assertTrue('Patching time exceeded' in log_contents)
    def test_patch(self):
        '''
        check file package.patched when patch successful
        '''
        print 'test_patch'
        
        with self.assertRaises(SystemExit) as cm:
            download()
        self.assertEqual(cm.exception.code, 0)
        with self.assertRaises(SystemExit) as cm:
            patch()
        self.assertEqual(cm.exception.code, 0)

        download_content = waagent.GetFileContents(MyPatching.package_downloaded_path)
        patch_content = waagent.GetFileContents(MyPatching.package_patched_path)
        self.assertEqual(download_content, patch_content)
    def test_patch_failed(self):
        '''
        check file package.patched when patch fail
        '''
        print 'test_patch_failed'

        def patch_package(self):
            return 1
        MyPatching.patch_package = patch_package

        old_log_len = len(waagent.GetFileContents(log_file))
        with self.assertRaises(SystemExit) as cm:
            download()
        self.assertEqual(cm.exception.code, 0)
        with self.assertRaises(SystemExit) as cm:
            patch()
        log_contents = waagent.GetFileContents(log_file)[old_log_len:]

        self.assertEqual(cm.exception.code, 0)
        patch_content = waagent.GetFileContents(MyPatching.package_patched_path)
        self.assertFalse(patch_content)
        self.assertTrue('Failed to patch the package' in log_contents)
示例#7
0
 def test_setgroups(self, hack):
     with patch('os.sysconf') as sysconf:
         sysconf.return_value = 100
         setgroups(list(range(400)))
         hack.assert_called_with(list(range(100)))
示例#8
0
 def test_on_decode_error(self):
     message = Message('foo')
     with patch('kombu.mixins.error') as error:
         self.c.on_decode_error(message, KeyError('foo'))
         error.assert_called()
         message.ack.assert_called_with()
示例#9
0
    def test_select(self, __select):
        ebadf = socket.error()
        ebadf.errno = errno.EBADF
        with patch('select.poll', create=True) as poller:
            poll = poller.return_value = Mock(name='poll.poll')
            poll.return_value = {3}, set(), 0
            assert asynpool._select({3}, poll=poll) == ({3}, set(), 0)

            poll.return_value = {3}, set(), 0
            assert asynpool._select({3}, None, {3}, poll=poll) == (
                {3},
                set(),
                0,
            )

            eintr = socket.error()
            eintr.errno = errno.EINTR
            poll.side_effect = eintr

            readers = {3}
            assert asynpool._select(readers, poll=poll) == (set(), set(), 1)
            assert 3 in readers

        with patch('select.poll', create=True) as poller:
            poll = poller.return_value = Mock(name='poll.poll')
            poll.side_effect = ebadf
            with patch('select.select') as selcheck:
                selcheck.side_effect = ebadf
                readers = {3}
                assert asynpool._select(readers, poll=poll) == (
                    set(),
                    set(),
                    1,
                )
                assert 3 not in readers

        with patch('select.poll', create=True) as poller:
            poll = poller.return_value = Mock(name='poll.poll')
            poll.side_effect = MemoryError()
            with pytest.raises(MemoryError):
                asynpool._select({1}, poll=poll)

        with patch('select.poll', create=True) as poller:
            poll = poller.return_value = Mock(name='poll.poll')
            with patch('select.select') as selcheck:

                def se(*args):
                    selcheck.side_effect = MemoryError()
                    raise ebadf

                poll.side_effect = se
                with pytest.raises(MemoryError):
                    asynpool._select({3}, poll=poll)

        with patch('select.poll', create=True) as poller:
            poll = poller.return_value = Mock(name='poll.poll')
            with patch('select.select') as selcheck:

                def se2(*args):
                    selcheck.side_effect = socket.error()
                    selcheck.side_effect.errno = 1321
                    raise ebadf

                poll.side_effect = se2
                with pytest.raises(socket.error):
                    asynpool._select({3}, poll=poll)

        with patch('select.poll', create=True) as poller:
            poll = poller.return_value = Mock(name='poll.poll')

            poll.side_effect = socket.error()
            poll.side_effect.errno = 34134
            with pytest.raises(socket.error):
                asynpool._select({3}, poll=poll)
示例#10
0
 def test_connect_getaddrinfo_raises_gaierror(self):
     with patch('socket.getaddrinfo', side_effect=socket.gaierror):
         with pytest.raises(socket.error):
             self.t.connect()
示例#11
0
 def test_when_logging_disabled(self):
     with patch('celery.worker.strategy.logger') as logger:
         logger.isEnabledFor.return_value = False
         with self._context(self.add.s(2, 2)) as C:
             C()
             logger.info.assert_not_called()
示例#12
0
文件: test_amqp.py 项目: zxjly/celery
 def test_send_task_message__with_receivers(self):
     from case import patch
     mocked_receiver = ((Mock(), Mock()), Mock())
     with patch('celery.signals.task_sent.receivers', [mocked_receiver]):
         self.app.amqp.send_task_message(Mock(), 'foo', self.simple_message)
示例#13
0
 def test_setup_app_sets_chdir(self, app):
     with patch('os.chdir') as chdir:
         cmd = MockCommand(app=app)
         cmd.setup_app_from_commandline(['--workdir=/opt'])
         chdir.assert_called_with('/opt')
示例#14
0
def test_move_by_taskmap():
    with patch('celery.contrib.migrate.move') as move:
        move_by_taskmap({'add': Queue('foo')})
        move.assert_called()
        cb = move.call_args[0][0]
        assert cb({'task': 'add'}, Mock())
示例#15
0
 def test_aaa_is_patched(self):
     with patch('eventlet.monkey_patch', create=True) as monkey_patch:
         from celery import maybe_patch_concurrency
         maybe_patch_concurrency(['x', '-P', 'eventlet'])
         monkey_patch.assert_called_with()
示例#16
0
 def test_maybe_close_fd(self):
     with patch('os.close'):
         _maybe_close_fd(Mock())
         _maybe_close_fd(object())
示例#17
0
 def fixup_context(self, app):
     with patch('celery.fixups.django.DjangoWorkerFixup.validate_models'):
         with patch('celery.fixups.django.symbol_by_name') as symbyname:
             with patch('celery.fixups.django.import_module') as impmod:
                 f = self.Fixup(app)
                 yield f, impmod, symbyname
示例#18
0
 def test_valid_expires_with_utc_makes_aware(self):
     with patch('celery.worker.request.maybe_make_aware') as mma:
         self.get_request(self.add.s(2, 2).set(expires=10),
                          maybe_make_aware=mma)
         mma.assert_called()
示例#19
0
def test_move_task_by_id():
    with patch('celery.contrib.migrate.move') as move:
        move_task_by_id('123f', Queue('foo'))
        move.assert_called()
        cb = move.call_args[0][0]
        assert cb({'id': '123f'}, Mock()) == Queue('foo')
示例#20
0
 def test_on_connection_error(self):
     with patch('kombu.mixins.warn') as warn:
         self.c.on_connection_error(KeyError('foo'), 3)
         warn.assert_called()
示例#21
0
 def fromfile(fdiff):
     return patch(fdiff)
示例#22
0
文件: protocol.py 项目: robnee/aioyam
    # low-level APIs.
    loop = asyncio.get_event_loop()

    on_con_lost = loop.create_future()

    name, value = "@MAIN:PWR", "On"

    transport, protocol = await loop.create_connection(
        lambda: YNCAProtocol(name, value, on_con_lost, loop),
        'CL-6EA47', 50000)

    # Wait until the protocol signals that the connection
    # is lost and close the transport.
    try:
        await on_con_lost
    finally:
        transport.close()


def run(future):
    loop = asyncio.get_event_loop()

    result = loop.run_until_complete(future)
    print("result:", result)


if __name__ == '__main__':
    patch()
    # asyncio.run(main2())
    run(main())
示例#23
0
 def test_default_ensure_callback(self):
     with patch('kombu.connection.logger') as logger:
         c = Connection(transport=Mock)
         c._default_ensure_callback(KeyError(), 3)
         self.assertTrue(logger.error.called)
示例#24
0
 def test_setup_app_no_respect(self, app):
     cmd = MockCommand(app=app)
     cmd.respects_app_option = False
     with patch('celery.bin.base.Celery') as cp:
         cmd.setup_app_from_commandline(['--app=x.y:z'])
         cp.assert_called()
示例#25
0
 def test_connparams_health_check_interval_supported(self):
     with patch('kombu.transport.redis.Channel._create_client'):
         with Connection('redis+socket:///tmp/redis.sock') as conn:
             connparams = conn.default_channel._connparams()
             assert connparams['health_check_interval'] == 25
示例#26
0
 def test_get_timeout_longer(self):
     res = self.app.AsyncResult(self.task4['id'])  # has RETRY state
     with patch('celery.result.time') as _time:
         with pytest.raises(TimeoutError):
             res.get(timeout=1, interval=1)
             _time.sleep.assert_called_with(1)
示例#27
0
 def test_calls_Queue_from_dict(self):
     with patch('kombu.common.Queue') as Queue:
         entry_to_queue('name', exchange='bar')
         Queue.from_dict.assert_called_with('name', exchange='bar')
示例#28
0
 def test_connect_socket_fails(self):
     with patch('socket.socket', side_effect=socket.error):
         with pytest.raises(socket.error):
             self.t.connect()
     assert self.t.sock is None and self.t.connected is False
示例#29
0
 def test_when_actual(self, getrlimit):
     with patch('os.sysconf') as sysconfig:
         sysconfig.side_effect = KeyError()
         getrlimit.return_value = [None, 13]
         assert get_fdmax(None) == 13
示例#30
0
 def test_gevent_bug_disables_connection_timeout(self):
     with patch('celery.worker.consumer.consumer._detect_environment') as d:
         d.return_value = 'gevent'
         self.app.conf.broker_connection_timeout = 33.33
         self.get_consumer()
         assert self.app.conf.broker_connection_timeout is None
示例#31
0
 def test_prepare_client_options(self):
     with patch('pymongo.version_tuple', new=(3, 0, 3)):
         options = self.backend._prepare_client_options()
         assert options == {
             'maxPoolSize': self.backend.max_pool_size
         }
示例#32
0
 def test_arm_alarm(self):
     if hasattr(signal, 'setitimer'):
         with patch('signal.setitimer', create=True) as seti:
             signals.arm_alarm(30)
             seti.assert_called()
示例#33
0
 def test_setgroups_sysconf_raises(self, hack):
     with patch('os.sysconf') as sysconf:
         sysconf.side_effect = ValueError()
         setgroups(list(range(400)))
         hack.assert_called_with(list(range(400)))
示例#34
0
 def test_task_not_shared(self):
     with patch('celery.app.base.connect_on_app_finalize') as sh:
         @self.app.task(shared=False)
         def foo():
             pass
         sh.assert_not_called()
示例#35
0
 def test_when_infinity(self, getrlimit):
     with patch('os.sysconf') as sysconfig:
         sysconfig.side_effect = KeyError()
         getrlimit.return_value = [None, resource.RLIM_INFINITY]
         default = object()
         assert get_fdmax(default) is default
示例#36
0
 def test_send_worker_shutdown(self):
     with patch('celery.signals.worker_shutdown') as ws:
         self.worker._send_worker_shutdown()
         ws.send.assert_called_with(sender=self.worker)
示例#37
0
 def fromfile(fdiff):
     return patch(fdiff)