Beispiel #1
0
    def test_main_loop_task_exception(self):
        max_runs = 10

        with patch('kobo.worker.main.TaskManager', self.create_task_manager()):
            with patch.object(main.signal, 'signal') as signal_mock:
                with patch.object(main.sys, 'exit') as exit_mock:
                    main.main_loop({
                        'max_runs': max_runs,
                        'fail': True,
                    },
                                   foreground=False)

                    signal_mock.assert_has_calls([
                        call(signal.SIGTERM, main.daemon_shutdown),
                        call(signal.SIGINT, signal.SIG_IGN),
                        call(signal.SIGTERM, signal.SIG_IGN),
                    ],
                                                 any_order=False)

                    exit_mock.assert_not_called()

            self.assertEqual(self.task_manager.hub._login.call_count, max_runs)
            self.assertEqual(self.task_manager.update_worker_info.call_count,
                             max_runs)
            self.assertEqual(self.task_manager.update_tasks.call_count,
                             max_runs)
            self.assertEqual(self.task_manager.get_next_task.call_count,
                             max_runs)
            self.assertEqual(self.task_manager.sleep.call_count, max_runs - 1)
            self.assertEqual(self.task_manager.log_error.call_count,
                             max_runs - 1)
            self.assertEqual(self.task_manager.shutdown.call_count, 1)
Beispiel #2
0
    def test_main_loop_task_exception(self):
        max_runs = 10

        with patch('kobo.worker.main.TaskManager', self.create_task_manager()):
            with patch.object(main.signal, 'signal') as signal_mock:
                with patch.object(main.sys, 'exit') as exit_mock:
                    main.main_loop({
                        'max_runs': max_runs,
                        'fail': True,
                    }, foreground=False)

                    signal_mock.assert_has_calls([
                        call(signal.SIGTERM, main.daemon_shutdown),
                        call(signal.SIGINT, signal.SIG_IGN),
                        call(signal.SIGTERM, signal.SIG_IGN),
                    ], any_order=False)

                    exit_mock.assert_not_called()

            self.assertEqual(self.task_manager.hub._login.call_count, max_runs)
            self.assertEqual(self.task_manager.update_worker_info.call_count, max_runs)
            self.assertEqual(self.task_manager.update_tasks.call_count, max_runs)
            self.assertEqual(self.task_manager.get_next_task.call_count, max_runs)
            self.assertEqual(self.task_manager.sleep.call_count, max_runs - 1)
            self.assertEqual(self.task_manager.log_error.call_count, max_runs - 1)
            self.assertEqual(self.task_manager.shutdown.call_count, 1)
Beispiel #3
0
    def test_main_loop_foreground_with_file_logger(self):
        max_runs = 1

        with patch('kobo.worker.main.TaskManager', self.create_task_manager()):
            with patch.object(main.kobo, 'log') as log_mock:
                with patch.object(main.signal, 'signal') as signal_mock:
                    with patch.object(main.sys, 'exit') as exit_mock:
                        main.main_loop({
                            'max_runs': max_runs,
                            'LOG_FILE': '/tmp/log.txt',
                        }, foreground=True)

                        log_mock.add_rotating_file_logger.assert_called_once_with(
                            self.task_manager._logger,
                            '/tmp/log.txt',
                            log_level=10,
                        )

                        log_mock.add_stderr_logger.assert_called_once_with(self.task_manager._logger)

                        signal_mock.assert_has_calls([
                            call(signal.SIGTERM, main.daemon_shutdown),
                            call(signal.SIGINT, signal.SIG_IGN),
                            call(signal.SIGTERM, signal.SIG_IGN),
                        ], any_order=False)

                        exit_mock.assert_not_called()

            self.assertEqual(self.task_manager.hub._login.call_count, max_runs)
            self.assertEqual(self.task_manager.update_worker_info.call_count, max_runs)
            self.assertEqual(self.task_manager.update_tasks.call_count, max_runs)
            self.assertEqual(self.task_manager.get_next_task.call_count, max_runs)
            self.assertEqual(self.task_manager.sleep.call_count, max_runs - 1)
            self.assertEqual(self.task_manager.shutdown.call_count, 1)
Beispiel #4
0
    def test_main_loop_foreground_with_file_logger(self):
        max_runs = 1

        with patch('kobo.worker.main.TaskManager', self.create_task_manager()):
            with patch.object(main.kobo, 'log') as log_mock:
                with patch.object(main.signal, 'signal') as signal_mock:
                    with patch.object(main.sys, 'exit') as exit_mock:
                        main.main_loop({
                            'max_runs': max_runs,
                            'LOG_FILE': '/tmp/log.txt',
                        }, foreground=True)

                        log_mock.add_rotating_file_logger.assert_called_once_with(
                            self.task_manager._logger,
                            '/tmp/log.txt',
                            log_level=10,
                        )

                        log_mock.add_stderr_logger.assert_called_once_with(self.task_manager._logger)

                        signal_mock.assert_has_calls([
                            call(signal.SIGTERM, main.daemon_shutdown),
                            call(signal.SIGINT, signal.SIG_IGN),
                            call(signal.SIGTERM, signal.SIG_IGN),
                        ], any_order=False)

                        exit_mock.assert_not_called()

            self.assertEqual(self.task_manager.hub._login.call_count, max_runs)
            self.assertEqual(self.task_manager.update_worker_info.call_count, max_runs)
            self.assertEqual(self.task_manager.update_tasks.call_count, max_runs)
            self.assertEqual(self.task_manager.get_next_task.call_count, max_runs)
            self.assertEqual(self.task_manager.sleep.call_count, max_runs - 1)
            self.assertEqual(self.task_manager.shutdown.call_count, 1)
Beispiel #5
0
    def test_main_loop_task_manager_exception(self):
        with patch('kobo.worker.main.TaskManager', Mock(side_effect=ValueError)) as mock_tm:
            with patch.object(main.signal, 'signal') as signal_mock:
                with patch.object(main.sys, 'exit') as exit_mock:
                    with self.assertRaises(ValueError):
                        main.main_loop({}, foreground=False)

                        mock_tm.assert_called_once()
                        signal_mock.assert_called_once_with(signal.SIGTERM, main.daemon_shutdown)
                        exit_mock.assert_not_called()
Beispiel #6
0
    def test_main_loop_task_manager_exception(self):
        with patch('kobo.worker.main.TaskManager', Mock(side_effect=ValueError)) as mock_tm:
            with patch.object(main.signal, 'signal') as signal_mock:
                with patch.object(main.sys, 'exit') as exit_mock:
                    with self.assertRaises(ValueError):
                        main.main_loop({}, foreground=False)

                        mock_tm.assert_called_once()
                        signal_mock.assert_called_once_with(signal.SIGTERM, main.daemon_shutdown)
                        exit_mock.assert_not_called()