def __init__(self, device_handler):
capabilities = Capabilities(device_handler.get_capabilities())
Session.__init__(self, capabilities)
self._host = None
self._host_keys = paramiko.HostKeys()
self._transport = None
self._connected = False
self._channel = None
self._channel_id = None
self._channel_name = None
self._buffer = StringIO()
# parsing-related, see _parse()
self._device_handler = device_handler
self._parsing_state10 = 0
self._parsing_pos10 = 0
self._parsing_pos11 = 0
self._parsing_state11 = 0
self._expchunksize = 0
self._curchunksize = 0
self._inendpos = 0
self._size_num_list = []
self._message_list = []
self._closing = threading.Event()
self.logger = SessionLoggerAdapter(logger, {'session': self})
def test_get_with_defaults_missing_capability(self, mock_request):
session = ncclient.transport.SSHSession(self.device_handler)
session._server_capabilities = Capabilities([])
obj = Get(session, self.device_handler, raise_mode=RaiseMode.ALL)
self.assertRaises(MissingCapabilityError,
obj.request,
with_defaults='report-all')
def test_rpc_capability_error(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
session._server_capabilities = [':running']
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
obj._assert(':running')
self.assertRaises(MissingCapabilityError, obj._assert, ':candidate')
def test_get_config_with_defaults_missing_capability(self, mock_request):
session = ncclient.transport.SSHSession(self.device_handler)
session._server_capabilities = Capabilities([])
obj = GetConfig(session, self.device_handler, raise_mode=RaiseMode.ALL)
source = 'candidate'
self.assertRaises(MissingCapabilityError,
obj.request,
source,
with_defaults='explicit')
def test_rpc_timeout_error(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
reply = RPCReply(xml1)
obj.deliver_reply(reply)
node = new_ele("commit")
sub_ele(node, "confirmed")
mock_thread.return_value = False
self.assertRaises(TimeoutExpiredError, obj._request, node)
def parse(raw):
"Returns tuple of (session-id (str), capabilities (Capabilities)"
sid, capabilities = 0, []
root = to_ele(raw)
for child in root.getchildren():
if child.tag == qualify("session-id") or child.tag == "session-id":
sid = child.text
elif child.tag == qualify("capabilities") or child.tag == "capabilities" :
for cap in child.getchildren():
if cap.tag == qualify("capability") or cap.tag == "capability":
capabilities.append(cap.text)
return sid, Capabilities(capabilities)
def test_rpc_rpcerror(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
reply = RPCReply(xml1)
obj._reply = reply
node = new_ele("commit")
sub_ele(node, "confirmed")
err = RPCError(to_ele(xml2))
obj.deliver_error(err)
self.assertRaises(RPCError, obj._request, node)
def test_rpc_async(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session,
device_handler,
raise_mode=RaiseMode.ALL,
timeout=0,
async=True)
reply = RPCReply(xml1)
obj._reply = reply
node = new_ele("commit")
result = obj._request(node)
self.assertEqual(result, obj)
def __init__(self, device_handler):
capabilities = Capabilities(device_handler.get_capabilities())
Session.__init__(self, capabilities)
self._host_keys = paramiko.HostKeys()
self._transport = None
self._connected = False
self._channel = None
self._channel_id = None
self._channel_name = None
self._buffer = StringIO() # for incoming data
# parsing-related, see _parse()
self._parsing_state = 0
self._parsing_pos = 0
self._device_handler = device_handler
def test_get_with_defaults_not_supported(self, mock_request):
session = ncclient.transport.SSHSession(self.device_handler)
session._server_capabilities = Capabilities([
"urn:ietf:params:netconf:capability:with-defaults:1.0"
"?basic-mode=explicit"
"&also-supported=report-all,trim"
])
obj = Get(session, self.device_handler, raise_mode=RaiseMode.ALL)
expected_error = (
"Invalid 'with-defaults' mode 'report-all-tagged'; the server "
"only supports the following: explicit, report-all, trim")
self.assertRaisesRegexp(WithDefaultsError,
expected_error,
obj.request,
with_defaults='report-all-tagged')
def __init__(self, device_handler):
capabilities = Capabilities(device_handler.get_capabilities())
Session.__init__(self, capabilities)
self._host = None
self._host_keys = paramiko.HostKeys()
self._transport = None
self._connected = False
self._channel = None
self._channel_id = None
self._channel_name = None
self._buffer = StringIO()
self._device_handler = device_handler
self._message_list = []
self._closing = threading.Event()
self.parser = DefaultXMLParser(self) # SAX or DOM parser
self.logger = SessionLoggerAdapter(logger, {'session': self})
def test_get_with_defaults_basic_mode(self, mock_request):
session = ncclient.transport.SSHSession(self.device_handler)
session._server_capabilities = Capabilities([
"urn:ietf:params:netconf:capability:with-defaults:1.0"
"?basic-mode=explicit"
])
obj = Get(session, self.device_handler, raise_mode=RaiseMode.ALL)
obj.request(with_defaults='explicit')
expected_xml = etree.fromstring(
'<nc:get xmlns:nc="{base}">'
'<ns0:with-defaults xmlns:ns0="{defaults}">explicit</ns0:with-defaults>'
'</nc:get>'.format(base=BASE_NS_1_0,
defaults=NETCONF_WITH_DEFAULTS_NS))
call = mock_request.call_args_list[0][0][0]
self.assertEqual(etree.tostring(call), etree.tostring(expected_xml))
def __init__(self, device_handler):
capabilities = Capabilities(device_handler.get_capabilities())
Session.__init__(self, capabilities)
self._host_keys = paramiko.HostKeys()
self._transport = None
self._connected = False
self._channel = None
self._channel_id = None
self._channel_name = None
self._buffer = StringIO() # for incoming data
# parsing-related, see _parse()
self._device_handler = device_handler
self._parsing_state10 = 0
self._parsing_pos10 = 0
self._parsing_pos11 = 0
self._parsing_state11 = 0
self._expchunksize = 0
self._curchunksize = 0
self._inendpos = 0
self._size_num_list = []
self._message_list = []
def test_rpc_send(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
reply = RPCReply(xml1)
obj._reply = reply
node = new_ele("commit")
sub_ele(node, "confirmed")
sub_ele(node, "confirm-timeout").text = "50"
sub_ele(node, "log").text = "message"
result = obj._request(node)
ele = new_ele("rpc", {"message-id": obj._id},
**device_handler.get_xml_extra_prefix_kwargs())
ele.append(node)
node = to_xml(ele)
mock_send.assert_called_once_with(node)
self.assertEqual(result.data_xml, (NCElement(
reply, device_handler.transform_reply())).data_xml)
self.assertEqual(obj.session, session)
self.assertEqual(reply, obj.reply)
def _mock_device_handler_and_session(self):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
return device_handler, session
def _connect(cls):
if cls._session is not None:
cls._session.close()
session = transport.StdIOSession(Capabilities(CAPABILITIES))
session.connect(path=shlex.split(cls.BIN_PATH))
cls._session = session
