def test_get_session(mock_interactivesession, mock_shell): terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell) terminal.initialize_terminal() assert terminal.get_session() == mock_interactivesession.return_value
def test_initialize_finalize(mock_interactivesession, mock_shell): finalize = mock.Mock() terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, finalize=finalize) terminal.initialize_terminal() terminal.close() finalize.assert_called_once_with()
def initialize_with_shells(self, shells, prepare=lambda: None, finalize=lambda: None): """ Initialize the terminal with the :class:`.InteractiveSession.Shell` based *shells* stack or a single shell. .. note:: The terminal session is not opened by this call. Either call :meth:`initialize_if_needed` directly or use initially empty proxies. The empty proxies can be created via methods :meth:`.runnerterminal.RunnerTerminal.create_empty_remote_proxy` and :meth:`.runnerterminal.RunnerTerminal.create_empty_recursive_proxy` The *prepare* callable should import any required modules and set the proxies. If the empty proxies are used in the initial setup then use :meth:`remoteproxies._RemoteProxy.set_from_remote_proxy` to replace the content. The *finalize* callable should do any special finalization of the proxies which are set in *prepare*. For example, if the proxy is managing a temporary file in the remote end, that could be removed in the *finalize*. .. note:: Proxies are automatically invalidated after finalization without any need to do special operations in *finalize* method. After finalization :class:`.runnerexceptions.InvalidProxySession` will be raised in case the remote object is accessed via proxies. The session is not guaranteed to be open when the *finalize* is called. That is why all possible exceptions are only logged. """ session = AutoRecoveringTerminal() session.initialize(shells=shells) self.initialize(session, prepare=prepare, finalize=finalize)
def test_finalize_raises(mock_interactivesession, mock_shell, intcaplog): def raise_exception(): raise Exception('message') mock_finalize = mock.Mock(side_effect=raise_exception) terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, finalize=mock_finalize) terminal.initialize_terminal() terminal.close() assert 'Failed to finalize the terminal: message' in intcaplog.text mock_close_terminal = mock_interactivesession.return_value.close_terminal mock_close_terminal.assert_called_once_with()
def _create_terminal(mock_shell, max_tries): terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, max_tries=max_tries, sleep_between_tries=3, broken_exceptions=_BrokenException) terminal.initialize_terminal() return terminal
def test_initialize_prepare(mock_interactivesession, mock_shell): prepare = mock.Mock() terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, prepare=prepare) terminal.initialize_terminal() prepare.assert_called_once_with()
def test_initialize_multiple_shells(mock_interactivesession): shells = [mock.Mock(spec_set=SshShell), mock.Mock(spec_set=SshShell)] terminal = AutoRecoveringTerminal() terminal.initialize(shells=shells) terminal.initialize_terminal() mock_interactivesession.return_value.spawn.assert_called_once_with( shells[0]) mock_interactivesession.return_value.push.assert_called_once_with( shells[1])
def test_verify_session(mock_interactivesession, mock_time_sleep, mock_shell): mock_finalize = mock.Mock() terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, broken_exceptions=_BrokenException, finalize=mock_finalize) terminal.initialize_terminal() m = mock.Mock(side_effect=_BrokenException) m.side_effect = _BrokenException with pytest.raises(_BrokenException): with terminal.auto_close(): m() m.assert_called_once_with() mock_finalize.assert_called_once_with()
def test_close_terminal_raises(mock_interactivesession, mock_shell, mock_time_sleep): mspawn = mock_interactivesession.return_value.spawn mspawn.side_effect = RaiseMaxNTimes(1) mclose_terminal = mock_interactivesession.return_value.close_terminal mclose_terminal.side_effect = RaiseMaxNTimes(1) terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell) terminal.initialize_terminal() mclose_terminal.assert_called_once_with()
def test_initialize_with_init_broken_exceptions(mock_interactivesession, mock_shell, mock_time_sleep, run_maxraise, exception, init_broken_exceptions): mspawn = mock_interactivesession.return_value.spawn mspawn.side_effect = RaiseMaxNTimes(run_maxraise, exception=exception) terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, init_broken_exceptions=init_broken_exceptions) terminal.initialize_terminal() assert mspawn.mock_calls == [ mock.call(mock_shell) for _ in range(run_maxraise + 1)]
def test_initialize_raises(mock_interactivesession, mock_shell, mock_time_sleep, spawn_maxraise, sleep_between_tries, max_tries): mspawn = mock_interactivesession.return_value.spawn mspawn.side_effect = RaiseMaxNTimes(spawn_maxraise) terminal = AutoRecoveringTerminal() terminal.initialize(shells=mock_shell, sleep_between_tries=sleep_between_tries, max_tries=max_tries) terminal.initialize_terminal() assert mspawn.mock_calls == [mock.call(mock_shell) for _ in range( spawn_maxraise + 1)] assert mock_time_sleep.mock_calls == [ mock.call(sleep_between_tries) for _ in range(spawn_maxraise)]