source: TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_attributeauthorityclient.py @ 6052

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_attributeauthorityclient.py@6052
Revision 6052, 23.1 KB checked in by pjkersha, 11 years ago (diff)

Updated MyProxy? Cert extension app for use with improved SAML Attribute Query interface class AttributeQuerySslSOAPBinding

  • Property svn:executable set to *
  • Property svn:keywords set to Id
Line 
1#!/usr/bin/env python
2"""NDG Attribute Authority SOAP client unit tests
3
4NERC DataGrid Project
5"""
6__author__ = "P J Kershaw"
7__date__ = "05/05/05, major update 16/01/07"
8__copyright__ = "(C) 2009 Science and Technology Facilities Council"
9__license__ = "BSD - see LICENSE file in top-level directory"
10__contact__ = "Philip.Kershaw@stfc.ac.uk"
11__revision__ = '$Id:test_attributeauthorityclient.py 4372 2008-10-29 09:45:39Z pjkersha $'
12import logging
13logging.basicConfig(level=logging.DEBUG)
14
15import unittest
16import os, re
17   
18from os.path import expandvars as xpdVars
19from os.path import join as jnPath
20mkPath = lambda file: jnPath(os.environ['NDGSEC_AACLNT_UNITTEST_DIR'], file)
21
22from datetime import datetime
23from uuid import uuid4
24from xml.etree import ElementTree
25
26from ndg.security.test.unit import BaseTestCase, mkDataDirPath
27
28from ndg.security.common.utils.etree import prettyPrint
29
30from ndg.security.common.attributeauthority import (AttributeAuthorityClient, 
31                                                NoMatchingRoleInTrustedHosts)
32from ndg.security.common.AttCert import AttCertRead
33from ndg.security.common.X509 import X509CertParse, X509CertRead
34from ndg.security.common.utils.configfileparsers import (
35    CaseSensitiveConfigParser)
36
37from saml.common.xml import SAMLConstants
38from saml.saml2.core import (Attribute, SAMLVersion, Subject, NameID, Issuer, 
39                             AttributeQuery, XSStringAttributeValue, StatusCode)
40from saml.xml.etree import ResponseElementTree
41
42from ndg.security.common.saml_utils.bindings import SOAPBinding as \
43                                                            SamlSoapBinding
44from ndg.security.common.saml_utils.bindings import AttributeQuerySOAPBinding
45from ndg.security.common.saml_utils.bindings import AttributeQuerySslSOAPBinding
46from ndg.security.common.saml_utils.esg import (EsgSamlNamespaces, 
47                                                XSGroupRoleAttributeValue,
48                                                EsgDefaultQueryAttributes)
49
50
51class AttributeAuthorityClientBaseTestCase(BaseTestCase):
52    def __init__(self, *arg, **kw):
53        super(AttributeAuthorityClientBaseTestCase, self).__init__(*arg, **kw)
54
55        if 'NDGSEC_AACLNT_UNITTEST_DIR' not in os.environ:
56            os.environ['NDGSEC_AACLNT_UNITTEST_DIR'
57                       ] = os.path.abspath(os.path.dirname(__file__))
58
59        self.cfgParser = CaseSensitiveConfigParser()
60        self.cfgFilePath = jnPath(os.environ['NDGSEC_AACLNT_UNITTEST_DIR'],
61                                  'attAuthorityClientTest.cfg')
62        self.cfgParser.read(self.cfgFilePath)
63       
64        self.cfg = {}
65        for section in self.cfgParser.sections():
66            self.cfg[section] = dict(self.cfgParser.items(section))
67
68        try:
69            self.sslCACertList = [X509CertRead(xpdVars(caFile)) 
70                                  for caFile in self.cfg['setUp'][
71                                            'sslcaCertFilePathList'].split()]
72        except KeyError:
73            self.sslCACertList = []
74           
75        self.startAttributeAuthorities()       
76     
77     
78class AttributeAuthorityClientTestCase(AttributeAuthorityClientBaseTestCase):
79    clntPriKeyPwd = None
80    pemPat = "-----BEGIN CERTIFICATE-----[^\-]*-----END CERTIFICATE-----"
81
82    def _getCertChainFromProxyCertFile(self, proxyCertFilePath):
83        '''Read proxy cert and user cert from a single PEM file and put in
84        a list ready for input into SignatureHandler'''               
85        proxyCertFileTxt = open(proxyCertFilePath).read()
86       
87        pemPatRE = re.compile(self.__class__.pemPat, re.S)
88        x509CertList = pemPatRE.findall(proxyCertFileTxt)
89       
90        signingCertChain = [X509CertParse(x509Cert) 
91                            for x509Cert in x509CertList]
92   
93        # Expecting proxy cert first - move this to the end.  This will
94        # be the cert used to verify the message signature
95        signingCertChain.reverse()
96       
97        return signingCertChain
98
99    def setUp(self):
100        super(AttributeAuthorityClientTestCase, self).setUp()
101               
102        if 'NDGSEC_INT_DEBUG' in os.environ:
103            import pdb
104            pdb.set_trace()
105           
106        thisSection = self.cfg['setUp']
107       
108        # Instantiate WS proxy
109        self.siteAClnt = AttributeAuthorityClient(uri=thisSection['uri'],
110                                sslPeerCertCN=thisSection.get('sslPeerCertCN'),
111                                sslCACertList=self.sslCACertList,
112                                cfgFileSection='wsse',
113                                cfg=self.cfgParser)           
114
115    def test01GetHostInfo(self):
116        """test01GetHostInfo: retrieve info for AA host"""
117        hostInfo = self.siteAClnt.getHostInfo()
118        print "Host Info:\n %s" % hostInfo       
119
120    def test02GetTrustedHostInfo(self):
121        """test02GetTrustedHostInfo: retrieve trusted host info matching a
122        given role"""
123        trustedHostInfo = self.siteAClnt.getTrustedHostInfo(
124                                 self.cfg['test02GetTrustedHostInfo']['role'])
125        for hostname, hostInfo in trustedHostInfo.items():
126            self.assert_(hostname, "Hostname not set")
127            for k, v in hostInfo.items():
128                self.assert_(k, "hostInfo value key unset")
129
130        print "Trusted Host Info:\n %s" % trustedHostInfo
131
132    def test03GetTrustedHostInfoWithNoMatchingRoleFound(self):
133        """test03GetTrustedHostInfoWithNoMatchingRoleFound: test the case
134        where the input role doesn't match any roles in the target AA's map
135        config file"""
136        _cfg = self.cfg['test03GetTrustedHostInfoWithNoMatchingRoleFound']
137        try:
138            trustedHostInfo = self.siteAClnt.getTrustedHostInfo(_cfg['role'])
139            self.fail("Expecting NoMatchingRoleInTrustedHosts exception")
140           
141        except NoMatchingRoleInTrustedHosts, e:
142            print('As expected - no match for role "%s": %s' % 
143                  (_cfg['role'], e))
144
145
146    def test04GetTrustedHostInfoWithNoRole(self):
147        """test04GetTrustedHostInfoWithNoRole: retrieve trusted host info
148        irrespective of role"""
149        trustedHostInfo = self.siteAClnt.getTrustedHostInfo()
150        for hostname, hostInfo in trustedHostInfo.items():
151            self.assert_(hostname, "Hostname not set")
152            for k, v in hostInfo.items():
153                self.assert_(k, "hostInfo value key unset")
154                   
155        print "Trusted Host Info:\n %s" % trustedHostInfo
156       
157
158    def test05GetAllHostsInfo(self):
159        """test05GetAllHostsInfo: retrieve info for all hosts"""
160        allHostInfo = self.siteAClnt.getAllHostsInfo()
161        for hostname, hostInfo in allHostInfo.items():
162            self.assert_(hostname, "Hostname not set")
163            for k, v in hostInfo.items():
164                self.assert_(k, "hostInfo value key unset")
165                   
166        print "All Hosts Info:\n %s" % allHostInfo
167
168
169    def test06GetAttCert(self):       
170        """test06GetAttCert: Request attribute certificate from NDG Attribute
171        Authority Web Service."""
172        _cfg = self.cfg['test06GetAttCert']
173       
174        # Read user Certificate into a string ready for passing via WS
175        try:
176            userX509CertFilePath = xpdVars(_cfg.get('issuingClntCertFilePath'))
177            userX509CertTxt = open(userX509CertFilePath, 'r').read()
178       
179        except TypeError:
180            # No issuing cert set
181            userX509CertTxt = None
182               
183        except IOError, ioErr:
184            raise Exception("Error reading certificate file \"%s\": %s" % 
185                            (ioErr.filename, ioErr.strerror))
186
187        # Make attribute certificate request
188        attCert = self.siteAClnt.getAttCert(userX509Cert=userX509CertTxt)
189       
190        print "Attribute Certificate: \n\n:" + str(attCert)
191       
192        attCert.filePath = xpdVars(_cfg['attCertFilePath'])
193        attCert.write()
194       
195       
196    def test07GetAttCertWithUserIdSet(self):       
197        """test07GetAttCertWithUserIdSet: Request attribute certificate from
198        NDG Attribute Authority Web Service setting a specific user Id
199        independent of the signer of the SOAP request."""
200        _cfg = self.cfg['test07GetAttCertWithUserIdSet']
201       
202        # Read user Certificate into a string ready for passing via WS
203        try:
204            userX509CertFilePath = xpdVars(_cfg.get('issuingClntCertFilePath'))
205            userX509CertTxt = open(userX509CertFilePath, 'r').read()
206       
207        except TypeError:
208            # No issuing cert set
209            userX509CertTxt = None
210               
211        except IOError, ioErr:
212            raise Exception("Error reading certificate file \"%s\": %s" % 
213                            (ioErr.filename, ioErr.strerror))
214
215        # Make attribute certificate request
216        userId = _cfg['userId']
217        attCert = self.siteAClnt.getAttCert(userId=userId,
218                                            userX509Cert=userX509CertTxt)
219       
220        print "Attribute Certificate: \n\n:" + str(attCert)
221       
222        attCert.filePath = xpdVars(_cfg['attCertFilePath'])
223        attCert.write()
224
225
226    def test08GetMappedAttCert(self):       
227        """test08GetMappedAttCert: Request mapped attribute certificate from
228        NDG Attribute Authority Web Service."""
229        _cfg = self.cfg['test08GetMappedAttCert']
230       
231        # Read user Certificate into a string ready for passing via WS
232        try:
233            userX509CertFilePath = xpdVars(_cfg.get('issuingClntCertFilePath'))
234            userX509CertTxt = open(userX509CertFilePath, 'r').read()
235       
236        except TypeError:
237            # No issuing cert set
238            userX509CertTxt = None
239               
240        except IOError, ioErr:
241            raise Exception("Error reading certificate file \"%s\": %s" % \
242                                    (ioErr.filename, ioErr.strerror))
243   
244        # Simlarly for Attribute Certificate
245        try:
246            userAttCert = AttCertRead(xpdVars(_cfg['userAttCertFilePath']))
247           
248        except IOError, ioErr:
249            raise Exception("Error reading attribute certificate file \"%s\": "
250                            "%s" % (ioErr.filename, ioErr.strerror))
251       
252        # Make client to site B Attribute Authority
253        siteBClnt = AttributeAuthorityClient(uri=_cfg['uri'], 
254                                       cfgFileSection='wsse',
255                                       cfg=self.cfgParser)
256   
257        # Make attribute certificate request
258        attCert = siteBClnt.getAttCert(userX509Cert=userX509CertTxt,
259                                       userAttCert=userAttCert)
260        print "Attribute Certificate: \n\n:" + str(attCert)
261       
262        attCert.filePath = xpdVars(_cfg['mappedAttCertFilePath'])
263        attCert.write()
264       
265       
266    def test09GetMappedAttCertStressTest(self):       
267        """test09GetMappedAttCertStressTest: Request mapped attribute
268        certificate from NDG Attribute Authority Web Service."""
269        _cfg = self.cfg['test09GetMappedAttCertStressTest']
270       
271        # Read user Certificate into a string ready for passing via WS
272        try:
273            userX509CertFilePath = xpdVars(_cfg.get('issuingClntCertFilePath'))
274            userX509CertTxt = open(userX509CertFilePath, 'r').read()
275       
276        except TypeError:
277            # No issuing cert set
278            userX509CertTxt = None
279               
280        except IOError, ioErr:
281            raise Exception("Error reading certificate file \"%s\": %s" % 
282                                    (ioErr.filename, ioErr.strerror))
283
284        # Make client to site B Attribute Authority
285        siteBClnt = AttributeAuthorityClient(uri=_cfg['uri'], 
286                                       cfgFileSection='wsse',
287                                       cfg=self.cfgParser)
288
289        acFilePathList = [xpdVars(file) for file in \
290                          _cfg['userAttCertFilePathList'].split()]
291
292        for acFilePath in acFilePathList:
293            try:
294                userAttCert = AttCertRead(acFilePath)
295               
296            except IOError, ioErr:
297                raise Exception("Error reading attribute certificate file "
298                                '"%s": %s' % (ioErr.filename, ioErr.strerror))
299       
300            # Make attribute certificate request
301            try:
302                attCert = siteBClnt.getAttCert(userX509Cert=userX509CertTxt,
303                                               userAttCert=userAttCert)
304            except Exception, e:
305                outFilePfx = 'test09GetMappedAttCertStressTest-%s' % \
306                        os.path.basename(acFilePath)   
307                msgFile = open(outFilePfx+".msg", 'w')
308                msgFile.write('Failed for "%s": %s\n' % (acFilePath, e))
309
310   
311class AttributeAuthoritySAMLInterfaceTestCase(
312                                        AttributeAuthorityClientBaseTestCase):
313    """Separate class for Attribute Authority SAML Attribute Query interface"""
314   
315    def __init__(self, *arg, **kw):
316        super(AttributeAuthoritySAMLInterfaceTestCase, self).__init__(*arg, 
317                                                                      **kw)
318        self.startSiteAAttributeAuthority(withSSL=True, port=5443)
319       
320    def test01SAMLAttributeQuery(self):
321        _cfg = self.cfg['test01SAMLAttributeQuery']
322       
323        attributeQuery = AttributeQuery()
324        attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20)
325        attributeQuery.id = str(uuid4())
326        attributeQuery.issueInstant = datetime.utcnow()
327       
328        attributeQuery.issuer = Issuer()
329        attributeQuery.issuer.format = Issuer.X509_SUBJECT
330        attributeQuery.issuer.value = "/CN=Authorisation Service/O=Site A"   
331                       
332        attributeQuery.subject = Subject() 
333        attributeQuery.subject.nameID = NameID()
334        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT
335        attributeQuery.subject.nameID.value = _cfg['subject']
336        xsStringNs = SAMLConstants.XSD_NS+"#"+\
337                                        XSStringAttributeValue.TYPE_LOCAL_NAME
338        fnAttribute = Attribute()
339        fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME
340        fnAttribute.nameFormat = xsStringNs
341        fnAttribute.friendlyName = "FirstName"
342
343        attributeQuery.attributes.append(fnAttribute)
344   
345        lnAttribute = Attribute()
346        lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME
347        lnAttribute.nameFormat = xsStringNs
348        lnAttribute.friendlyName = "LastName"
349
350        attributeQuery.attributes.append(lnAttribute)
351   
352        emailAddressAttribute = Attribute()
353        emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME
354        emailAddressAttribute.nameFormat = xsStringNs
355        emailAddressAttribute.friendlyName = "emailAddress"
356       
357        attributeQuery.attributes.append(emailAddressAttribute) 
358
359        siteAAttribute = Attribute()
360        siteAAttribute.name = _cfg['siteAttributeName']
361        siteAAttribute.nameFormat = xsStringNs
362       
363        attributeQuery.attributes.append(siteAAttribute) 
364
365        binding = SamlSoapBinding()
366        response = binding.send(attributeQuery, _cfg['uri'])
367       
368        self.assert_(response.status.statusCode.value==StatusCode.SUCCESS_URI)
369       
370        # Check Query ID matches the query ID the service received
371        self.assert_(response.inResponseTo == attributeQuery.id)
372       
373        now = datetime.utcnow()
374        self.assert_(response.issueInstant < now)
375        self.assert_(response.assertions[-1].issueInstant < now)       
376        self.assert_(response.assertions[-1].conditions.notBefore < now) 
377        self.assert_(response.assertions[-1].conditions.notOnOrAfter > now)
378         
379        samlResponseElem = ResponseElementTree.toXML(response)
380       
381        print("SAML Response ...")
382        print(ElementTree.tostring(samlResponseElem))
383        print("Pretty print SAML Response ...")
384        print(prettyPrint(samlResponseElem))
385             
386    def test02SAMLAttributeQueryInvalidIssuer(self):
387        _cfg = self.cfg['test02SAMLAttributeQueryInvalidIssuer']
388       
389        attributeQuery = AttributeQuery()
390        attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20)
391        attributeQuery.id = str(uuid4())
392        attributeQuery.issueInstant = datetime.utcnow()
393       
394        attributeQuery.issuer = Issuer()
395        attributeQuery.issuer.format = Issuer.X509_SUBJECT
396        attributeQuery.issuer.value = "Invalid Site"   
397                       
398        attributeQuery.subject = Subject() 
399        attributeQuery.subject.nameID = NameID()
400        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT
401        attributeQuery.subject.nameID.value = _cfg['subject']
402        xsStringNs = SAMLConstants.XSD_NS+"#"+\
403                                        XSStringAttributeValue.TYPE_LOCAL_NAME
404
405        siteAAttribute = Attribute()
406        siteAAttribute.name = _cfg['siteAttributeName']
407        siteAAttribute.nameFormat = xsStringNs
408       
409        attributeQuery.attributes.append(siteAAttribute) 
410
411        binding = SamlSoapBinding()
412        response = binding.send(attributeQuery, _cfg['uri'])
413
414        samlResponseElem = ResponseElementTree.toXML(response)
415       
416        print("SAML Response ...")
417        print(ElementTree.tostring(samlResponseElem))
418        print("Pretty print SAML Response ...")
419        print(prettyPrint(samlResponseElem))
420       
421        self.assert_(
422            response.status.statusCode.value==StatusCode.REQUEST_DENIED_URI)
423                   
424    def test03SAMLAttributeQueryUnknownSubject(self):
425        _cfg = self.cfg['test03SAMLAttributeQueryUnknownSubject']
426       
427        attributeQuery = AttributeQuery()
428        attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20)
429        attributeQuery.id = str(uuid4())
430        attributeQuery.issueInstant = datetime.utcnow()
431       
432        attributeQuery.issuer = Issuer()
433        attributeQuery.issuer.format = Issuer.X509_SUBJECT
434        attributeQuery.issuer.value = "/CN=Authorisation Service/O=Site A"   
435                       
436        attributeQuery.subject = Subject() 
437        attributeQuery.subject.nameID = NameID()
438        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT
439        attributeQuery.subject.nameID.value = _cfg['subject']
440        xsStringNs = SAMLConstants.XSD_NS+"#"+\
441                                        XSStringAttributeValue.TYPE_LOCAL_NAME
442
443        siteAAttribute = Attribute()
444        siteAAttribute.name = _cfg['siteAttributeName']
445        siteAAttribute.nameFormat = xsStringNs
446       
447        attributeQuery.attributes.append(siteAAttribute) 
448
449        binding = SamlSoapBinding()
450        response = binding.send(attributeQuery, _cfg['uri'])
451       
452        samlResponseElem = ResponseElementTree.toXML(response)
453        print("SAML Response ...")
454        print(ElementTree.tostring(samlResponseElem))
455        print("Pretty print SAML Response ...")
456        print(prettyPrint(samlResponseElem))
457       
458        self.assert_(
459            response.status.statusCode.value==StatusCode.UNKNOWN_PRINCIPAL_URI)
460             
461    def test04SAMLAttributeQueryInvalidAttrName(self):
462        _cfg = self.cfg['test04SAMLAttributeQueryInvalidAttrName']
463       
464        attributeQuery = AttributeQuery()
465        attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20)
466        attributeQuery.id = str(uuid4())
467        attributeQuery.issueInstant = datetime.utcnow()
468       
469        attributeQuery.issuer = Issuer()
470        attributeQuery.issuer.format = Issuer.X509_SUBJECT
471        attributeQuery.issuer.value = "/CN=Authorisation Service/O=Site A"   
472                       
473        attributeQuery.subject = Subject() 
474        attributeQuery.subject.nameID = NameID()
475        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT
476        attributeQuery.subject.nameID.value = _cfg['subject']
477        xsStringNs = SAMLConstants.XSD_NS+"#"+\
478                                        XSStringAttributeValue.TYPE_LOCAL_NAME
479
480        invalidAttribute = Attribute()
481        invalidAttribute.name = "myInvalidAttributeName"
482        invalidAttribute.nameFormat = xsStringNs
483       
484        attributeQuery.attributes.append(invalidAttribute) 
485
486        binding = SamlSoapBinding()
487        response = binding.send(attributeQuery, _cfg['uri'])
488       
489        samlResponseElem = ResponseElementTree.toXML(response)
490       
491        print("SAML Response ...")
492        print(ElementTree.tostring(samlResponseElem))
493        print("Pretty print SAML Response ...")
494        print(prettyPrint(samlResponseElem))
495       
496        self.assert_(response.status.statusCode.value==\
497                     StatusCode.INVALID_ATTR_NAME_VALUE_URI)
498       
499    def test05AttributeQuerySOAPBindingInterface(self):
500        _cfg = self.cfg['test05AttributeQuerySOAPBindingInterface']
501       
502        binding = AttributeQuerySOAPBinding()
503       
504        binding.subjectID = AttributeAuthoritySAMLInterfaceTestCase.OPENID_URI
505        binding.issuerDN = \
506            AttributeAuthoritySAMLInterfaceTestCase.VALID_REQUESTOR_IDS[0]       
507       
508        binding.queryAttributes = EsgDefaultQueryAttributes.ATTRIBUTES
509       
510        response = binding.send(uri=_cfg['uri'])
511        samlResponseElem = ResponseElementTree.toXML(response)
512       
513        print("SAML Response ...")
514        print(ElementTree.tostring(samlResponseElem))
515        print("Pretty print SAML Response ...")
516        print(prettyPrint(samlResponseElem))
517       
518        self.assert_(response.status.statusCode.value==StatusCode.SUCCESS_URI)
519
520    def test06AttributeQueryFromConfig(self):
521        thisSection = 'test06AttributeQueryFromConfig'
522        _cfg = self.cfg[thisSection]
523       
524        binding = AttributeQuerySOAPBinding.fromConfig(self.cfgFilePath, 
525                                                       section=thisSection,
526                                                       prefix='attributeQuery.')
527        binding.subjectID = _cfg['subject']
528        response = binding.send(uri=_cfg['uri'])
529        samlResponseElem = ResponseElementTree.toXML(response)
530       
531        print("SAML Response ...")
532        print(ElementTree.tostring(samlResponseElem))
533        print("Pretty print SAML Response ...")
534        print(prettyPrint(samlResponseElem))
535       
536        self.assert_(response.status.statusCode.value==StatusCode.SUCCESS_URI)
537       
538    def test07AttributeQuerySslSOAPBindingInterface(self):
539        thisSection = 'test07AttributeQuerySslSOAPBindingInterface'
540        _cfg = self.cfg[thisSection]
541       
542        binding = AttributeQuerySslSOAPBinding.fromConfig(self.cfgFilePath, 
543                                                       section=thisSection,
544                                                       prefix='attributeQuery.')
545       
546        binding.subjectID = _cfg['subject']
547        response = binding.send(uri=_cfg['uri'])
548        samlResponseElem = ResponseElementTree.toXML(response)
549       
550        print("SAML Response ...")
551        print(ElementTree.tostring(samlResponseElem))
552        print("Pretty print SAML Response ...")
553        print(prettyPrint(samlResponseElem))
554       
555        self.assert_(response.status.statusCode.value==StatusCode.SUCCESS_URI)
556       
557if __name__ == "__main__":
558    unittest.main()
Note: See TracBrowser for help on using the repository browser.