Ejemplo n.º 1
0
    def test_successful_execution(self, ):
        supervisor = sergeant.supervisor.Supervisor(
            worker_module_name=
            'tests.supervisor.workers.worker_successful_execution',
            worker_class_name='Worker',
            concurrent_workers=1,
            logger=unittest.mock.MagicMock(),
        )
        supervisor.supervise_loop = unittest.mock.MagicMock()
        supervisor.respawn_a_worker = unittest.mock.MagicMock()
        supervisor.start()
        supervisor.current_workers[0].process.wait(5)
        supervisor.supervise_worker(supervisor.current_workers[0])

        first_log = supervisor.logger.info.call_args_list[0]
        self.assertTrue(expr=first_log[1]['msg'].startswith(
            'spawned a new worker at pid: '), )
        self.assertEqual(
            first=first_log[1]['extra'],
            second={
                'supervisor': {
                    'worker_module_name':
                    'tests.supervisor.workers.worker_successful_execution',
                    'worker_class_name': 'Worker',
                    'concurrent_workers': 1,
                    'max_worker_memory_usage': None,
                },
            },
        )

        second_log = supervisor.logger.info.call_args_list[1]
        del second_log[1]['extra']['summary']['start_time']
        del second_log[1]['extra']['summary']['end_time']
        del second_log[1]['extra']['summary']['executor']
        self.assertEqual(
            first=second_log[1],
            second={
                'msg':
                f'worker({supervisor.current_workers[0].process.pid}) has finished successfully',
                'extra': {
                    'supervisor': {
                        'worker_module_name':
                        'tests.supervisor.workers.worker_successful_execution',
                        'worker_class_name': 'Worker',
                        'concurrent_workers': 1,
                        'max_worker_memory_usage': None,
                    },
                    'summary': {
                        'return_code': 0,
                        'initialize_exception': None,
                        'finalize_exception': None,
                        'executor_exception': None,
                        'respawn': False,
                        'stop': False,
                    },
                },
            },
        )

        supervisor.respawn_a_worker.assert_called_once()
Ejemplo n.º 2
0
    def test_import_module_exception(
        self,
        sys_exit,
    ):
        supervisor = sergeant.supervisor.Supervisor(
            worker_module_name='tests.supervisor.workers.worker_not_importable',
            worker_class_name='Worker',
            concurrent_workers=1,
            logger=unittest.mock.MagicMock(),
        )
        supervisor.supervise_loop = unittest.mock.MagicMock()
        supervisor.respawn_a_worker = unittest.mock.MagicMock()
        supervisor.stop_a_worker = unittest.mock.MagicMock()
        supervisor.start()
        supervisor.current_workers[0].process.wait(5)
        supervisor.supervise_worker(supervisor.current_workers[0])

        first_log = supervisor.logger.info.call_args_list[0]
        self.assertTrue(expr=first_log[1]['msg'].startswith(
            'spawned a new worker at pid: '), )
        self.assertEqual(
            first=first_log[1]['extra'],
            second={
                'supervisor': {
                    'worker_module_name':
                    'tests.supervisor.workers.worker_not_importable',
                    'worker_class_name': 'Worker',
                    'concurrent_workers': 1,
                    'max_worker_memory_usage': None,
                },
            },
        )

        second_log = supervisor.logger.critical.call_args_list[0]
        del second_log[1]['extra']['summary']['stacktrace']

        self.assertEqual(
            first=second_log[1],
            second={
                'msg':
                f'worker({supervisor.current_workers[0].process.pid}) importing the worker module has raised an exception: Exception(\'non importable module\')',
                'extra': {
                    'supervisor': {
                        'worker_module_name':
                        'tests.supervisor.workers.worker_not_importable',
                        'worker_class_name': 'Worker',
                        'concurrent_workers': 1,
                        'max_worker_memory_usage': None,
                    },
                    'summary': {
                        'return_code': 7,
                        'exception': 'Exception(\'non importable module\')',
                    }
                },
            },
        )

        sys_exit.assert_called_once()
Ejemplo n.º 3
0
    def test_unknown_class(
        self,
        sys_exit,
    ):
        supervisor = sergeant.supervisor.Supervisor(
            worker_module_name=
            'tests.supervisor.workers.worker_successful_execution',
            worker_class_name='UnknownClass',
            concurrent_workers=1,
            logger=unittest.mock.MagicMock(),
        )
        supervisor.supervise_loop = unittest.mock.MagicMock()
        supervisor.respawn_a_worker = unittest.mock.MagicMock()
        supervisor.start()
        supervisor.current_workers[0].process.wait(5)
        supervisor.supervise_worker(supervisor.current_workers[0])

        sys_exit.assert_called_once_with(1)

        first_log = supervisor.logger.info.call_args_list[0]
        self.assertTrue(expr=first_log[1]['msg'].startswith(
            'spawned a new worker at pid: '), )
        self.assertEqual(
            first=first_log[1]['extra'],
            second={
                'supervisor': {
                    'worker_module_name':
                    'tests.supervisor.workers.worker_successful_execution',
                    'worker_class_name': 'UnknownClass',
                    'concurrent_workers': 1,
                    'max_worker_memory_usage': None,
                },
            },
        )

        second_log = supervisor.logger.critical.call_args_list[0]
        self.assertEqual(
            first=second_log[1],
            second={
                'msg':
                'could not find worker class: tests.supervisor.workers.worker_successful_execution.UnknownClass',
                'extra': {
                    'supervisor': {
                        'worker_module_name':
                        'tests.supervisor.workers.worker_successful_execution',
                        'worker_class_name': 'UnknownClass',
                        'concurrent_workers': 1,
                        'max_worker_memory_usage': None,
                    },
                },
            },
        )