def makeDataElement(self):
""" Returns an XML Element that can be put into a jabber:x:avatar IQ stanza. """
data = Element((None, "data"))
data["mimetype"] = "image/png"
data.addContent(
base64.encodestring(self.getImageData()).replace("\n", ""))
return data
class Device(Element):
'''
classdocs
'''
def __init__(self, deviceName, rootUri, feeds=None, tags=None):
Element.__init__(self, (None, 'device'))
self._deviceName = Element((None, 'name'))
self._deviceName.addContent(deviceName)
self.addChild(self._deviceName)
self._rootUri = Element((None, 'rootUri'))
self._rootUri.addContent(rootUri)
self.addChild(self._rootUri)
self._feeds = []
if feeds is not None:
for f in feeds:
self._feeds.append(f)
self.addChild(f)
self._tags = []
if tags is not None:
for t in tags:
tag = Tag(t)
self.addChild(tag)
self._tags.append(tag)
def addFeed(self, feed):
self._feeds.append(feed)
self.addChild(feed)
def addTag(self, tag):
eTag = Tag(tag)
self._tags.append(eTag)
self.addChild(eTag)
def makeDataElement(self):
""" Returns an XML Element that can be put into a jabber:x:avatar IQ stanza. """
data = Element((None, "data"))
data["mimetype"] = "image/png"
data.addContent(
base64.encodestring(self.getImageData()).replace("\n", ""))
return data
def test_fromElement_bad(self):
el = Element((None, 'note'))
el['type'] = 'wrong'
el.addContent('bla')
n = Note.fromElement(el)
self.assertEquals(n.note_type, 'warn')
self.assertEquals(n.content, 'bla')
def test_toElement(self):
n = Note('bla', 'error')
el = Element((None, 'note'))
el['type'] = 'error'
el.addContent('bla')
self.assertEquals(n.toElement().toXml(), el.toXml())
def test_fromElement(self):
el = Element((None, 'note'))
el['type'] = 'error'
el.addContent('bla')
n = Note.fromElement(el)
self.assertEquals(n.note_type, 'error')
self.assertEquals(n.content, 'bla')
def streamStarted(self, rootelem):
# Create handshake
hs = Element(("jabber:component:accept", "handshake"))
hs.addContent(xmlstream.hashPassword(self.xmlstream.sid,
self.password))
# Setup observer to watch for handshake result
self.xmlstream.addOnetimeObserver("/handshake", self._handshakeEvent)
self.xmlstream.send(hs)
def test_onError_toPublishOnly(self):
errors = ['errornode1', 'errornode2']
node = nodes.PSErrorNode(testJid, self.mockPSClient)
node.errorChannels = Mock(side_effect=utils.good_side_effect(errors))
el = Element(('top', 'ns'))
el.addContent('im covered in bees')
el.toXml = Mock()
d = node.onError(el)
def cb(msg):
self.assertEquals(self.mockPSClient.publish.call_count, 2)
self.assertEquals(el.toXml.call_count, 0)
d.addCallback(cb)
return d
def test_onOutput_toLog(self):
outputs = ['log']
node = nodes.PSOutputNode(testJid, self.mockPSClient)
node.outputChannels = Mock(side_effect=utils.good_side_effect(outputs))
el = Element(('top', 'ns'))
el.addContent('im covered in bees')
el.toXml = Mock()
d = node.onOutput(el)
def cb(msg):
self.assertFalse(self.mockPSClient.publish.called)
self.assertEquals(el.toXml.call_count, 1)
d.addCallback(cb)
return d
def test_onError_toPublishErrored(self):
self.mockPSClient.publish = Mock(side_effect=utils.bad_side_effect(error.StanzaError('DISAPPOINTED')))
errors = ['errornode1', 'errornode2', 'log']
node = nodes.PSErrorNode(testJid, self.mockPSClient)
node.errorChannels = Mock(side_effect=utils.good_side_effect(errors))
el = Element(('top', 'ns'))
el.addContent('im covered in bees')
el.toXml = Mock()
d = node.onError(el)
def cb(msg):
self.assertEquals(self.mockPSClient.publish.call_count, 2)
self.assertEquals(el.toXml.call_count, 1)
d.addCallback(cb)
return self.assertFailure(d, error.StanzaError)
def _saslStep1(self, challenge):
c = str(challenge)
dc = binascii.a2b_base64(c)
ra = self._parse(dc)
self.realm = ra['realm']
self.nonce = ra['nonce']
self.nc = 0
self.charset = ra['charset']
self.algorithm = ra['algorithm']
#response = Element((SASL_XMLNS,"response"))
response = Element((None, "response"))
# why?
response['xmlns'] = SASL_XMLNS
r = self._response(self.charset, self.realm, self.nonce)
response.addContent(r)
self.xmlstream.removeObserver("/challenge", self._saslStep1)
self.xmlstream.addOnetimeObserver("/challenge", self._saslStep2)
self.xmlstream.send(response)
class Feed(Element):
def __init__(self, name, type, uri, tags=None):
Element.__init__(self, (None, 'feed'), attribs={'type': type})
self._feedName = Element((None, 'name'))
self._feedName.addContent(name)
self.addChild(self._feedName)
self._feedUri = Element((None, 'feedUri'))
self._feedUri.addContent(uri)
self.addChild(self._feedUri)
self._tags = []
if tags is not None:
for t in tags:
tag = Tag(t)
self.addChild(tag)
self._tags.append(tag)
def addTag(self, tag):
eTag = Tag(tag)
self._tags.append(eTag)
self.addChild(eTag)
class Feed(Element):
def __init__(self, name, type, uri, tags = None):
Element.__init__(self, (None, 'feed'), attribs={'type':type})
self._feedName = Element((None, 'name'))
self._feedName.addContent(name)
self.addChild(self._feedName)
self._feedUri = Element((None, 'feedUri'))
self._feedUri.addContent(uri)
self.addChild(self._feedUri)
self._tags = []
if tags is not None:
for t in tags:
tag = Tag(t)
self.addChild(tag)
self._tags.append(tag)
def addTag(self, tag):
eTag = Tag(tag)
self._tags.append(eTag)
self.addChild(eTag)
def start(self, data):
print 'start', data
tag = etree.QName(data.tag)
qname = ('',
tag.localname) if tag.namespace is None else (tag.namespace,
tag.localname)
#=======================================================================
# for k, v in attrs.items():
# if " " in k:
# aqname = k.rsplit(" ", 1)
# attrs[(aqname[0], aqname[1])] = v
# del attrs[k]
#=======================================================================
# Construct the new element
e = Element(qname, self.defaultNsStack[-1], data.attrib,
self.localPrefixes)
#Add content
if data.text:
e.addContent(data.text)
self.localPrefixes = {}
# Document already started
if self.documentStarted == 1:
if self.currElem != None:
self.currElem.children.append(e)
e.parent = self.currElem
self.currElem = e
# New document
else:
self.documentStarted = 1
self.DocumentStartEvent(e)
class Device(Element):
'''
classdocs
'''
def __init__(self, deviceName, rootUri, feeds = None, tags = None):
Element.__init__(self, (None, 'device'))
self._deviceName = Element((None, 'name'))
self._deviceName.addContent(deviceName)
self.addChild(self._deviceName)
self._rootUri = Element((None, 'rootUri'))
self._rootUri.addContent(rootUri)
self.addChild(self._rootUri)
self._feeds = []
if feeds is not None:
for f in feeds:
self._feeds.append(f)
self.addChild(f)
self._tags = []
if tags is not None:
for t in tags:
tag = Tag(t)
self.addChild(tag)
self._tags.append(tag)
def addFeed(self, feed):
self._feeds.append(feed)
self.addChild(feed)
def addTag(self, tag):
eTag = Tag(tag)
self._tags.append(eTag)
self.addChild(eTag)
def _featureParse(self, f):
self.bind = 0
self.session = 0
# TODO - check for tls
if self.success == 1:
for f in f.elements():
if f.name == "bind":
self.bind = 1
if f.name == "session":
self.session = 1
if self.bind:
iq = client.IQ(self.xmlstream, "set")
iq.addElement((BIND_XMLNS, "bind"))
iq.bind.addElement("resource", content=self.jid)
iq.addCallback(self._bindResultEvent)
iq.send()
else:
if f.starttls:
if SSL:
# look for required
#starttls = Element((TLS_XMLNS,"starttls"),TLS_XMLNS)
starttls = Element((None, "starttls"))
# why? --- should not be here!!!!!
starttls['xmlns'] = TLS_XMLNS
self.xmlstream.addOnetimeObserver("/proceed",
self._proceed)
self.xmlstream.addOnetimeObserver("/failue",
self._tlsError)
self.xmlstream.send(starttls)
else:
self.xmlstream.dispatch(f, self.AUTH_FAILED_EVENT)
else:
# Look for SASL
m = f.mechanisms
if m.uri == SASL_XMLNS:
ms = 'DIGEST-MD5'
for mech in m.elements():
ms = str(mech)
if ms == 'DIGEST-MD5':
break
if ms == 'PLAIN':
break
#auth = Element((SASL_XMLNS,"auth"),SASL_XMLNS,{'mechanism' : ms})
auth = Element((None, "auth"), attribs={'mechanism': ms})
# why?
auth['xmlns'] = SASL_XMLNS
# auth['mechanism'] = ms
if ms == 'DIGEST-MD5':
self.xmlstream.addOnetimeObserver(
"/challenge", self._saslStep1)
if ms == 'PLAIN':
# TODO add authzid
auth_str = ""
auth_str = auth_str + "\000"
auth_str = auth_str + self.username.encode('utf-8')
auth_str = auth_str + "\000"
auth_str = auth_str + self.password.encode('utf-8')
auth.addContent(binascii.b2a_base64(auth_str))
self.xmlstream.addOnetimeObserver(
"/success", self._saslSuccess)
self.xmlstream.addObserver("/failure", self._saslError)
self.xmlstream.send(auth)
else:
self.xmlstream.dispatch(f, self.AUTH_FAILED_EVENT)
class XPathTest(unittest.TestCase):
def setUp(self):
# Build element:
# <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
# somecontent
# <bar>
# <foo>
# <gar>DEF</gar>
# </foo>
# </bar>
# somemorecontent
# <bar attrib2="value2">
# <bar>
# <foo/>
# <gar>ABC</gar>
# </bar>
# <bar/>
# </foo>
self.e = Element(("testns", "foo"))
self.e["attrib1"] = "value1"
self.e["attrib3"] = "user@host/resource"
self.e.addContent("somecontent")
self.bar1 = self.e.addElement("bar")
self.subfoo = self.bar1.addElement("foo")
self.gar1 = self.subfoo.addElement("gar")
self.gar1.addContent("DEF")
self.e.addContent("somemorecontent")
self.bar2 = self.e.addElement("bar")
self.bar2["attrib2"] = "value2"
self.bar3 = self.bar2.addElement("bar")
self.subfoo2 = self.bar3.addElement("foo")
self.gar2 = self.bar3.addElement("gar")
self.gar2.addContent("ABC")
self.bar4 = self.e.addElement("bar")
def testStaticMethods(self):
self.assertEquals(xpath.matches("/foo/bar", self.e),
True)
self.assertEquals(xpath.queryForNodes("/foo/bar", self.e),
[self.bar1, self.bar2, self.bar4])
self.assertEquals(xpath.queryForString("/foo", self.e),
"somecontent")
self.assertEquals(xpath.queryForStringList("/foo", self.e),
["somecontent", "somemorecontent"])
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])
class XPathTest(unittest.TestCase):
def setUp(self):
# Build element:
# <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
# somecontent
# <bar>
# <foo>
# <gar>DEF</gar>
# </foo>
# </bar>
# somemorecontent
# <bar attrib2="value2">
# <bar>
# <foo/>
# <gar>ABC</gar>
# </bar>
# <bar/>
# </foo>
self.e = Element(("testns", "foo"))
self.e["attrib1"] = "value1"
self.e["attrib3"] = "user@host/resource"
self.e.addContent("somecontent")
self.bar1 = self.e.addElement("bar")
self.subfoo = self.bar1.addElement("foo")
self.gar1 = self.subfoo.addElement("gar")
self.gar1.addContent("DEF")
self.e.addContent("somemorecontent")
self.bar2 = self.e.addElement("bar")
self.bar2["attrib2"] = "value2"
self.bar3 = self.bar2.addElement("bar")
self.subfoo2 = self.bar3.addElement("foo")
self.gar2 = self.bar3.addElement("gar")
self.gar2.addContent("ABC")
self.bar4 = self.e.addElement("bar")
def testStaticMethods(self):
self.assertEquals(xpath.matches("/foo/bar", self.e), True)
self.assertEquals(xpath.queryForNodes("/foo/bar", self.e),
[self.bar1, self.bar2, self.bar4])
self.assertEquals(xpath.queryForString("/foo", self.e), "somecontent")
self.assertEquals(xpath.queryForStringList("/foo", self.e),
["somecontent", "somemorecontent"])
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])
class XPathTest(unittest.TestCase):
def setUp(self):
# Build element:
# <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
# somecontent
# <bar>
# <foo>
# <gar>DEF</gar>
# </foo>
# </bar>
# somemorecontent
# <bar attrib2="value2">
# <bar>
# <foo/>
# <gar>ABC</gar>
# </bar>
# <bar/>
# <bar attrib4='value4' attrib5='value5'>
# <foo/>
# <gar>JKL</gar>
# </bar>
# <bar attrib4='value4' attrib5='value4'>
# <foo/>
# <gar>MNO</gar>
# </bar>
# <bar attrib4='value4' attrib5='value6'/>
# </foo>
self.e = Element(("testns", "foo"))
self.e["attrib1"] = "value1"
self.e["attrib3"] = "user@host/resource"
self.e.addContent("somecontent")
self.bar1 = self.e.addElement("bar")
self.subfoo = self.bar1.addElement("foo")
self.gar1 = self.subfoo.addElement("gar")
self.gar1.addContent("DEF")
self.e.addContent("somemorecontent")
self.bar2 = self.e.addElement("bar")
self.bar2["attrib2"] = "value2"
self.bar3 = self.bar2.addElement("bar")
self.subfoo2 = self.bar3.addElement("foo")
self.gar2 = self.bar3.addElement("gar")
self.gar2.addContent("ABC")
self.bar4 = self.e.addElement("bar")
self.bar5 = self.e.addElement("bar")
self.bar5["attrib4"] = "value4"
self.bar5["attrib5"] = "value5"
self.subfoo3 = self.bar5.addElement("foo")
self.gar3 = self.bar5.addElement("gar")
self.gar3.addContent("JKL")
self.bar6 = self.e.addElement("bar")
self.bar6["attrib4"] = "value4"
self.bar6["attrib5"] = "value4"
self.subfoo4 = self.bar6.addElement("foo")
self.gar4 = self.bar6.addElement("gar")
self.gar4.addContent("MNO")
self.bar7 = self.e.addElement("bar")
self.bar7["attrib4"] = "value4"
self.bar7["attrib5"] = "value6"
def test_staticMethods(self):
"""
Test basic operation of the static methods.
"""
self.assertEqual(xpath.matches("/foo/bar", self.e),
True)
self.assertEqual(xpath.queryForNodes("/foo/bar", self.e),
[self.bar1, self.bar2, self.bar4,
self.bar5, self.bar6, self.bar7])
self.assertEqual(xpath.queryForString("/foo", self.e),
"somecontent")
self.assertEqual(xpath.queryForStringList("/foo", self.e),
["somecontent", "somemorecontent"])
def test_locationFooBar(self):
"""
Test matching foo with child bar.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.matches(self.e), 1)
def test_locationFooBarFoo(self):
"""
Test finding foos at the second level.
"""
xp = XPathQuery("/foo/bar/foo")
self.assertEqual(xp.matches(self.e), 1)
self.assertEqual(xp.queryForNodes(self.e), [self.subfoo,
self.subfoo3,
self.subfoo4])
def test_locationNoBar3(self):
"""
Test not finding bar3.
"""
xp = XPathQuery("/foo/bar3")
self.assertEqual(xp.matches(self.e), 0)
def test_locationAllChilds(self):
"""
Test finding childs of foo.
"""
xp = XPathQuery("/foo/*")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar1, self.bar2,
self.bar4, self.bar5,
self.bar6, self.bar7])
def test_attribute(self):
"""
Test matching foo with attribute.
"""
xp = XPathQuery("/foo[@attrib1]")
self.assertEqual(xp.matches(self.e), True)
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_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])
test_position.todo = "XPath queries with position are not working."
def test_namespaceFound(self):
"""
Test matching node with namespace.
"""
xp = XPathQuery("/foo[@xmlns='testns']/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_queryForString(self):
"""
Test for queryForString and queryForStringList.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForString(self.e), "somecontent")
self.assertEqual(xp.queryForStringList(self.e),
["somecontent", "somemorecontent"])
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_textCondition(self):
"""
Test matching a node with given text.
"""
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEqual(xp.matches(self.e), True)
def test_textNotOperator(self):
"""
Test for not operator.
"""
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEqual(xp.matches(self.e), True)
def test_anyLocationAndText(self):
"""
Test finding any nodes named gar and getting their text contents.
"""
xp = XPathQuery("//gar")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.gar1, self.gar2,
self.gar3, self.gar4])
self.assertEqual(xp.queryForStringList(self.e), ["DEF", "ABC",
"JKL", "MNO"])
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 test_anyLocationQueryForString(self):
"""
L{XPathQuery.queryForString} should raise a L{NotImplementedError}
for any location.
"""
xp = XPathQuery("//bar")
self.assertRaises(NotImplementedError, xp.queryForString, None)
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_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_booleanOperatorsNoParens(self):
"""
Test multiple boolean operators in condition without parens.
"""
xp = XPathQuery("""//bar[@attrib5='value4' or
@attrib5='value5' or
@attrib5='value6']""")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar5, self.bar6, self.bar7])
class XPathTests(unittest.TestCase):
def setUp(self):
# Build element:
# <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
# somecontent
# <bar>
# <foo>
# <gar>DEF</gar>
# </foo>
# </bar>
# somemorecontent
# <bar attrib2="value2">
# <bar>
# <foo/>
# <gar>ABC</gar>
# </bar>
# <bar/>
# <bar attrib4='value4' attrib5='value5'>
# <foo/>
# <gar>JKL</gar>
# </bar>
# <bar attrib4='value4' attrib5='value4'>
# <foo/>
# <gar>MNO</gar>
# </bar>
# <bar attrib4='value4' attrib5='value6' attrib6='á'>
# <quux>☃</quux>
# </bar>
# </foo>
self.e = Element(("testns", "foo"))
self.e["attrib1"] = "value1"
self.e["attrib3"] = "user@host/resource"
self.e.addContent(u"somecontent")
self.bar1 = self.e.addElement("bar")
self.subfoo = self.bar1.addElement("foo")
self.gar1 = self.subfoo.addElement("gar")
self.gar1.addContent(u"DEF")
self.e.addContent(u"somemorecontent")
self.bar2 = self.e.addElement("bar")
self.bar2["attrib2"] = "value2"
self.bar3 = self.bar2.addElement("bar")
self.subfoo2 = self.bar3.addElement("foo")
self.gar2 = self.bar3.addElement("gar")
self.gar2.addContent(u"ABC")
self.bar4 = self.e.addElement("bar")
self.bar5 = self.e.addElement("bar")
self.bar5["attrib4"] = "value4"
self.bar5["attrib5"] = "value5"
self.subfoo3 = self.bar5.addElement("foo")
self.gar3 = self.bar5.addElement("gar")
self.gar3.addContent(u"JKL")
self.bar6 = self.e.addElement("bar")
self.bar6["attrib4"] = "value4"
self.bar6["attrib5"] = "value4"
self.subfoo4 = self.bar6.addElement("foo")
self.gar4 = self.bar6.addElement("gar")
self.gar4.addContent(u"MNO")
self.bar7 = self.e.addElement("bar")
self.bar7["attrib4"] = "value4"
self.bar7["attrib5"] = "value6"
self.bar7["attrib6"] = u"á"
self.quux = self.bar7.addElement("quux")
self.quux.addContent(u"\N{SNOWMAN}")
def test_staticMethods(self):
"""
Test basic operation of the static methods.
"""
self.assertEqual(xpath.matches("/foo/bar", self.e), True)
self.assertEqual(
xpath.queryForNodes("/foo/bar", self.e),
[self.bar1, self.bar2, self.bar4, self.bar5, self.bar6, self.bar7])
self.assertEqual(xpath.queryForString("/foo", self.e), "somecontent")
self.assertEqual(xpath.queryForStringList("/foo", self.e),
["somecontent", "somemorecontent"])
def test_locationFooBar(self):
"""
Test matching foo with child bar.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.matches(self.e), 1)
def test_locationFooBarFoo(self):
"""
Test finding foos at the second level.
"""
xp = XPathQuery("/foo/bar/foo")
self.assertEqual(xp.matches(self.e), 1)
self.assertEqual(xp.queryForNodes(self.e),
[self.subfoo, self.subfoo3, self.subfoo4])
def test_locationNoBar3(self):
"""
Test not finding bar3.
"""
xp = XPathQuery("/foo/bar3")
self.assertEqual(xp.matches(self.e), 0)
def test_locationAllChilds(self):
"""
Test finding childs of foo.
"""
xp = XPathQuery("/foo/*")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(
xp.queryForNodes(self.e),
[self.bar1, self.bar2, self.bar4, self.bar5, self.bar6, self.bar7])
def test_attribute(self):
"""
Test matching foo with attribute.
"""
xp = XPathQuery("/foo[@attrib1]")
self.assertEqual(xp.matches(self.e), True)
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_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_namespaceFound(self):
"""
Test matching node with namespace.
"""
xp = XPathQuery("/foo[@xmlns='testns']/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_queryForString(self):
"""
queryforString on absolute paths returns their first CDATA.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForString(self.e), "somecontent")
def test_queryForStringList(self):
"""
queryforStringList on absolute paths returns all their CDATA.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForStringList(self.e),
["somecontent", "somemorecontent"])
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_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_textCondition(self):
"""
Test matching a node with given text.
"""
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEqual(xp.matches(self.e), True)
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_textNotOperator(self):
"""
Test for not operator.
"""
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEqual(xp.matches(self.e), True)
def test_anyLocationAndText(self):
"""
Test finding any nodes named gar and getting their text contents.
"""
xp = XPathQuery("//gar")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e),
[self.gar1, self.gar2, self.gar3, self.gar4])
self.assertEqual(xp.queryForStringList(self.e),
["DEF", "ABC", "JKL", "MNO"])
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 test_anyLocationQueryForString(self):
"""
L{XPathQuery.queryForString} should raise a L{NotImplementedError}
for any location.
"""
xp = XPathQuery("//bar")
self.assertRaises(NotImplementedError, xp.queryForString, None)
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_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_booleanOperatorsNoParens(self):
"""
Test multiple boolean operators in condition without parens.
"""
xp = XPathQuery("""//bar[@attrib5='value4' or
@attrib5='value5' or
@attrib5='value6']""")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e),
[self.bar5, self.bar6, self.bar7])
def test_badXPathNoClosingBracket(self):
"""
A missing closing bracket raises a SyntaxError.
This test excercises the most common failure mode.
"""
exc = self.assertRaises(SyntaxError, XPathQuery, """//bar[@attrib1""")
self.assertTrue(exc.msg.startswith("Trying to find one of"),
("SyntaxError message '%s' doesn't start with "
"'Trying to find one of'") % exc.msg)
class XPathTests(unittest.TestCase):
def setUp(self):
# Build element:
# <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
# somecontent
# <bar>
# <foo>
# <gar>DEF</gar>
# </foo>
# </bar>
# somemorecontent
# <bar attrib2="value2">
# <bar>
# <foo/>
# <gar>ABC</gar>
# </bar>
# <bar/>
# <bar attrib4='value4' attrib5='value5'>
# <foo/>
# <gar>JKL</gar>
# </bar>
# <bar attrib4='value4' attrib5='value4'>
# <foo/>
# <gar>MNO</gar>
# </bar>
# <bar attrib4='value4' attrib5='value6' attrib6='á'>
# <quux>☃</quux>
# </bar>
# </foo>
self.e = Element(("testns", "foo"))
self.e["attrib1"] = "value1"
self.e["attrib3"] = "user@host/resource"
self.e.addContent(u"somecontent")
self.bar1 = self.e.addElement("bar")
self.subfoo = self.bar1.addElement("foo")
self.gar1 = self.subfoo.addElement("gar")
self.gar1.addContent(u"DEF")
self.e.addContent(u"somemorecontent")
self.bar2 = self.e.addElement("bar")
self.bar2["attrib2"] = "value2"
self.bar3 = self.bar2.addElement("bar")
self.subfoo2 = self.bar3.addElement("foo")
self.gar2 = self.bar3.addElement("gar")
self.gar2.addContent(u"ABC")
self.bar4 = self.e.addElement("bar")
self.bar5 = self.e.addElement("bar")
self.bar5["attrib4"] = "value4"
self.bar5["attrib5"] = "value5"
self.subfoo3 = self.bar5.addElement("foo")
self.gar3 = self.bar5.addElement("gar")
self.gar3.addContent(u"JKL")
self.bar6 = self.e.addElement("bar")
self.bar6["attrib4"] = "value4"
self.bar6["attrib5"] = "value4"
self.subfoo4 = self.bar6.addElement("foo")
self.gar4 = self.bar6.addElement("gar")
self.gar4.addContent(u"MNO")
self.bar7 = self.e.addElement("bar")
self.bar7["attrib4"] = "value4"
self.bar7["attrib5"] = "value6"
self.bar7["attrib6"] = u"á"
self.quux = self.bar7.addElement("quux")
self.quux.addContent(u"\N{SNOWMAN}")
def test_staticMethods(self):
"""
Test basic operation of the static methods.
"""
self.assertEqual(xpath.matches("/foo/bar", self.e),
True)
self.assertEqual(xpath.queryForNodes("/foo/bar", self.e),
[self.bar1, self.bar2, self.bar4,
self.bar5, self.bar6, self.bar7])
self.assertEqual(xpath.queryForString("/foo", self.e),
"somecontent")
self.assertEqual(xpath.queryForStringList("/foo", self.e),
["somecontent", "somemorecontent"])
def test_locationFooBar(self):
"""
Test matching foo with child bar.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.matches(self.e), 1)
def test_locationFooBarFoo(self):
"""
Test finding foos at the second level.
"""
xp = XPathQuery("/foo/bar/foo")
self.assertEqual(xp.matches(self.e), 1)
self.assertEqual(xp.queryForNodes(self.e), [self.subfoo,
self.subfoo3,
self.subfoo4])
def test_locationNoBar3(self):
"""
Test not finding bar3.
"""
xp = XPathQuery("/foo/bar3")
self.assertEqual(xp.matches(self.e), 0)
def test_locationAllChilds(self):
"""
Test finding childs of foo.
"""
xp = XPathQuery("/foo/*")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar1, self.bar2,
self.bar4, self.bar5,
self.bar6, self.bar7])
def test_attribute(self):
"""
Test matching foo with attribute.
"""
xp = XPathQuery("/foo[@attrib1]")
self.assertEqual(xp.matches(self.e), True)
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_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_namespaceFound(self):
"""
Test matching node with namespace.
"""
xp = XPathQuery("/foo[@xmlns='testns']/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_queryForString(self):
"""
queryforString on absolute paths returns their first CDATA.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForString(self.e), "somecontent")
def test_queryForStringList(self):
"""
queryforStringList on absolute paths returns all their CDATA.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForStringList(self.e),
["somecontent", "somemorecontent"])
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_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_textCondition(self):
"""
Test matching a node with given text.
"""
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEqual(xp.matches(self.e), True)
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_textNotOperator(self):
"""
Test for not operator.
"""
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEqual(xp.matches(self.e), True)
def test_anyLocationAndText(self):
"""
Test finding any nodes named gar and getting their text contents.
"""
xp = XPathQuery("//gar")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.gar1, self.gar2,
self.gar3, self.gar4])
self.assertEqual(xp.queryForStringList(self.e), ["DEF", "ABC",
"JKL", "MNO"])
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 test_anyLocationQueryForString(self):
"""
L{XPathQuery.queryForString} should raise a L{NotImplementedError}
for any location.
"""
xp = XPathQuery("//bar")
self.assertRaises(NotImplementedError, xp.queryForString, None)
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_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_booleanOperatorsNoParens(self):
"""
Test multiple boolean operators in condition without parens.
"""
xp = XPathQuery("""//bar[@attrib5='value4' or
@attrib5='value5' or
@attrib5='value6']""")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e), [self.bar5, self.bar6, self.bar7])
def test_badXPathNoClosingBracket(self):
"""
A missing closing bracket raises a SyntaxError.
This test excercises the most common failure mode.
"""
exc = self.assertRaises(SyntaxError, XPathQuery, """//bar[@attrib1""")
self.assertTrue(exc.msg.startswith("Trying to find one of"),
("SyntaxError message '%s' doesn't start with "
"'Trying to find one of'") % exc.msg)
class XPathTest(unittest.TestCase):
def setUp(self):
# Build element:
# <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
# somecontent
# <bar>
# <foo>
# <gar>DEF</gar>
# </foo>
# </bar>
# somemorecontent
# <bar attrib2="value2">
# <bar>
# <foo/>
# <gar>ABC</gar>
# </bar>
# <bar/>
# <bar attrib4='value4' attrib5='value5'>
# <foo/>
# <gar>JKL</gar>
# </bar>
# <bar attrib4='value4' attrib5='value4'>
# <foo/>
# <gar>MNO</gar>
# </bar>
# <bar attrib4='value4' attrib5='value6'/>
# </foo>
self.e = Element(("testns", "foo"))
self.e["attrib1"] = "value1"
self.e["attrib3"] = "user@host/resource"
self.e.addContent("somecontent")
self.bar1 = self.e.addElement("bar")
self.subfoo = self.bar1.addElement("foo")
self.gar1 = self.subfoo.addElement("gar")
self.gar1.addContent("DEF")
self.e.addContent("somemorecontent")
self.bar2 = self.e.addElement("bar")
self.bar2["attrib2"] = "value2"
self.bar3 = self.bar2.addElement("bar")
self.subfoo2 = self.bar3.addElement("foo")
self.gar2 = self.bar3.addElement("gar")
self.gar2.addContent("ABC")
self.bar4 = self.e.addElement("bar")
self.bar5 = self.e.addElement("bar")
self.bar5["attrib4"] = "value4"
self.bar5["attrib5"] = "value5"
self.subfoo3 = self.bar5.addElement("foo")
self.gar3 = self.bar5.addElement("gar")
self.gar3.addContent("JKL")
self.bar6 = self.e.addElement("bar")
self.bar6["attrib4"] = "value4"
self.bar6["attrib5"] = "value4"
self.subfoo4 = self.bar6.addElement("foo")
self.gar4 = self.bar6.addElement("gar")
self.gar4.addContent("MNO")
self.bar7 = self.e.addElement("bar")
self.bar7["attrib4"] = "value4"
self.bar7["attrib5"] = "value6"
def test_staticMethods(self):
"""
Test basic operation of the static methods.
"""
self.assertEqual(xpath.matches("/foo/bar", self.e), True)
self.assertEqual(
xpath.queryForNodes("/foo/bar", self.e),
[self.bar1, self.bar2, self.bar4, self.bar5, self.bar6, self.bar7])
self.assertEqual(xpath.queryForString("/foo", self.e), "somecontent")
self.assertEqual(xpath.queryForStringList("/foo", self.e),
["somecontent", "somemorecontent"])
def test_locationFooBar(self):
"""
Test matching foo with child bar.
"""
xp = XPathQuery("/foo/bar")
self.assertEqual(xp.matches(self.e), 1)
def test_locationFooBarFoo(self):
"""
Test finding foos at the second level.
"""
xp = XPathQuery("/foo/bar/foo")
self.assertEqual(xp.matches(self.e), 1)
self.assertEqual(xp.queryForNodes(self.e),
[self.subfoo, self.subfoo3, self.subfoo4])
def test_locationNoBar3(self):
"""
Test not finding bar3.
"""
xp = XPathQuery("/foo/bar3")
self.assertEqual(xp.matches(self.e), 0)
def test_locationAllChilds(self):
"""
Test finding childs of foo.
"""
xp = XPathQuery("/foo/*")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(
xp.queryForNodes(self.e),
[self.bar1, self.bar2, self.bar4, self.bar5, self.bar6, self.bar7])
def test_attribute(self):
"""
Test matching foo with attribute.
"""
xp = XPathQuery("/foo[@attrib1]")
self.assertEqual(xp.matches(self.e), True)
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_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])
test_position.todo = "XPath queries with position are not working."
def test_namespaceFound(self):
"""
Test matching node with namespace.
"""
xp = XPathQuery("/foo[@xmlns='testns']/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_queryForString(self):
"""
Test for queryForString and queryForStringList.
"""
xp = XPathQuery("/foo")
self.assertEqual(xp.queryForString(self.e), "somecontent")
self.assertEqual(xp.queryForStringList(self.e),
["somecontent", "somemorecontent"])
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_textCondition(self):
"""
Test matching a node with given text.
"""
xp = XPathQuery("/foo[text() = 'somecontent']")
self.assertEqual(xp.matches(self.e), True)
def test_textNotOperator(self):
"""
Test for not operator.
"""
xp = XPathQuery("/foo[not(@nosuchattrib)]")
self.assertEqual(xp.matches(self.e), True)
def test_anyLocationAndText(self):
"""
Test finding any nodes named gar and getting their text contents.
"""
xp = XPathQuery("//gar")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e),
[self.gar1, self.gar2, self.gar3, self.gar4])
self.assertEqual(xp.queryForStringList(self.e),
["DEF", "ABC", "JKL", "MNO"])
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 test_anyLocationQueryForString(self):
"""
L{XPathQuery.queryForString} should raise a L{NotImplementedError}
for any location.
"""
xp = XPathQuery("//bar")
self.assertRaises(NotImplementedError, xp.queryForString, None)
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_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_booleanOperatorsNoParens(self):
"""
Test multiple boolean operators in condition without parens.
"""
xp = XPathQuery("""//bar[@attrib5='value4' or
@attrib5='value5' or
@attrib5='value6']""")
self.assertEqual(xp.matches(self.e), True)
self.assertEqual(xp.queryForNodes(self.e),
[self.bar5, self.bar6, self.bar7])
def toElement(self):
el = Element((None, 'note'))
el['type'] = self.note_type
el.addContent(self.content)
return el
