Changeset 5596


Ignore:
Timestamp:
11/08/09 11:42:54 (10 years ago)
Author:
pjkersha
Message:

test_saml unit tests fixed running in new saml egg

Location:
TI12-security/trunk/python
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/utils/etree.py

    r5589 r5596  
    1515    import cElementTree, ElementTree 
    1616 
     17import re 
     18 
    1719# Fred Lundh's customisation for C14N functionality - egg available from 
    1820# http://ndg.nerc.ac.uk/dist site 
     
    2931from cStringIO import StringIO 
    3032 
    31 # ElementTree helpers   
    32 getNs = lambda elem: elem.tag.split('}')[0][1:] 
    33 getLocalName = lambda elem: elem.tag.rsplit('}',1)[-1] 
    3433 
    3534class QName(ElementTree.QName): 
    3635    """Extend ElementTree implementation for improved attribute access support 
    3736    """  
     37    # ElementTree tag is of the form {namespace}localPart.  getNs extracts the 
     38    # namespace from within the brackets but if not found returns '' 
     39    getNs = staticmethod(lambda tag: getattr(re.search('(?<=\{).+(?=\})', tag), 
     40                                             'group',  
     41                                             str)()) 
     42                                              
     43    getLocalPart = staticmethod(lambda tag: tag.rsplit('}',1)[-1]) 
     44     
    3845    def __init__(self, namespaceURI, tag=None, prefix=None): 
    3946        ElementTree.QName.__init__(self, namespaceURI, tag=tag) 
     
    4350            self.localPart = tag 
    4451        else: 
    45             self.namespaceURI = QName.getNs(self.text) 
    46             self.localPart = QName.getLocalName(self.text) 
     52            self.namespaceURI = QName.getNs(namespaceURI) 
     53            self.localPart = QName.getLocalPart(namespaceURI) 
    4754             
    4855        self.prefix = prefix 
    4956 
    50     @staticmethod 
    51     def getNs(tag): 
    52         return tag.split('}')[0][1:] 
    53  
    54     @staticmethod 
    55     def getLocalName(tag): 
    56         return tag.rsplit('}',1)[-1] 
    57      
    5857    def _getPrefix(self): 
    5958        return self.__prefix 
     
    8180                            "Namespace URI'") 
    8281 
     82 
    8383def canonicalize(elem, **kw): 
    8484    '''ElementTree based Canonicalization - See ElementC14N for keyword 
     
    9595    ElementC14N.write(ElementC14N.build_scoped_tree(elem), f, **kw) 
    9696    return f.getvalue() 
     97 
    9798 
    9899def prettyPrint(*arg, **kw): 
     
    124125        state can be maintained for declared namespace declarations during 
    125126        recursive calls using "declaredNss" above'''   
    126         strAttrib = ''.join([' %s="%s"' % (att, attVal)  
    127                              for att, attVal in elem.attrib.items()]) 
     127        strAttribs = [] 
     128        for attr, attrVal in elem.attrib.items(): 
     129            nsDeclaration = '' 
     130             
     131            attrNamespace = QName.getNs(attr) 
     132            if attrNamespace: 
     133                nsPrefix = ElementTree._namespace_map.get(attrNamespace) 
     134                if nsPrefix is None: 
     135                    raise KeyError('prettyPrint: missing namespace "%s" for '  
     136                                   'ElementTree._namespace_map'%attrNamespace) 
     137                 
     138                attr = "%s:%s" % (nsPrefix, QName.getLocalPart(attr)) 
     139                 
     140                if attrNamespace not in self.declaredNss: 
     141                    nsDeclaration = ' xmlns:%s="%s"' % (nsPrefix,attrNamespace) 
     142                    self.declaredNss.append(attrNamespace) 
     143                 
     144            strAttribs.append('%s %s="%s"' % (nsDeclaration, attr, attrVal)) 
     145             
     146        strAttrib = ''.join(strAttribs) 
    128147         
    129         namespace = getNs(elem) 
     148        namespace = QName.getNs(elem.tag) 
    130149        nsPrefix = ElementTree._namespace_map.get(namespace) 
    131150        if nsPrefix is None: 
     
    133152                           'ElementTree._namespace_map' % namespace) 
    134153             
    135         tag = "%s:%s" % (nsPrefix, getLocalName(elem)) 
     154        tag = "%s:%s" % (nsPrefix, QName.getLocalPart(elem.tag)) 
    136155         
    137156        # Put in namespace declaration if one doesn't already exist 
  • TI12-security/trunk/python/ndg.security.saml/saml/__init__.py

    r5589 r5596  
    3737# TODO: remove ElementTree dependency - package should XML implementation 
    3838# independent 
    39 from ndg.security.common.utils.etree import QName 
    40 from ndg.security.common.utils import TypedList 
    41 from ndg.security.common.saml.xml import SAMLConstants, XMLConstants 
     39from saml.utils import TypedList 
     40from saml.xml import QName, SAMLConstants, XMLConstants 
    4241 
    4342       
     
    4544    """Base class for all SAML types""" 
    4645    @classmethod 
    47     def parse(cls): 
     46    def parse(cls, xmlObject): 
    4847        raise NotImplementedError() 
    4948     
    5049    @classmethod 
    51     def create(cls): 
     50    def create(cls, samlObject): 
    5251        raise NotImplementedError() 
    5352     
     
    886885        ''' 
    887886        self.__qname = QName(namespaceURI,  
    888                              tag=elementLocalName,  
    889                              prefix=namespacePrefix) 
     887                             elementLocalName,  
     888                             namespacePrefix) 
    890889         
    891890        # BaseID child element. 
     
    11921191        # child "any" elements. 
    11931192        self.__unknownChildren = TypedList(SAMLObject)          
    1194         self.__qname = QName( 
    1195                 namespaceURI=StatusDetail.DEFAULT_ELEMENT_NAME.namespaceURI, 
    1196                 tag=StatusDetail.DEFAULT_ELEMENT_NAME, 
    1197                 prefix=StatusDetail.DEFAULT_ELEMENT_NAME.prefix) 
     1193        self.__qname = QName(StatusDetail.DEFAULT_ELEMENT_NAME.namespaceURI, 
     1194                             StatusDetail.DEFAULT_ELEMENT_NAME, 
     1195                             StatusDetail.DEFAULT_ELEMENT_NAME.prefix) 
    11981196     
    11991197    def getUnknownXMLObjects(self, qname=None):  
     
    13741372        self.__childStatusCode = None 
    13751373         
    1376         self.__qname = QName( 
    1377                     namespaceURI=StatusCode.DEFAULT_ELEMENT_NAME.namespaceURI, 
    1378                     tag=StatusCode.DEFAULT_ELEMENT_NAME, 
    1379                     prefix=StatusCode.DEFAULT_ELEMENT_NAME.prefix) 
     1374        self.__qname = QName(StatusCode.DEFAULT_ELEMENT_NAME.namespaceURI, 
     1375                             StatusCode.DEFAULT_ELEMENT_NAME.localPart, 
     1376                             StatusCode.DEFAULT_ELEMENT_NAME.prefix) 
    13801377 
    13811378    def _getStatusCode(self):  
     
    14491446        self.__statusDetail = None 
    14501447         
    1451         self.__qname = QName( 
    1452                         namespaceURI=Status.DEFAULT_ELEMENT_NAME.namespaceURI, 
    1453                         tag=Status.DEFAULT_ELEMENT_NAME, 
    1454                         prefix=Status.DEFAULT_ELEMENT_NAME.prefix) 
     1448        self.__qname = QName(Status.DEFAULT_ELEMENT_NAME.namespaceURI, 
     1449                             Status.DEFAULT_ELEMENT_NAME.localPart, 
     1450                             Status.DEFAULT_ELEMENT_NAME.prefix) 
    14551451                 
    14561452    def _getQName(self): 
  • TI12-security/trunk/python/ndg.security.saml/saml/test/test_saml.py

    r5589 r5596  
    2020from xml.etree.ElementTree import iselement 
    2121from xml.etree import ElementTree 
    22 from ndg.security.common.utils.etree import prettyPrint 
    23  
    24 from ndg.security.common.saml import Assertion, Attribute, AttributeValue, \ 
    25     AttributeStatement, SAMLVersion, XSStringAttributeValue, \ 
    26     XSGroupRoleAttributeValue, AttributeQuery, Response, Issuer, Subject, \ 
    27     NameID, StatusCode, Status, Conditions 
    28 from ndg.security.common.saml.xml import XMLConstants 
    29 from ndg.security.common.saml.xml.etree import AssertionElementTree, \ 
     22from saml.xml.etree import prettyPrint 
     23 
     24from saml import Assertion, Attribute, AttributeValue, AttributeStatement, \ 
     25    SAMLVersion, XSStringAttributeValue, XSGroupRoleAttributeValue, \ 
     26    AttributeQuery, Response, Issuer, Subject, NameID, StatusCode, Status, \ 
     27    Conditions 
     28from saml.xml import XMLConstants 
     29from saml.xml.etree import AssertionElementTree, \ 
    3030    XSGroupRoleAttributeValueElementTree, AttributeQueryElementTree, \ 
    3131    ResponseElementTree, ConditionsElementTree 
     
    234234        self.assert_(iselement(assertionElem)) 
    235235         
    236         # Serialise to output 
    237         xmlOutput = prettyPrint(assertionElem) 
     236        # Serialise to output  
     237        xmlOutput = prettyPrint(assertionElem)        
    238238        self.assert_(len(xmlOutput)) 
     239         
     240        print("\n"+"_"*80) 
    239241        print(xmlOutput) 
     242        print("_"*80) 
    240243 
    241244    def test02CreateAttributeQuery(self): 
     
    248251                        "https://openid.localhost/philip.kershaw") 
    249252         
    250         elem = AttributeQueryElementTree.create(attributeQuery) 
     253        elem = AttributeQueryElementTree.create(attributeQuery)         
    251254        xmlOutput = prettyPrint(elem) 
     255            
     256        print("\n"+"_"*80) 
    252257        print(xmlOutput) 
     258        print("_"*80) 
    253259 
    254260    def test03ParseAttributeQuery(self): 
     
    261267                        "https://openid.localhost/philip.kershaw") 
    262268         
    263         elem = AttributeQueryElementTree.create(attributeQuery) 
    264         xmlOutput = prettyPrint(elem) 
     269        elem = AttributeQueryElementTree.create(attributeQuery)         
     270        xmlOutput = prettyPrint(elem)        
     271        print("\n"+"_"*80) 
    265272        print(xmlOutput) 
    266273                 
     
    281288                     attributeQuery.attributes[1].name) 
    282289         
    283         xmlOutput2 = prettyPrint(elem2) 
     290        xmlOutput2 = prettyPrint(elem2)        
     291        print("_"*80) 
    284292        print(xmlOutput2) 
     293        print("_"*80) 
    285294 
    286295    def test04createResponse(self): 
     
    335344        self.assert_(iselement(responseElem)) 
    336345         
    337         # Serialise to output 
    338         xmlOutput = prettyPrint(responseElem) 
     346        # Serialise to output         
     347        xmlOutput = prettyPrint(responseElem)        
    339348        self.assert_(len(xmlOutput)) 
     349        print("\n"+"_"*80) 
    340350        print(xmlOutput) 
     351        print("_"*80) 
    341352     
    342353if __name__ == "__main__": 
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/__init__.py

    r5558 r5596  
    371371        return datetime.strptime(issueInstant,  
    372372                                 IssueInstantXMLObject.issueInstantFmt) 
     373         
     374     
     375class QName(object): 
     376    """XML Qualified Name"""  
     377 
     378    def __init__(self, namespaceURI, localPart, prefix): 
     379        self.namespaceURI = namespaceURI 
     380        self.localPart = localPart 
     381        self.prefix = prefix 
     382     
     383    def _getPrefix(self): 
     384        return self.__prefix 
     385 
     386    def _setPrefix(self, value): 
     387        if not isinstance(value, basestring): 
     388            raise TypeError('Expected string type for "prefix"; got %r' % 
     389                            type(value)) 
     390        self.__prefix = value 
     391     
     392    prefix = property(_getPrefix, _setPrefix, None, "Prefix") 
     393 
     394    def _getLocalPart(self): 
     395        return self.__localPart 
     396     
     397    def _setLocalPart(self, value): 
     398        if not isinstance(value, basestring): 
     399            raise TypeError('Expected string type for "localPart"; got %r' % 
     400                            type(value)) 
     401        self.__localPart = value 
     402         
     403    localPart = property(_getLocalPart, _setLocalPart, None, "LocalPart") 
     404 
     405    def _getNamespaceURI(self): 
     406        return self.__namespaceURI 
     407 
     408    def _setNamespaceURI(self, value): 
     409        if not isinstance(value, basestring): 
     410            raise TypeError('Expected string type for "namespaceURI"; got %r' % 
     411                            type(value)) 
     412        self.__namespaceURI = value 
     413   
     414    namespaceURI = property(_getNamespaceURI, _setNamespaceURI, None,  
     415                            "Namespace URI'") 
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/etree.py

    r5595 r5596  
    3030import logging 
    3131log = logging.getLogger(__name__) 
     32import re 
    3233 
    3334try: # python 2.5 
     
    4445from saml.xml import XMLObject, IssueInstantXMLObject, XMLObjectParseError, \ 
    4546    SAMLConstants 
     47from saml.xml import QName as GenericQName 
    4648 
    4749# Generic Helper classes 
     
    4951    """Extend ElementTree implementation for improved attribute access support 
    5052    """  
     53 
     54    # ElementTree tag is of the form {namespace}localPart.  getNs extracts the 
     55    # namespace from within the brackets but if not found returns '' 
     56    getNs = staticmethod(lambda tag: getattr(re.search('(?<=\{).+(?=\})', tag), 
     57                                             'group',  
     58                                             str)()) 
     59                                              
     60    getLocalPart = staticmethod(lambda tag: tag.rsplit('}',1)[-1]) 
     61 
    5162    def __init__(self, namespaceURI, tag=None, prefix=None): 
    5263        ElementTree.QName.__init__(self, namespaceURI, tag=tag) 
     
    5667            self.localPart = tag 
    5768        else: 
    58             self.namespaceURI = QName.getNs(self.text) 
    59             self.localPart = QName.getLocalName(self.text) 
     69            self.namespaceURI = QName.getNs(namespaceURI) 
     70            self.localPart = QName.getLocalPart(namespaceURI) 
    6071             
    6172        self.prefix = prefix 
    62  
    63     getNs = staticmethod(lambda elem: elem.tag.split('}')[0][1:]) 
    64     getLocalName = staticmethod(lambda elem: elem.tag.rsplit('}',1)[-1]) 
    65      
    66 #    @staticmethod 
    67 #    def getNs(tag): 
    68 #        return tag.split('}')[0][1:] 
    69 # 
    70 #    @staticmethod 
    71 #    def getLocalName(tag): 
    72 #        return tag.rsplit('}',1)[-1] 
    7373     
    7474    def _getPrefix(self): 
     
    9696    namespaceURI = property(_getNamespaceURI, _setNamespaceURI, None,  
    9797                            "Namespace URI'") 
     98 
     99    @classmethod 
     100    def fromGeneric(cls, genericQName): 
     101        '''Cast the generic QName type in saml.xml to the ElementTree specific 
     102        implementation''' 
     103        if not isinstance(genericQName, GenericQName): 
     104            raise TypeError("Expecting %r for QName, got %r" % (GenericQName, 
     105                                                        type(genericQName))) 
     106             
     107        qname = cls(genericQName.namespaceURI,  
     108                    tag=genericQName.localPart, 
     109                    prefix=genericQName.prefix) 
     110        return qname 
    98111     
    99112     
     
    126139        state can be maintained for declared namespace declarations during 
    127140        recursive calls using "declaredNss" above'''   
    128         strAttrib = ''.join([' %s="%s"' % (att, attVal)  
    129                              for att, attVal in elem.attrib.items()]) 
    130          
    131         namespace = getNs(elem) 
     141        strAttribs = [] 
     142        for attr, attrVal in elem.attrib.items(): 
     143            nsDeclaration = '' 
     144             
     145            attrNamespace = QName.getNs(attr) 
     146            if attrNamespace: 
     147                nsPrefix = ElementTree._namespace_map.get(attrNamespace) 
     148                if nsPrefix is None: 
     149                    raise KeyError('prettyPrint: missing namespace "%s" for '  
     150                                   'ElementTree._namespace_map'%attrNamespace) 
     151                 
     152                attr = "%s:%s" % (nsPrefix, QName.getLocalPart(attr)) 
     153                 
     154                if attrNamespace not in self.declaredNss: 
     155                    nsDeclaration = ' xmlns:%s="%s"' % (nsPrefix,attrNamespace) 
     156                    self.declaredNss.append(attrNamespace) 
     157                 
     158            strAttribs.append('%s %s="%s"' % (nsDeclaration, attr, attrVal)) 
     159             
     160        strAttrib = ''.join(strAttribs) 
     161         
     162        namespace = QName.getNs(elem.tag) 
    132163        nsPrefix = ElementTree._namespace_map.get(namespace) 
    133164        if nsPrefix is None: 
     
    135166                           'ElementTree._namespace_map' % namespace) 
    136167             
    137         tag = "%s:%s" % (nsPrefix, getLocalName(elem)) 
     168        tag = "%s:%s" % (nsPrefix, QName.getLocalPart(elem.tag)) 
    138169         
    139170        # Put in namespace declaration if one doesn't already exist 
     
    175206         
    176207        if not isinstance(conditions, Conditions): 
    177             raise TypeError("Expecting %r type got: %r"%(Conditions,condition)) 
     208            raise TypeError("Expecting %r type got: %r" % (Conditions, 
     209                                                           conditions)) 
    178210         
    179211        notBeforeStr = cls.datetime2Str(conditions.notBefore) 
     
    183215            cls.NOT_ON_OR_AFTER_ATTRIB_NAME: notOnOrAfterStr, 
    184216        } 
    185         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME), **attrib) 
     217         
     218        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME)) 
     219        elem = ElementTree.Element(tag, **attrib) 
    186220         
    187221        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
     
    215249            cls.VERSION_ATTRIB_NAME: str(assertion.version) 
    216250        } 
    217         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME), **attrib) 
     251        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME)) 
     252        elem = ElementTree.Element(tag, **attrib) 
    218253         
    219254        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
     
    268303                                                           attributeStatement)) 
    269304             
    270         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME)) 
     305        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME))   
     306        elem = ElementTree.Element(tag) 
    271307        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
    272308                                   ] = cls.DEFAULT_ELEMENT_NAME.prefix  
     
    293329        if not isinstance(attribute, Attribute): 
    294330            raise TypeError("Expecting %r type got: %r"%(Attribute, attribute)) 
    295              
    296         elem = ElementTree.Element(str(Attribute.DEFAULT_ELEMENT_NAME)) 
     331         
     332        tag = str(QName.fromGeneric(Attribute.DEFAULT_ELEMENT_NAME))     
     333        elem = ElementTree.Element(tag) 
    297334        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
    298335                                   ] = cls.DEFAULT_ELEMENT_NAME.prefix  
     
    331368                            (ElementTree.Element, elem)) 
    332369 
    333         if getLocalName(elem) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     370        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    334371            raise XMLObjectParseError("No \"%s\" element found" % 
    335372                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     
    350387 
    351388        for childElem in elem: 
    352             localName = getLocalName(childElem) 
    353             if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    354                 raise XMLObjectParseError('Expecting "%s" element; found ' 
    355                                           '"%s"' % 
    356                                           (cls.DEFAULT_ELEMENT_LOCAL_NAME, 
    357                                            localName)) 
     389            localName = QName.getLocalPart(childElem.tag) 
     390            if localName != AttributeValue.DEFAULT_ELEMENT_LOCAL_NAME: 
     391                raise XMLObjectParseError('Expecting "%s" element; found "%s"'% 
     392                                    (AttributeValue.DEFAULT_ELEMENT_LOCAL_NAME, 
     393                                     localName)) 
    358394             
    359395            # Find XML type attribute to key which AttributeValue sub type to  
     
    391427                                                           attributeValue)) 
    392428             
    393         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME)) 
     429        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME))    
     430        elem = ElementTree.Element(tag) 
    394431        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
    395432                                   ] = cls.DEFAULT_ELEMENT_NAME.prefix 
     
    444481                            (ElementTree.Element, elem)) 
    445482 
    446         localName = getLocalName(elem) 
     483        localName = QName.getLocalPart(elem.tag) 
    447484        if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    448485            raise XMLObjectParseError("No \"%s\" element found" % 
     
    461498         
    462499        # Update namespace map as an XSI type has been referenced.  This will 
    463         # ensure the correct prefix is applied if it re-serialised. 
     500        # ensure the correct prefix is applied if it is re-serialised. 
    464501        ElementTree._namespace_map[SAMLConstants.XSI_NS 
    465502                                   ] = SAMLConstants.XSI_PREFIX 
     
    484521        if not isinstance(attributeValue, XSGroupRoleAttributeValue): 
    485522            raise TypeError("Expecting %r type; got: %r" %  
    486                             (XSGroupRole, type(attributeValue))) 
     523                            (XSGroupRoleAttributeValue, type(attributeValue))) 
    487524             
    488525        ElementTree._namespace_map[attributeValue.namespaceURI 
     
    585622            cls.FORMAT_ATTRIB_NAME: issuer.format 
    586623        } 
    587         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME), **attrib) 
     624        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME)) 
     625        elem = ElementTree.Element(tag, **attrib) 
    588626        ElementTree._namespace_map[issuer.qname.namespaceURI 
    589627                                   ] = issuer.qname.prefix 
     
    600638                            (ElementTree.Element, elem)) 
    601639 
    602         if getLocalName(elem) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     640        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    603641            raise XMLObjectParseError('No "%s" element found' % 
    604642                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     
    635673            cls.FORMAT_ATTRIB_NAME: nameID.format 
    636674        } 
    637         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME), **attrib) 
     675        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME)) 
     676        elem = ElementTree.Element(tag, **attrib) 
    638677         
    639678        ElementTree._namespace_map[nameID.qname.namespaceURI 
     
    657696                            (ElementTree.Element, elem)) 
    658697 
    659         if getLocalName(elem) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     698        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    660699            raise XMLObjectParseError("No \"%s\" element found" % 
    661700                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     
    689728                                                           type(subject))) 
    690729             
    691         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME)) 
     730        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME))   
     731        elem = ElementTree.Element(tag) 
    692732         
    693733        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
     
    713753                            (ElementTree.Element, elem)) 
    714754 
    715         if getLocalName(elem) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     755        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    716756            raise XMLObjectParseError("No \"%s\" element found" % 
    717757                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     
    742782            raise TypeError("Expecting %r class got %r" % (StatusCode,  
    743783                                                           type(statusCode))) 
    744  
    745         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME)) 
     784             
     785        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME)) 
     786        elem = ElementTree.Element(tag) 
    746787         
    747788        ElementTree._namespace_map[statusCode.qname.namespaceURI 
     
    765806                            (ElementTree.Element, elem)) 
    766807 
    767         if getLocalName(elem) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     808        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    768809            raise XMLObjectParseError('No "%s" element found' % 
    769810                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    770811             
    771812        statusCode = StatusCode() 
    772         statusCode.format = format 
    773813        statusCode.value = elem.text.strip()  
    774814         
     
    791831                                                           type(Status))) 
    792832             
    793         elem = ElementTree.Element(str(Status.DEFAULT_ELEMENT_NAME)) 
     833        tag = str(QName.fromGeneric(Status.DEFAULT_ELEMENT_NAME))   
     834        elem = ElementTree.Element(tag) 
    794835         
    795836        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
     
    814855                            (ElementTree.Element, elem)) 
    815856 
    816         if getLocalName(elem) != Status.DEFAULT_ELEMENT_LOCAL_NAME: 
     857        if QName.getLocalPart(elem.tag) != Status.DEFAULT_ELEMENT_LOCAL_NAME: 
    817858            raise XMLObjectParseError('No "%s" element found' % 
    818859                                      Status.DEFAULT_ELEMENT_LOCAL_NAME) 
     
    856897            cls.VERSION_ATTRIB_NAME: str(attributeQuery.version) 
    857898        } 
    858                   
    859         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME), **attrib) 
     899         
     900        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME)) 
     901        elem = ElementTree.Element(tag, **attrib) 
    860902         
    861903        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
     
    889931                            (ElementTree.Element, elem)) 
    890932 
    891         if getLocalName(elem) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     933        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    892934            raise XMLObjectParseError("No \"%s\" element found" % 
    893935                                    cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     
    921963         
    922964        for childElem in elem: 
    923             localName = getLocalName(childElem) 
     965            localName = QName.getLocalPart(childElem.tag) 
    924966            if localName == Issuer.DEFAULT_ELEMENT_LOCAL_NAME: 
    925967                # Parse Issuer 
     
    9691011            cls.VERSION_ATTRIB_NAME: str(response.version) 
    9701012        } 
    971                   
    972         elem = ElementTree.Element(str(cls.DEFAULT_ELEMENT_NAME), **attrib) 
     1013         
     1014        tag = str(QName.fromGeneric(cls.DEFAULT_ELEMENT_NAME))         
     1015        elem = ElementTree.Element(tag, **attrib) 
    9731016         
    9741017        ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
     
    10021045                            (ElementTree.Element, elem)) 
    10031046 
    1004         if getLocalName(elem) != Response.DEFAULT_ELEMENT_LOCAL_NAME: 
     1047        if QName.getLocalPart(elem.tag) != Response.DEFAULT_ELEMENT_LOCAL_NAME: 
    10051048            raise XMLObjectParseError("No \"%s\" element found" % 
    1006                                     Response.DEFAULT_ELEMENT_LOCAL_NAME) 
     1049                                      Response.DEFAULT_ELEMENT_LOCAL_NAME) 
    10071050         
    10081051        # Unpack attributes from top-level element 
     
    10361079         
    10371080        for childElem in elem: 
    1038             localName = getLocalName(childElem) 
     1081            localName = QName.getLocalPart(childElem.tag) 
    10391082            if localName == Issuer.DEFAULT_ELEMENT_LOCAL_NAME: 
    10401083                # Parse Issuer 
Note: See TracChangeset for help on using the changeset viewer.