• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

contrib/opal/ZSI/test/test_t1.py

00001 #!/usr/bin/env python
00002 import unittest, sys, tests_good, tests_bad, time
00003 from ZSI import *
00004 try:
00005     import cStringIO as StringIO
00006 except ImportError:
00007     import StringIO
00008 
00009 class t1TestCase(unittest.TestCase):
00010     "Test case wrapper for old ZSI t1 test case"
00011 
00012     def setUp(self):
00013         self.goodTests = []
00014         self.badTests = []
00015         for key,val in tests_good.__dict__.items():
00016             try:
00017                 if key[0:4] == "test" and int(key[4:]) > 0:
00018                     self.goodTests.append((key,val))
00019             except:
00020                 pass
00021         for key,val in tests_bad.__dict__.items():
00022             try:
00023                 if key[0:4] == "test" and int(key[4:]) > 0:
00024                     self.badTests.append((key,val))                    
00025             except:
00026                 pass
00027         self.goodTests.sort(lambda a,b: cmp(a[0], b[0]))
00028         self.badTests.sort(lambda a,b: cmp(a[0], b[0]))
00029 
00030     def check_bug1724481(self):
00031         # [ 1724481 ] Error handling of enum serialization broken"
00032         enum = TC.Enumeration(['Red', 'Blue', 'Green'], 'color')
00033         sw = SoapWriter()
00034         self.assertRaises(EvaluateException, sw.serialize,'ddd', enum)
00035 
00036     def checkt1(self):
00037         for key,val in self.badTests:
00038             print "\n", "." * 60, key
00039             self.failUnlessRaises(ParseException, ParsedSoap, val)
00040         for key,val in self.goodTests:
00041             print "\n", "." * 60, key
00042             ps = ParsedSoap(val)
00043 
00044         ps = ParsedSoap(datatest)
00045         elts = ps.data_elements
00046 
00047         self.failUnlessEqual(TC.Integer(None, nillable=True).parse(elts[10], ps),
00048                                                                         None)
00049         self.failUnlessEqual(TC.Ibyte(None, nillable=True).parse(elts[10], ps),
00050                                                                         None)
00051         B = [ TC.Integer('Price'), TC.Integer('p2'), TC.String(unique=1) ]
00052         self.failUnlessEqual(TC.Integer(('test-uri', 'Price')).parse(elts[0], ps), 
00053                                                         34)
00054         self.failUnlessEqual(B[0].parse(elts[0], ps), 34)
00055         self.failUnlessEqual(B[1].parse(elts[1], ps), 44)
00056         self.failUnlessEqual(B[2].parse(elts[2], ps), u"This is the name")
00057         self.failUnlessEqual(TC.HexBinaryString().parse(elts[9], ps), "? A")
00058         self.failUnlessEqual(TC.String('Name').parse(elts[2], ps), 
00059                                                     u"This is the name")
00060         self.failUnlessEqual(TC.Any('Price').parse(elts[0], ps), 34)
00061         self.failUnlessEqual(TC.Any('n3').parse(elts[4], ps), 
00062                                                     u"The value of n3")
00063         TC.XML('n2').parse(elts[3], ps)
00064         nodelist = TC.XML('a2').parse(elts[7], ps)
00065         self.failUnlessEqual(TC.String('n3').parse(elts[4], ps), 
00066                                                     u"The value of n3")
00067         self.failUnlessEqual(TC.Base64String('n64').parse(elts[5], ps),
00068                                                     u"hello")
00069         self.failUnlessEqual(TC.String('n64').parse(elts[5], ps),
00070                                                     u"a GVsbG8=")
00071         enum = TC.Enumeration(['Red', 'Blue', 'Green'], 'color')
00072         self.failUnlessEqual(enum.parse(elts[6], ps), u'Red')
00073         self.failUnlessEqual(TC.IEnumeration([44,46,47]).parse(elts[1],ps),
00074                                                         44)
00075         S = TC.Struct(None, [TC.String('t'), TC.Integer('i')], inorder=0)
00076         pyobj = S.parse(elts[8], ps)
00077         S2 = TC.Struct(myclass, [TC.IunsignedShort('i'), TC.String('q:z',
00078         minOccurs=0), TC.String('t')], 'a2', typed=0)
00079         pyobj2 = S2.parse(elts[8], ps)
00080         self.failUnlessEqual(TC.URI().parse(elts[12], ps), 
00081                                             u'"http://foo.com/~salz"')
00082         self.failUnlessEqual(pyobj["i"], pyobj2.i)
00083         self.failUnlessEqual(pyobj["t"], pyobj2.t)
00084 
00085         tcary = TC.Array('SOAP-ENC:int', TC.Integer())
00086         nsa = tcary.parse(elts[14],ps)
00087         self.failUnlessEqual(nsa, [None, None, None, 12, 13, 14, 15, 16, 17])
00088         tcary.sparse = 1
00089         sa = tcary.parse(elts[14],ps)
00090         self.failUnlessEqual(sa, 
00091                     [(3, 12), (4, 13), (5, 14), (6, 15), (7, 16), (8, 17)])
00092 
00093         """
00094         mychoice = TC.Choice([
00095             TC.String('n3'),
00096             TC.URI('uri'),
00097             TC.Integer('Price'),
00098         ])
00099 
00100         b = mychoice.parse(elts[0], ps)
00101         self.failUnlessEqual(b[0], 'Price')
00102         self.failUnlessEqual(b[1], 34)
00103         b = mychoice.parse(elts[12], ps)
00104         self.failUnlessEqual(b[0], 'uri')
00105         self.failUnlessEqual(b[1], u'"http://foo.com/~salz"')
00106         b = mychoice.parse(elts[4], ps)
00107         self.failUnlessEqual(b[0], 'n3')
00108         self.failUnlessEqual(b[1], u'The value of n3')
00109         """
00110 
00111         self.failUnlessEqual(TC.Array(('test-uri','x'), TC.Any()).parse(elts[15], ps),
00112                                             [u'The value of n3', u'rich salz', 13])
00113         self.failUnlessEqual(TC.Struct(None,(TC.FPfloat('a'), TC.Decimal('b'),
00114                                             TC.FPdouble('c'))).parse(elts[13],ps),
00115                                             {'a': 6.9000000000000004, 'c':
00116                                                 TC._make_inf(), 'b': 0.0})
00117         nsdict = ps.GetElementNSdict(ps.header)
00118         nsdict[''] = "http://www.zolera.com/ns/"
00119         nsdict['q'] = 'q-namespace-uri' 
00120         sio = StringIO.StringIO()
00121         z = SoapWriter(sio, header=ps.header_elements, nsdict=nsdict) 
00122         z.serialize(pyobj2, S2) 
00123         S2.inline = 1 
00124         S2.typed = 0 
00125         tc = TC.gDateTime('dt') 
00126         z.serialize(pyobj2, S2) 
00127         z.serialize(pyobj, S) 
00128         #z.serialize(('n3', '******this is the value of a union'), mychoice) 
00129         z.serialize('uri:some/place/special', TC.XML('foo', nsdict=nsdict)) 
00130         tcary.sparse = False
00131         z.serialize(nsa, tcary, childnames='tt') 
00132         tcary.sparse = True
00133         z.serialize(sa, tcary, name='MYSPARSEARRAY') 
00134         z.serialize(time.time(), tc) 
00135         z.serialize(time.time(), TC.gTime('monthday')) 
00136         z.serialize('$$$$$foo<', TC.String(textprotect=0)) 
00137         self.failUnlessEqual(TC.Any().parse(elts[11], ps),
00138                                         {'urt-i': 12, 'urt-t': u'rich salz'})
00139 
00140         try: 
00141             a = bar() 
00142         except Exception, e: 
00143             f = FaultFromException(e, 0, sys.exc_info()[2]) 
00144             print f.AsSOAP() 
00145         print
00146         print
00147         print FaultFromNotUnderstood('myuri', 'dalocalname', actor='cher').AsSOAP() 
00148         print
00149         print
00150         print FaultFromActor('actor:i:dont:understand').AsSOAP()
00151 
00152 
00153 def makeTestSuite():
00154     suite = unittest.TestSuite()
00155     suite.addTest(unittest.makeSuite(t1TestCase, "check"))
00156     return suite
00157 
00158 ##  exceptions
00159 def foo():
00160     '''dummy'''
00161     return 3 / 0
00162 
00163 def bar():
00164     return foo() + 2
00165 
00166 class zParseException: pass
00167 
00168 class myclass:
00169     def __init__(self, name=None):
00170         self.name = name or id(self)
00171         self.z = 'z value'
00172     def __str__(self):
00173         return 'myclass-%s-(%d,"%s")' % (self.name, self.i, self.t) + \
00174                                                         str(self.z)
00175 
00176 datatest = '''<SOAP-ENV:Envelope
00177   xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
00178   xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
00179   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
00180   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
00181   SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
00182   <SOAP-ENV:Header xmlns:t="http://www.zolera.com/ns/" xmlns:q='"'>
00183   <t:sometag SOAP-ENV:mustUnderstand="1">you must grok sometag</t:sometag>
00184   </SOAP-ENV:Header>
00185     <SOAP-ENV:Body xmlns='test-uri'>
00186         <root SOAP-ENC:root='1'/>
00187         <Price xsi:type='xsd:integer'>34</Price> <!-- 0 -->
00188         <SOAP-ENC:byte>44</SOAP-ENC:byte> <!-- 1 -->
00189         <Name>This is the name</Name>   <!-- 2 -->
00190         <n2><xmldoc><![CDATA[<greeting>Hello</greeting>]]></xmldoc></n2> <!-- 3 -->
00191         <n3 href='#zzz' xsi:type='SOAP-ENC:string'/> <!-- 4 -->
00192         <n64>a GVsbG8=</n64> <!-- 5 -->
00193         <SOAP-ENC:string>Red</SOAP-ENC:string> <!-- 6 -->
00194         <a2 href='#tri2'/> <!-- 7 --> 
00195         <a2><i>12</i><t>rich salz</t></a2> <!-- 8 --> 
00196         <xsd:hexBinary>3F2041</xsd:hexBinary> <!-- 9 --> 
00197         <nullint xsi:nil='1'/> <!-- 10 --> 
00198         <Anytest><urt-i xsi:type='SOAP-ENC:byte'>12</urt-i> 
00199         <urt-t id="urtid" 
00200             xsi:type="xsd:string">rich salz</urt-t></Anytest> <!-- 11 --> 
00201         <uri>"http://foo.com/%7Esalz"</uri> <!-- 12 --> 
00202         <floattest> <!-- 13 --> 
00203             <a>6.9</a> <b>-0</b> <c>INF</c> 
00204         </floattest> 
00205         <atest SOAP-ENC:offset='[3]' SOAP-ENC:arrayType="x"> <!-- 14 --> 
00206             <i>12</i> 
00207             <SOAP-ENC:integer id='n13'>13</SOAP-ENC:integer> 
00208             <i>14</i> 
00209             <i>15</i> 
00210             <i>16</i> 
00211             <i>17</i> 
00212         </atest> 
00213         <sarray SOAP-ENC:arrayType="struct"> <!-- 15 --> 
00214             <i href="#zzz" xsi:type='xsd:string'/> 
00215             <i href="#urtid"/> 
00216             <thing href="#n13"/> 
00217         </sarray> 
00218         <xpath>//sarray</xpath> <!-- 16 --> 
00219         <z xmlns='myns' xsi:type='SOAP-ENC:string' id='zzz'>The value of n3</z> 
00220         <zz xmlns='myns2' id='tri2'>
00221             <inner xmlns='myns2' >
00222                 <f1>content</f1>
00223                 <sec xmlns='myns2' >ond</sec >
00224             </inner>
00225         </zz> 
00226     </SOAP-ENV:Body> 
00227 </SOAP-ENV:Envelope>'''
00228 
00229 def main():
00230     unittest.main(defaultTest="makeTestSuite")
00231 
00232 
00233 if __name__ == "__main__" : main()
00234 
00235 

Generated on Wed Oct 20 2010 11:12:16 for APBS by  doxygen 1.7.2