"""Tests for SOX"""
from unittest import TestCase, makeSuite, TestSuite
from cStringIO import StringIO
from xml.sax import InputSource
from peak.util import SOX
def stream(str):
inpsrc = InputSource()
inpsrc.setByteStream(StringIO(str))
return inpsrc
class SOXTest(TestCase):
text = ""
useNS = False
def setUp(self):
self.object = ob = SOX.load(stream(self.text), namespaces=self.useNS)
self.de = ob.documentElement
class Simple(SOXTest):
text = """TEXT"""
def testTop(self):
assert self.de._name == 'top'
def testNodelist(self):
object = self.object
top = object._get('top')
assert len(top)==1
assert object.top is top
def testText(self):
t = []
for n in self.de._allNodes:
if n == str(n): t.append(n)
assert ''.join(t) == 'TEXT'
def testAttrs(self):
assert self.de.foo=='bar'
assert self.de.baz=='spam'
class NSTest(SOXTest):
text = """
[0]
[1]
[2]
"""
useNS = True
def testModel(self):
node = self.de._subNodes[1]
assert node.ns2uri['Model']=='http://omg.org/MOF/1.3'
node = self.de._subNodes[2]
assert 'Model' not in node.ns2uri
assert node.ns2uri[''] == "www.zope.org"
class NegotiationTests(TestCase):
def setUp(self):
self.n = SOX.NegotiatingParser()
self.attrs = []
self.log = []
self.n.element_map['nothing'] = self.nothing
def nothing(self,neg,data):
self.failUnless(neg is self.n)
self.assertEqual(data['name'], 'nothing')
self.assertEqual(data['attributes'], self.attrs)
data['finish']=lambda *args: 99
self.log.append(True) # we ran
def lookup_element(self,ns,name):
self.log.append(name)
def check_log(self,data):
self.assertEqual(self.log,data)
def testElementMatching(self):
self.n.setLookups(self.lookup_element)
self.n.element_map['nothing'] = self.nothing
self.n.startElement("nothing",[])
self.check_log([True])
self.log=[]
self.attrs = [('foo','bar')]
self.n.startElement('abc',[])
self.n.startElement('nothing',['foo','bar'])
self.assertEqual(self.log, ['abc',True])
self.log=[]
self.attrs = []
self.n.startElement('nothing',[])
self.n.startElement('nothing',[])
self.check_log([True,True])
def testElementLookup(self):
self.n.startElement('xyz',[])
self.check_log([])
self.n.setLookups(self.lookup_element)
self.assertEqual(self.n.element_map,{}) # Cache should be cleared
self.n.startElement('xyz',[])
self.check_log(['xyz'])
def testCachePerNamespace(self):
e1 = self.n.element_map
a1 = self.n.attribute_map
self.n.startElement('nothing',['xmlns','foobly'])
# Verify that declaring XMLNS clears element cache *before* negotiation
self.check_log([])
e2 = self.n.element_map
a2 = self.n.attribute_map
self.failIf(e1 is e2 or a1 is a2)
self.n.startElement('bar',['xmlns:foo','spam'])
e3 = self.n.element_map
a3 = self.n.attribute_map
self.failIf(e2 is e3 or a2 is a3)
self.failIf(e1 is e3 or a1 is a3)
# Cache should stay the same if no new namespaces declared
self.n.startElement('baz',[])
self.failUnless(self.n.element_map is e3)
self.failUnless(self.n.attribute_map is a3)
self.n.endElement('baz')
self.n.endElement('bar')
self.failUnless(self.n.element_map is e2)
self.failUnless(self.n.attribute_map is a2)
self.n.endElement('nothing')
self.failUnless(self.n.element_map is e1)
self.failUnless(self.n.attribute_map is a1)
def testSingleXMLNamespace(self):
self.assertEqual(self.n.ns_info, {})
self.n.startElement('foo',['xmlns','foobly'])
self.assertEqual(self.n.ns_info, {'':['foobly']})
self.n.startElement('foo',['xmlns','barbaz'])
self.assertEqual(self.n.ns_info, {'':['foobly','barbaz']})
self.n.startElement('bar',['xmlns:baz','spam'])
self.assertEqual(
self.n.ns_info, {'':['foobly','barbaz'], 'baz':['spam']}
)
self.n.endElement('bar')
self.assertEqual(self.n.ns_info, {'':['foobly','barbaz'],'baz':[]})
self.n.endElement('foo')
self.assertEqual(self.n.ns_info, {'':['foobly'],'baz':[]})
def testMultipleNS(self):
self.n.startElement('foo',['xmlns:a','foobly', 'xmlns:b','do'])
self.assertEqual(self.n.ns_info, {'a':['foobly'],'b':['do']})
self.n.endElement('foo')
self.assertEqual(self.n.ns_info, {'a':[],'b':[]})
self.n.startElement('whee',[])
self.n.endElement('whee')
self.assertEqual(self.n.ns_info, {'a':[],'b':[]})
def testSaveLookups(self):
el1 = self.n.lookup_element; ec1 = self.n.element_map
al1 = self.n.lookup_attribute; ac1 = self.n.attribute_map
self.n.startElement('xyz',[])
self.n.setLookups(self.lookup_element,self.lookup_element)
el2 = self.n.lookup_element; ec2 = self.n.element_map
al2 = self.n.lookup_attribute; ac2 = self.n.attribute_map
self.failIf(el1 is el2 or al1 is al2 or ec1 is ec2 or ac1 is ac2)
self.n.endElement('xyz')
el3 = self.n.lookup_element; ec3 = self.n.element_map
al3 = self.n.lookup_attribute; ac3 = self.n.attribute_map
self.failUnless(el1 is el3 and al1 is al3)
self.failUnless(ec1 is ec3 and ac1 is ac3)
def testLifecycle(self):
def do_start(neg,data):
self.failUnless(neg is self.n)
self.log.append("started") # we ran
def do_finish(neg,data):
self.failUnless(neg is self.n)
self.log.append("finished") # we ran
return 7
def do_child(child):
self.log.append(("child",child)) # we ran
def tag_one(neg,data):
self.failUnless(neg is self.n)
self.assertEqual(data['name'],'tag1')
data['start'] = do_start
data['finish'] = do_finish
data['child'] = do_child
self.n.element_map['tag1'] = tag_one
self.n.startElement('tag1',[])
self.check_log(['started'])
self.n.startElement('foo',['a','b','c','d'])
self.n.endElement('foo')
self.check_log(['started'])
self.n.endElement('tag1')
self.check_log(['started','finished'])
self.log = []
self.n.startElement('tag1',[])
self.n.startElement('tag1',[])
self.n.endElement('tag1')
self.n.endElement('tag1')
self.check_log(['started','started','finished',('child',7),'finished'])
def testAttributeLookup(self):
self.n.startElement("xyz",['a:b','c', 'd', 'e'])
self.check_log([])
# Setting lookup should clear caches
self.n.setLookups(attribute=self.lookup_element)
self.assertEqual(self.n.element_map,{})
self.assertEqual(self.n.attribute_map,{})
self.n.startElement("xyz",['a:b','c', 'd', 'e'])
self.check_log(['a:b'])
self.n.startElement("xyz",['a:b','x', 'c:d', 'e'])
self.check_log(['a:b','c:d'])
def got_ef(neg,data,attr,val):
self.assertEqual(attr,'e:f')
self.assertEqual(val,'g')
self.log.append('got it!')
self.failUnless( ('e:f','g') in data['attributes'])
self.n.attribute_map['e:f'] = got_ef
self.attrs = [('e:f','g')]
self.n.startElement("nothing",['e:f','g'])
self.check_log(['a:b','c:d', 'got it!'])
# Verify that declaring XMLNS clears attrib cache *before* negotiation
self.log=[]
self.n.startElement("xyz",["xmlns:foo","bar", 'e:f','g'])
self.check_log(['e:f'])
def testText(self):
def tag_one(neg,data):
self.failUnless(neg is self.n)
self.assertEqual(data['name'],'tag1')
data['text'] = do_text
data['literal'] = do_literal
def do_text(text):
self.log.append(('txt',text))
def do_literal(text):
self.log.append(('lit',text))
self.n.element_map['tag1'] = tag_one
self.n.text("foo")
self.n.literal("bar")
self.n.comment("ping")
self.check_log([])
self.n.startElement('tag1',[])
self.n.text("baz")
self.n.literal("spam")
self.n.comment("whiz")
self.check_log([('txt','baz'),('lit','spam'),('lit','')])
self.log = []
self.n.endElement('tag1')
self.n.text("baz")
self.n.literal("spam")
self.n.comment("ni!")
self.check_log([])
def parse(self,data,root,stream=False):
if stream:
return self.n.parseStream(StringIO(data),root)
return self.n.parseString(data,root)
def testParses(self):
for mode in True,False:
self.setUp() # ensure clean slate between parses
result = self.parse('', {'finish':lambda *args:27}, mode)
self.assertEqual(result,27)
self.check_log([True])
self.parse(
'',
{'literal':self.log.append, 'child':self.log.append},
mode
)
self.check_log([True,'',True,99])
#def testNSLookups(self):
# TODO
#def testNSAdd(self):
# TODO
TestClasses = (
Simple, NSTest, NegotiationTests
)
def test_suite():
s = []
for t in TestClasses:
s.append(makeSuite(t,'test'))
return TestSuite(s)