Beispiel #1
0
    def test_serve_threaded(self):
        mock_context = MagicMock()
        mock_delay = MagicMock()
        trail_server = TrailServer(self.mock_trail_definition,
                                   context=mock_context,
                                   delay=mock_delay)
        trail_server.serve(threaded=True)

        args = self.mock_process.call_args[0]
        kwargs = self.mock_process.call_args[1]

        self.assertEqual(args, tuple())
        self.assertEqual(kwargs['target'], sigint_resistant_function)
        args_for_sigint_resistant_function = kwargs['args']
        kwargs_for_sigint_resistant_function = kwargs['kwargs']
        passed_trail_manager, passed_root_step, passed_socket, passed_backup_function = \
            args_for_sigint_resistant_function
        self.assertEqual(passed_trail_manager, trail_manager)
        self.assertEqual(passed_root_step, self.mock_root_step)
        self.assertEqual(passed_socket, self.mock_api_socket)
        passed_backup_function(self.mock_root_step)
        self.mock_backup_trail.assert_called_once_with(self.mock_root_step,
                                                       trail_server.dag_file)

        self.assertEqual(kwargs_for_sigint_resistant_function,
                         dict(delay=mock_delay))

        self.mock_process_object.start.assert_called_once_with()
Beispiel #2
0
    def test_restore_trail(self):
        restore_trail_patcher = patch('autotrail.layer2.trail.restore_trail')
        mock_restore_trail = restore_trail_patcher.start()

        trail_server = TrailServer(self.mock_trail_definition)
        trail_server.restore_trail('mock_dag_file')

        mock_restore_trail.assert_called_once_with(
            self.mock_root_step, 'mock_dag_file', {
                Step.BLOCKED: Step.PAUSED,
                Step.RUN: Step.PAUSED
            })

        restore_trail_patcher.stop()
Beispiel #3
0
    def test_initialize_with_all_parameters(self):
        mock_socket_file = MagicMock()
        mock_dag_file = MagicMock()
        mock_context = MagicMock()
        mock_delay = MagicMock()
        mock_timeout = MagicMock()
        mock_backlog_count = MagicMock()

        trail_server = TrailServer(self.mock_trail_definition,
                                   socket_file=mock_socket_file,
                                   dag_file=mock_dag_file,
                                   context=mock_context,
                                   delay=mock_delay,
                                   timeout=mock_timeout,
                                   backlog_count=mock_backlog_count)

        self.assertEqual(trail_server.context, mock_context)
        self.mock_make_dag.assert_called_once_with(self.mock_trail_definition)
        self.assertEqual(trail_server.root_step, self.mock_root_step)
        self.assertFalse(trail_server.started)
        self.assertEqual(trail_server.timeout, mock_timeout)
        self.assertEqual(trail_server.backlog_count, mock_backlog_count)
        self.assertEqual(trail_server.trail_process, None)
        self.assertEqual(trail_server.delay, mock_delay)
        self.assertEqual(trail_server.dag_file, mock_dag_file)
        self.assertEqual(trail_server.socket_file, mock_socket_file)
        self.mock_socket_server_setup.assert_called_once_with(
            mock_socket_file,
            backlog_count=mock_backlog_count,
            timeout=mock_timeout)
        self.assertEqual(trail_server.api_socket, self.mock_api_socket)
        self.assertEqual(self.mock_mktemp.call_count, 0)
Beispiel #4
0
    def test_serve_not_threaded(self):
        trail_manager_patcher = patch('autotrail.layer2.trail.trail_manager')
        mock_trail_manager = trail_manager_patcher.start()

        mock_context = MagicMock()
        mock_delay = MagicMock()
        trail_server = TrailServer(self.mock_trail_definition,
                                   context=mock_context,
                                   delay=mock_delay)
        trail_server.serve()

        root_step, api_socket, backup_function = mock_trail_manager.call_args[
            0]
        self.assertEqual(root_step, self.mock_root_step)
        self.assertEqual(api_socket, self.mock_api_socket)
        backup_function(self.mock_root_step)
        self.mock_backup_trail.assert_called_once_with(self.mock_root_step,
                                                       trail_server.dag_file)

        kwargs = mock_trail_manager.call_args[1]
        self.assertEqual(kwargs, dict(delay=mock_delay))

        trail_manager_patcher.stop()
Beispiel #5
0
    def test_initialize_with_required_parameters(self):
        trail_server = TrailServer(self.mock_trail_definition)

        self.assertEqual(trail_server.context, None)
        self.mock_make_dag.assert_called_once_with(self.mock_trail_definition)
        self.assertEqual(trail_server.root_step, self.mock_root_step)
        self.assertFalse(trail_server.started)
        self.assertEqual(trail_server.timeout, 0.0001)
        self.assertEqual(trail_server.backlog_count, 1)
        self.assertEqual(trail_server.trail_process, None)
        self.assertEqual(trail_server.delay, 1)

        self.mock_mktemp.assert_any_call(prefix='autotrail.')
        self.assertEqual(trail_server.dag_file, 'mock_temp_file')
        self.mock_mktemp.assert_any_call(prefix='autotrail.socket.')
        self.assertEqual(trail_server.socket_file, 'mock_temp_file')

        self.mock_socket_server_setup.assert_called_once_with('mock_temp_file',
                                                              backlog_count=1,
                                                              timeout=0.0001)
        self.assertEqual(trail_server.api_socket, self.mock_api_socket)
        self.assertEqual(self.mock_mktemp.call_count, 2)