def is_connected_still_False_when_connect_fails(self, client):
client.connect.side_effect = socket.error
cxn = Connection("host")
try:
cxn.open()
except socket.error:
pass
assert cxn.is_connected is False
def short_circuits_if_already_connected(self, client):
cxn = Connection("host")
# First call will set self.transport to fixture's mock
cxn.open()
# Second call will check .is_connected which will see active==True,
# and short circuit
cxn.open()
assert client.connect.call_count == 1
def uses_proxycommand_as_sock_for_Client_connect(self, moxy, client):
"uses ProxyCommand from gateway as 'sock' arg to SSHClient.connect"
# Setup
main = Connection("host", gateway="net catty %h %p")
main.open()
# Expect ProxyCommand instantiation
moxy.assert_called_once_with("net catty host 22")
# Expect result of that as sock arg to connect()
sock_arg = client.connect.call_args[1]["sock"]
assert sock_arg is moxy.return_value
def uses_gateway_channel_as_sock_for_SSHClient_connect(self, Client):
"uses Connection gateway as 'sock' arg to SSHClient.connect"
# Setup
mock_gw = Mock()
mock_main = Mock()
Client.side_effect = [mock_gw, mock_main]
gw = Connection("otherhost")
gw.open = Mock(wraps=gw.open)
main = Connection("host", gateway=gw)
main.open()
# Expect gateway is also open()'d
gw.open.assert_called_once_with()
# Expect direct-tcpip channel open on 1st client
open_channel = mock_gw.get_transport.return_value.open_channel
kwargs = open_channel.call_args[1]
assert kwargs["kind"] == "direct-tcpip"
assert kwargs["dest_addr"], "host" == 22
# Expect result of that channel open as sock arg to connect()
sock_arg = mock_main.connect.call_args[1]["sock"]
assert sock_arg is open_channel.return_value
def calls_open_for_you(self, Remote, client):
c = Connection("host")
c.open = Mock()
c.sudo("command")
assert c.open.called
def calls_open_for_you(self, client):
c = Connection("host")
c.open = Mock()
c.transport = Mock() # so create_session no asplode
c.create_session()
assert c.open.called
def calls_SSHClient_close(self, client):
"calls paramiko.SSHClient.close()"
c = Connection("host")
c.open()
c.close()
client.close.assert_called_with()
def has_no_required_args_and_returns_None(self, client):
c = Connection("host")
c.open()
assert c.close() is None
def is_connected_True_when_successful(self, client):
c = Connection("host")
c.open()
assert c.is_connected is True
