def test_locationFooBarFoo(self):
"""
Test finding foos at the second level.
"""
xp = XPathQuery("/foo/bar/foo")
self.assertEquals(xp.matches(self.e), 1)
self.assertEquals(xp.queryForNodes(self.e), [self.subfoo, self.subfoo3, self.subfoo4])
def test_textConditionUnicode(self):
"""
A node can be matched by text with non-ascii code points.
"""
xp = XPathQuery(u"//*[text()='\N{SNOWMAN}']")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.quux])
def test_position(self):
"""
Test finding element at position.
"""
xp = XPathQuery("/foo/bar[2]")
self.assertEqual(xp.matches(self.e), 1)
self.assertEqual(xp.queryForNodes(self.e), [self.bar1])
def test_attributeWithValueAny(self):
"""
Test find nodes with attribute having value.
"""
xp = XPathQuery("/foo/*[@attrib2='value2']")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar2])
def test_queryForString(self):
"""
Test for queryForString and queryForStringList.
"""
xp = XPathQuery("/foo")
self.assertEquals(xp.queryForString(self.e), "somecontent")
self.assertEquals(xp.queryForStringList(self.e), ["somecontent", "somemorecontent"])
def test_locationAllChilds(self):
"""
Test finding childs of foo.
"""
xp = XPathQuery("/foo/*")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar4, self.bar5, self.bar6, self.bar7])
def test_andOperator(self):
"""
Test boolean and operator in condition.
"""
xp = XPathQuery("//bar[@attrib4='value4' and @attrib5='value5']")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar5])
def test_orOperator(self):
"""
Test boolean or operator in condition.
"""
xp = XPathQuery("//bar[@attrib5='value4' or @attrib5='value5']")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar5, self.bar6])
def test_queryForStringListAnyLocation(self):
"""
queryforStringList on relative paths returns all their CDATA.
"""
xp = XPathQuery("//foo")
self.assertEqual(xp.queryForStringList(self.e),
["somecontent", "somemorecontent"])
def test_locationWithValueUnicode(self):
"""
Nodes' attributes can be matched with non-ASCII values.
"""
xp = XPathQuery(u"/foo/*[@attrib6='á']")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar7])
def test_queryForNodes(self):
"""
Test finding nodes.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.queryForNodes(self.e), [self.bar1, self.bar2,
self.bar4, self.bar5,
self.bar6, self.bar7])
def test_anyLocationAndText(self):
"""
Test finding any nodes named gar and getting their text contents.
"""
xp = XPathQuery("//gar")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.gar1, self.gar2, self.gar3, self.gar4])
self.assertEquals(xp.queryForStringList(self.e), ["DEF", "ABC", "JKL", "MNO"])
def test_booleanOperatorsParens(self):
"""
Test multiple boolean operators in condition with parens.
"""
xp = XPathQuery("""//bar[@attrib4='value4' and
(@attrib5='value4' or @attrib5='value6')]""")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar6, self.bar7])
def test_anyLocation(self):
"""
Test finding any nodes named bar.
"""
xp = XPathQuery("//bar")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(
xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar3, self.bar4, self.bar5, self.bar6, self.bar7]
)
def test_anyLocationQueryForString(self):
"""
L{XPathQuery.queryForString} should raise a L{NotImplementedError}
for any location.
"""
xp = XPathQuery("//bar")
self.assertRaises(NotImplementedError, xp.queryForString, None)
def _sendX1Xml(self, xml):
log.msg('x1 send out xml directly')
self.send(xml)
expectResp = XPathQuery("//%s" % (self.reqMsg.expectedRes))
def recvCmdResp(cancelCmdCallID, element):
cancelCmdCallID.cancel()
def send_resp2cmd_queue(x1CliInst):
log.msg('recv X1 response')
x1CliInst.factory.cmd_queue.put(
RespMsg(result="OK", content=x1CliInst.recvRootElement))
self.addOnetimeObserver(xmlstream.STREAM_END_EVENT,
send_resp2cmd_queue)
def cancelCmdResp():
self.removeObserver(expectResp, recvCmdResp)
log.msg("X1 did't receive response. request:%s." %
self.reqMsg.content)
from twisted.words.xish import domish
self.factory.cmd_queue.put(
RespMsg(result="Unavailable",
content=domish.Element((None, 'Unavailable'))))
self.reqMsg = None
self.transport.loseConnection()
cancelCmdRespCallId = self.callLater(X1ClientProtocol.timeOut,
cancelCmdResp)
self.addOnetimeObserver(expectResp, recvCmdResp, 0,
cancelCmdRespCallId)
return cancelCmdResp
def test_anyLocation(self):
"""
Test finding any nodes named bar.
"""
xp = XPathQuery("//bar")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(
xp.queryForNodes(self.e),
[
self.bar1,
self.bar2,
self.bar3,
self.bar4,
self.bar5,
self.bar6,
self.bar7,
],
)
def _getCmdRespXmlString(self, checkElement, respMsg):
log.msg('get respMsg: %s; checkElement: %s' %
(respMsg.result, checkElement))
if respMsg.result == 'OK' and XPathQuery(
'//%s' % checkElement).matches(respMsg.content):
resp = CmdResp('success', respMsg.content).toXml()
return resp
resp = CmdResp('failure', respMsg.content).toXml()
return resp
class X2ServerProtocol(MultiXmlStream):
X2PingReqPath = XPathQuery('/payload/ping/pingType/pingRequest')
getX2PingReqSeqNbr = XPathQuery('/payload/ping/seqNbr').queryForString
X2IRIEvent = XPathQuery('/payload/extPDU/IRI-Event')
def _genPingResp(self, element):
SeqNbr = int(X2ServerProtocol.getX2PingReqSeqNbr(element))
log.msg("recv X2 Ping request, SeqNbr: %d" % SeqNbr)
self.pingResp = li_xml_temp.pingX2Resp(SeqNbr)
def sendPingResp(SeqNbr, x2ProtInst):
x2ProtInst.send(x2ProtInst.pingResp)
x2ProtInst.pingResp = None
log.msg("send X2 Ping response, SeqNbr: %d" % SeqNbr)
self.addOnetimeObserver(xmlstream.STREAM_END_EVENT, sendPingResp, 0,
SeqNbr)
def _getIRIEvent(self, element):
log.msg('recv X2 message: %s' %
X2ServerProtocol.X2IRIEvent.queryForNodes(element)[0].name)
if self.factory.x2LogHandler is not None:
def recordIRIEvent(x2ProtInst):
x2ProtInst.factory.x2LogHandler.msg(
x2ProtInst.recvRootElement.toXml())
self.addOnetimeObserver(xmlstream.STREAM_END_EVENT, recordIRIEvent)
def __init__(self):
self.recvRootElement = None
self.pingResp = None
MultiXmlStream.__init__(self)
self.addObserver(X2ServerProtocol.X2PingReqPath, self._genPingResp)
self.addObserver(X2ServerProtocol.X2IRIEvent, self._getIRIEvent)
def connectionMade(self):
log.msg('x2 connection is established')
MultiXmlStream.connectionMade(self)
def _getX1ReqXmlString(self, cmdRootElement, **kwargs):
xmlPara = {}
log.msg('recv cmd xml: %s' % cmdRootElement.toXml())
for arg in self.args:
log.msg('query arg: %s' % arg)
xmlPara[arg] = XPathQuery("/cmd/%s" %
arg).queryForString(cmdRootElement)
for k, v in kwargs.iteritems():
xmlPara[k] = v
from importlib import import_module
m = import_module('lixml.li_xml_temp')
fn = getattr(m, self.text)
return fn(**xmlPara)
class CmdCB(object):
def __init__(self, text, *args):
self.text = text
self.xPathQuery = XPathQuery("/action[text() = '%s']" % text)
self.args = args
def _getCmdRespXmlString(self, checkElement, respMsg):
log.msg('get respMsg: %s; checkElement: %s' %
(respMsg.result, checkElement))
if respMsg.result == 'OK' and XPathQuery(
'//%s' % checkElement).matches(respMsg.content):
resp = CmdResp('success', respMsg.content).toXml()
return resp
resp = CmdResp('failure', respMsg.content).toXml()
return resp
def checkCmdAction(self, protoInst, element):
log.msg('recv cmd, action: %s, and add onetime oberser' %
self.xPathQuery.queryForString(element))
protoInst.addOnetimeObserver(xmlstream.STREAM_END_EVENT,
self._sendXml2X1Client)
def _getX1ReqXmlString(self, cmdRootElement, **kwargs):
xmlPara = {}
log.msg('recv cmd xml: %s' % cmdRootElement.toXml())
for arg in self.args:
log.msg('query arg: %s' % arg)
xmlPara[arg] = XPathQuery("/cmd/%s" %
arg).queryForString(cmdRootElement)
for k, v in kwargs.iteritems():
xmlPara[k] = v
from importlib import import_module
m = import_module('lixml.li_xml_temp')
fn = getattr(m, self.text)
return fn(**xmlPara)
'''
_sendCmdRespXmlString & _sendXml2X1Client will be overlapped by inherited class
'''
def _sendCmdRespXmlString(self, respMsg, protoInst):
protoInst.send(self._getCmdRespXmlString('success', respMsg))
def _sendXml2X1Client(self, protoInst):
protoInst.factory.cmd_queue.get().addCallback(
self._sendCmdRespXmlString, protoInst)
def test_receiveRoot(self):
"""
Receiving the starttag of the root element results in stream start.
"""
xmlString = []
def storeElement(xmlInstance):
xmlString.append(xmlInstance)
self.multixmlstream.addObserver(XPathQuery("/body/tl-1"), storeElement)
self.multixmlstream.connectionMade()
self.multixmlstream.dataReceived(
"<root><body><hd/></body><body><tl-1><bb1/></tl-1></body>")
self.multixmlstream.dataReceived(
'<body><tl-1><bb2/>Hi</tl-1></body></root>')
self.assertEqual(2, len(xmlString))
self.assertEqual('tl-1', xmlString[0].children[0].name)
self.assertEqual('bb1', xmlString[0].children[0].children[0].name)
self.assertEqual('bb2', xmlString[1].children[0].children[0].name)
def test_namespaceFound(self):
"""
Test matching node with namespace.
"""
xp = XPathQuery("/foo[@xmlns='testns']/bar")
self.assertEqual(xp.matches(self.e), 1)
def testFunctionality(self):
xp = XPathQuery("/foo/bar")
self.assertEquals(xp.matches(self.e), 1)
xp = XPathQuery("/foo/bar/foo")
self.assertEquals(xp.matches(self.e), 1)
self.assertEquals(xp.queryForNodes(self.e), [self.subfoo])
xp = XPathQuery("/foo/bar3")
self.assertEquals(xp.matches(self.e), 0)
xp = XPathQuery("/foo/*")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar4])
xp = XPathQuery("/foo[@attrib1]")
self.assertEquals(xp.matches(self.e), True)
xp = XPathQuery("/foo/*[@attrib2='value2']")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.bar2])
# XXX: Revist this, given new grammar
# xp = XPathQuery("/foo/bar[2]")
# self.assertEquals(xp.matches(self.e), 1)
# self.assertEquals(xp.queryForNodes(self.e), [self.bar1])
xp = XPathQuery("/foo[@xmlns='testns']/bar")
self.assertEquals(xp.matches(self.e), 1)
xp = XPathQuery("/foo[@xmlns='badns']/bar2")
self.assertEquals(xp.matches(self.e), 0)
xp = XPathQuery("/foo[@attrib1='value1']")
self.assertEquals(xp.matches(self.e), 1)
xp = XPathQuery("/foo")
self.assertEquals(xp.queryForString(self.e), "somecontent")
self.assertEquals(xp.queryForStringList(self.e), ["somecontent", "somemorecontent"])
xp = XPathQuery("/foo/bar")
self.assertEquals(xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar4])
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEquals(xp.matches(self.e), True)
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEquals(xp.matches(self.e), True)
xp = XPathQuery("//gar")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.gar1, self.gar2])
self.assertEquals(xp.queryForStringList(self.e), ["DEF", "ABC"])
xp = XPathQuery("//bar")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar3, self.bar4])
def testFunctionality(self):
xp = XPathQuery("/foo/bar")
self.assertEquals(xp.matches(self.e), 1)
xp = XPathQuery("/foo/bar/foo")
self.assertEquals(xp.matches(self.e), 1)
self.assertEquals(xp.queryForNodes(self.e), [self.subfoo])
xp = XPathQuery("/foo/bar3")
self.assertEquals(xp.matches(self.e), 0)
xp = XPathQuery("/foo/*")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e),
[self.bar1, self.bar2, self.bar4])
xp = XPathQuery("/foo[@attrib1]")
self.assertEquals(xp.matches(self.e), True)
xp = XPathQuery("/foo/*[@attrib2='value2']")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.bar2])
# XXX: Revist this, given new grammar
# xp = XPathQuery("/foo/bar[2]")
# self.assertEquals(xp.matches(self.e), 1)
# self.assertEquals(xp.queryForNodes(self.e), [self.bar1])
xp = XPathQuery("/foo[@xmlns='testns']/bar")
self.assertEquals(xp.matches(self.e), 1)
xp = XPathQuery("/foo[@xmlns='badns']/bar2")
self.assertEquals(xp.matches(self.e), 0)
xp = XPathQuery("/foo[@attrib1='value1']")
self.assertEquals(xp.matches(self.e), 1)
xp = XPathQuery("/foo")
self.assertEquals(xp.queryForString(self.e), "somecontent")
self.assertEquals(xp.queryForStringList(self.e),
["somecontent", "somemorecontent"])
xp = XPathQuery("/foo/bar")
self.assertEquals(xp.queryForNodes(self.e),
[self.bar1, self.bar2, self.bar4])
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEquals(xp.matches(self.e), True)
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEquals(xp.matches(self.e), True)
xp = XPathQuery("//gar")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e), [self.gar1, self.gar2])
self.assertEquals(xp.queryForStringList(self.e), ["DEF", "ABC"])
xp = XPathQuery("//bar")
self.assertEquals(xp.matches(self.e), True)
self.assertEquals(xp.queryForNodes(self.e),
[self.bar1, self.bar2, self.bar3, self.bar4])
def test_locationNoBar3(self):
"""
Test not finding bar3.
"""
xp = XPathQuery("/foo/bar3")
self.assertEqual(xp.matches(self.e), 0)
def test_textNotOperator(self):
"""
Test for not operator.
"""
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEqual(xp.matches(self.e), True)
def test_textCondition(self):
"""
Test matching a node with given text.
"""
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEqual(xp.matches(self.e), True)
def test_queryForString(self):
"""
queryforString on absolute paths returns their first CDATA.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForString(self.e), "somecontent")
def test_attributeWithValue(self):
"""
Test matching node with attribute having value.
"""
xp = XPathQuery("/foo[@attrib1='value1']")
self.assertEqual(xp.matches(self.e), 1)
def test_namespaceNotFound(self):
"""
Test not matching node with wrong namespace.
"""
xp = XPathQuery("/foo[@xmlns='badns']/bar2")
self.assertEqual(xp.matches(self.e), 0)
def test_queryForString(self):
"""
queryforString on absolute paths returns their first CDATA.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForString(self.e), "somecontent")
def test_locationFooBar(self):
"""
Test matching foo with child bar.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.matches(self.e), 1)
def test_namespaceNotFound(self):
"""
Test not matching node with wrong namespace.
"""
xp = XPathQuery("/foo[@xmlns='badns']/bar2")
self.assertEqual(xp.matches(self.e), 0)
def test_attributeWithValue(self):
"""
Test matching node with attribute having value.
"""
xp = XPathQuery("/foo[@attrib1='value1']")
self.assertEqual(xp.matches(self.e), 1)
def test_textNotOperator(self):
"""
Test for not operator.
"""
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEqual(xp.matches(self.e), True)
def test_textCondition(self):
"""
Test matching a node with given text.
"""
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEqual(xp.matches(self.e), True)
def test_locationFooBar(self):
"""
Test matching foo with child bar.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.matches(self.e), 1)
def __init__(self, text, *args):
self.text = text
self.xPathQuery = XPathQuery("/action[text() = '%s']" % text)
self.args = args
def test_locationNoBar3(self):
"""
Test not finding bar3.
"""
xp = XPathQuery("/foo/bar3")
self.assertEqual(xp.matches(self.e), 0)
def test_attribute(self):
"""
Test matching foo with attribute.
"""
xp = XPathQuery("/foo[@attrib1]")
self.assertEqual(xp.matches(self.e), True)
def test_attribute(self):
"""
Test matching foo with attribute.
"""
xp = XPathQuery("/foo[@attrib1]")
self.assertEqual(xp.matches(self.e), True)
def test_namespaceFound(self):
"""
Test matching node with namespace.
"""
xp = XPathQuery("/foo[@xmlns='testns']/bar")
self.assertEqual(xp.matches(self.e), 1)
class X1ClientProtocol(MultiXmlStream):
X1PingRespPath = XPathQuery('/payload/ping/pingType/pingResponse')
getX1PingRespSeqNbr = XPathQuery('/payload/ping/seqNbr').queryForString
X1AlarmPath = XPathQuery(
'/payload/extPDU/LI-ADM-Event/lI-ADM-MessageSequence/alarmNotification'
)
callLater = reactor.callLater
timeOut = 30
def connectionMade(self):
log.msg('x1 tcp connection is made')
self.alarmCounter = 0
self.factory.x1_queue.get().addCallback(self.cmdReceived)
if config.pingEnable:
self.lcping = task.LoopingCall(self._sendPingRequest)
self.lcping.start(config.ping_delay)
MultiXmlStream.connectionMade(self)
def recordX1Alarm(element):
self.alarmCounter += 1
log.msg("recv X1 total alrams: %d" % self.alarmCounter)
log.msg("recv X1 alarm: %s" % element.toXml())
self.addObserver(X1ClientProtocol.X1AlarmPath, recordX1Alarm)
def cmdReceived(self, reqMsg):
if reqMsg.type == 'cmd':
log.msg("recv cmd: %s" % reqMsg.content)
self.reqMsg = reqMsg
self._sendX1Xml(self.reqMsg.content)
self.factory.x1_queue.get().addCallback(self.cmdReceived)
def connectionLost(self, Why):
log.msg("connnect is lost, reason:%s" % Why)
if hasattr(self, 'lcping') and self.lcping is not None:
lcping, self.lcping = self.lcping, None
lcping.stop()
log.msg('server existed')
reactor.stop()
if self.factory.x1_queue:
self.factory.x1_queue = None
return Why
def _sendPingRequest(self):
self.factory.state.x1Seq += 1
self.send(li_xml_temp.pingX1Req(self.factory.state.x1Seq))
log.msg("x1 ping request is sent out, x1Seq =",
self.factory.state.x1Seq)
def recvPingResp(cancelPingId, x1Seq, element):
cancelPingId.cancel()
RecvX1Seq = int(X1ClientProtocol.getX1PingRespSeqNbr(element))
log.msg("recv x1 ping response, x1Seq=%d; send out x1Seq=%d" %
(RecvX1Seq, x1Seq))
def ping_cancel():
self.removeObserver(X1ClientProtocol.X1PingRespPath, recvPingResp)
log.msg("x1 ping response is not received ")
self.transport.loseConnection()
pingCallID = self.callLater(config.ping_timeout, ping_cancel)
self.addOnetimeObserver(X1ClientProtocol.X1PingRespPath, recvPingResp,
0, pingCallID, self.factory.state.x1Seq)
def _sendX1Xml(self, xml):
log.msg('x1 send out xml directly')
self.send(xml)
expectResp = XPathQuery("//%s" % (self.reqMsg.expectedRes))
def recvCmdResp(cancelCmdCallID, element):
cancelCmdCallID.cancel()
def send_resp2cmd_queue(x1CliInst):
log.msg('recv X1 response')
x1CliInst.factory.cmd_queue.put(
RespMsg(result="OK", content=x1CliInst.recvRootElement))
self.addOnetimeObserver(xmlstream.STREAM_END_EVENT,
send_resp2cmd_queue)
def cancelCmdResp():
self.removeObserver(expectResp, recvCmdResp)
log.msg("X1 did't receive response. request:%s." %
self.reqMsg.content)
from twisted.words.xish import domish
self.factory.cmd_queue.put(
RespMsg(result="Unavailable",
content=domish.Element((None, 'Unavailable'))))
self.reqMsg = None
self.transport.loseConnection()
cancelCmdRespCallId = self.callLater(X1ClientProtocol.timeOut,
cancelCmdResp)
self.addOnetimeObserver(expectResp, recvCmdResp, 0,
cancelCmdRespCallId)
return cancelCmdResp
