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)]