Changeset 6051


Ignore:
Timestamp:
25/11/09 17:11:29 (10 years ago)
Author:
pjkersha
Message:

Refactoring MyProxy? Cert Extension app following updates to the SAML Attribute Query client interface

Location:
TI12-security/trunk/python
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r6034 r6051  
    3939from saml.xml.etree import AssertionElementTree, ResponseElementTree 
    4040    
    41 from ndg.security.common.saml_utils.bindings import SOAPBinding as SamlSoapBinding 
    42 from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
     41from ndg.security.common.saml_utils.bindings import AttributeQuerySslSOAPBinding 
     42from ndg.security.common.saml_utils.esg import (EsgSamlNamespaces, 
     43                                                EsgDefaultQueryAttributes) 
    4344from ndg.security.common.utils.etree import prettyPrint 
    4445from ndg.security.common.X509 import X500DN 
     
    101102    """Application to create a X.509 certificate extension containing a SAML 
    102103    assertion for inclusion by MyProxy into an issued certificate 
    103      
    104     @type DEFAULT_ATTR_DESCR: tuple 
    105     @cvar DEFAULT_ATTR_DESCR: a tuple of tuples describing the default 
    106     SAML attributes to be queried from the Attribute Authority.  The format is, 
    107      
    108     ((<name>, <friendlyName>, <format>), (...), ...) 
    109      
    110     FriendlyName can be defaulted to None in which case it will be omitted from 
    111     the query 
    112104    """ 
    113     XSSTRING_NS = "%s#%s" % ( 
    114         SAMLConstants.XSD_NS, 
    115         XSStringAttributeValue.TYPE_LOCAL_NAME 
    116     ) 
    117     N_ATTR_DESCR_ELEM_ITEMS = 3 
    118      
    119     DEFAULT_ATTR_DESCR = ( 
    120         (EsgSamlNamespaces.FIRSTNAME_ATTRNAME,  
    121          EsgSamlNamespaces.FIRSTNAME_FRIENDLYNAME,  
    122          XSSTRING_NS), 
    123         (EsgSamlNamespaces.LASTNAME_ATTRNAME,  
    124          EsgSamlNamespaces.LASTNAME_FRIENDLYNAME,  
    125          XSSTRING_NS), 
    126         (EsgSamlNamespaces.EMAILADDRESS_ATTRNAME,  
    127          EsgSamlNamespaces.EMAILADDRESS_FRIENDLYNAME,  
    128          XSSTRING_NS), 
    129     ) 
     105    DEFAULT_QUERY_ATTRIBUTES = EsgDefaultQueryAttributes.ATTRIBUTES 
     106    N_DEFAULT_QUERY_ATTRIBUTES = len(DEFAULT_QUERY_ATTRIBUTES) 
    130107    ESG_NAME_ID_FORMAT = EsgSamlNamespaces.NAMEID_FORMAT 
    131108     
    132109    CONNECTION_STRING_OPTNAME = 'connectionString' 
    133110    OPENID_SQLQUERY_OPTNAME = 'openIdSqlQuery' 
    134     OPENID_IDENTITY_URI_TMPL_OPTNAME = 'identityUriTemplate' 
    135111    ATTRIBUTE_AUTHORITY_URI_OPTNAME = 'attributeAuthorityURI' 
    136     ISSUER_DN_OPTNAME = 'issuerDN' 
    137     CLOCK_SKEW_OPTNAME = 'clockSkew' 
    138112     
    139113    CONFIG_FILE_OPTNAMES = ( 
    140114        ATTRIBUTE_AUTHORITY_URI_OPTNAME, 
    141         ISSUER_DN_OPTNAME,                  
    142115        CONNECTION_STRING_OPTNAME, 
    143116        OPENID_SQLQUERY_OPTNAME, 
    144         OPENID_IDENTITY_URI_TMPL_OPTNAME, 
    145         CLOCK_SKEW_OPTNAME             
    146117    ) 
    147     __slots__ = ( 
    148        'userOpenID', 
    149        'attributeDescr' 
    150     ) 
    151     __slots__ += CONFIG_FILE_OPTNAMES 
     118    ATTRIBUTE_QUERY_ATTRNAME = 'attributeQuery' 
     119    LEN_ATTRIBUTE_QUERY_ATTRNAME = len(ATTRIBUTE_QUERY_ATTRNAME) 
     120    __slots__ = CONFIG_FILE_OPTNAMES + (ATTRIBUTE_QUERY_ATTRNAME,) 
    152121    __PRIVATE_ATTR_PREFIX = '_CertExtApp__' 
    153122    __slots__ += tuple([__PRIVATE_ATTR_PREFIX + i for i in __slots__]) 
     
    156125    def __init__(self): 
    157126        self.__attributeAuthorityURI = None 
    158         self.__userOpenID = None 
    159         self.__issuerDN = None 
    160127        self.__connectionString = None 
    161128        self.__openIdSqlQuery = None 
    162         self.__identityUriTemplate = None  
    163         self.__clockSkew = timedelta(seconds=0.) 
    164                 
    165         # Use property here as a safeguard in case DEFAULT_ATTR_DESCR has been 
    166         # altered 
    167         self.attributeDescr = CertExtApp.DEFAULT_ATTR_DESCR 
     129        self.__attributeQuery = AttributeQuerySslSOAPBinding()  
     130        self.__attributeQuery.queryAttributes = \ 
     131            CertExtApp.DEFAULT_QUERY_ATTRIBUTES 
    168132 
    169133    @classmethod 
     
    183147        Attribute Authority for attributes 
    184148        """ 
    185         identifier = self.queryOpenId(username) 
    186         self.userOpenID = IdentityMapping.userIdentifier2IdentityURI( 
    187                                                     self.identityUriTemplate,  
    188                                                     identifier) 
    189          
    190         response = self.attributeQuery() 
     149        self.__attributeQuery.subjectID = self.queryOpenId(username) 
     150        response = self.__attributeQuery.send( 
     151                                                uri=self.attributeAuthorityURI) 
    191152         
    192153        try: 
     
    200161        return assertionStr 
    201162 
    202     def readConfig(self, configFilePath, prefix='', section='DEFAULT'): 
     163    def readConfig(self, cfg, prefix='', section='DEFAULT'): 
    203164        '''Read config file settings 
    204         @type configFilePath: basestring 
    205         @param configFilePath: configuration file path 
     165        @type cfg: basestring /ConfigParser derived type 
     166        @param cfg: configuration file path or ConfigParser type object 
    206167        @type prefix: basestring 
    207168        @param prefix: prefix for option names e.g. "certExtApp." 
     
    210171        parameters. 
    211172        ''' 
    212         cfg = CaseSensitiveConfigParser() 
    213         cfg.read(os.path.expandvars(configFilePath)) 
    214          
    215         for optName in CertExtApp.CONFIG_FILE_OPTNAMES: 
    216             val = cfg.get(section, prefix+optName) 
    217             setattr(self, optName, val) 
    218              
    219     def _getAttributeDescr(self): 
    220         return self.__attributeDescr 
    221  
    222     def _setAttributeDescr(self, value): 
    223         if not isinstance(value, tuple): 
    224             raise TypeError('Expecting tuple type for "attributeDescr";' 
    225                             ' got %r instead' % type(value)) 
    226              
    227         for i in value: 
    228             if not isinstance(value, tuple): 
    229                 raise TypeError('Expecting tuple type for "attributeDescr" ' 
    230                                 'tuple sub-elements; got %r instead' %  
    231                                 type(value)) 
    232             if len(i) != CertExtApp.N_ATTR_DESCR_ELEM_ITEMS: 
    233                 raise TypeError('Expecting %d element tuple for ' 
    234                                 '"attributeDescr" sub-elements; got %d ' 
    235                                 'elements instead' %  
    236                                 (CertExtApp.N_ATTR_DESCR_ELEM_ITEMS, 
    237                                  len(i))) 
    238                  
    239         self.__attributeDescr = value 
    240      
    241     attributeDescr = property(_getAttributeDescr,  
    242                               _setAttributeDescr,  
    243                               doc="List of name, friendly name, format tuples " 
    244                                   "determining attributes to query from the " 
    245                                   "Attribute Authority") 
    246  
     173        if isinstance(cfg, basestring): 
     174            cfgFilePath = os.path.expandvars(cfg) 
     175            _cfg = CaseSensitiveConfigParser() 
     176            _cfg.read(cfgFilePath) 
     177             
     178        elif isinstance(cfg, ConfigParser): 
     179            _cfg = cfg    
     180        else: 
     181            raise AttributeError('Expecting basestring or ConfigParser type ' 
     182                                 'for "cfg" attribute; got %r type' % type(cfg)) 
     183         
     184        prefixLen = len(prefix) 
     185        for optName, val in _cfg.items(section): 
     186            if prefix: 
     187                # Filter attributes based on prefix 
     188                if optName.startswith(prefix): 
     189                    setattr(self, optName[prefixLen:], val) 
     190            else: 
     191                # No prefix set - attempt to set all attributes    
     192                setattr(self, optName, val) 
     193             
     194    def __setattr__(self, name, value): 
     195        """Enable setting of AttributeQuerySslSOAPBinding attributes from 
     196        names starting with attributeQuery.* / attributeQuery_*.  Addition for 
     197        setting these values from ini file 
     198        """ 
     199        try: 
     200            super(CertExtApp, self).__setattr__(name, value) 
     201             
     202        except AttributeError: 
     203            # Coerce into setting AttributeQuerySslSOAPBinding attributes -  
     204            # names must start with 'attributeQuery\W' e.g. 
     205            # attributeQuery.clockSkew or attributeQuery_issuerDN 
     206            if name.startswith(CertExtApp.ATTRIBUTE_QUERY_ATTRNAME):                 
     207                setattr(self.__attributeQuery,  
     208                        name[CertExtApp.LEN_ATTRIBUTE_QUERY_ATTRNAME+1:],  
     209                        value) 
     210            else: 
     211                raise 
     212 
     213    @property 
     214    def attributeQuery(self): 
     215        """SAML SOAP Attribute Query client binding object""" 
     216        return self.__attributeQuery 
     217     
    247218    def _getAttributeAuthorityURI(self): 
    248219        return self.__attributeAuthorityURI 
     
    257228                                     _setAttributeAuthorityURI,  
    258229                                     doc="Attribute Authority SOAP SAML URI") 
    259  
    260     def _getUserOpenID(self): 
    261         return self.__userOpenID 
    262  
    263     def _setUserOpenID(self, value): 
    264         if not isinstance(value, basestring): 
    265             raise TypeError('Expecting string type for "userOpenID"; got %r ' 
    266                             'instead' % type(value)) 
    267         self.__userOpenID = value 
    268  
    269     userOpenID = property(_getUserOpenID, _setUserOpenID,  
    270                           doc="OpenID corresponding to user certificate to " 
    271                               "be issued") 
    272  
    273     def _getIssuerDN(self): 
    274         return self.__issuerDN 
    275  
    276     def _setIssuerDN(self, value): 
    277         if isinstance(value, basestring): 
    278             self.__issuerDN = X500DN.fromString(value) 
    279              
    280         elif isinstance(value, X500DN): 
    281             self.__issuerDN = value 
    282         else: 
    283             raise TypeError('Expecting string or X500DN type for "issuerDN"; ' 
    284                             'got %r instead' % type(value)) 
    285         self.__issuerDN = value 
    286  
    287     issuerDN = property(_getIssuerDN, _setIssuerDN,  
    288                         doc="Distinguished Name of issuer of SAML Attribute " 
    289                             "Query to Attribute Authority") 
    290230 
    291231    def _getConnectionString(self): 
     
    316256                        fset=_setOpenIdSqlQuery,  
    317257                        doc="SQL Query for authentication request") 
    318  
    319     def _getIdentityUriTemplate(self): 
    320         return self.__identityUriTemplate 
    321  
    322     def _setIdentityUriTemplate(self, value): 
    323         if not isinstance(value, basestring): 
    324             raise TypeError('Expecting string type for "%s" attribute; got %r'%  
    325                             (CertExtApp.OPENID_IDENTITY_URI_TMPL_OPTNAME, 
    326                              type(value))) 
    327         self.__identityUriTemplate = value 
    328  
    329     identityUriTemplate = property(_getIdentityUriTemplate,  
    330                                    _setIdentityUriTemplate,  
    331                                    doc="Identity URI template string - sets " 
    332                                        "the common component of user's " 
    333                                        "identity URI.  It should contain the " 
    334                                        "${userIdentifier} template " 
    335                                        "substitution parameter") 
    336  
    337     def _getClockSkew(self): 
    338         return self.__clockSkew 
    339  
    340     def _setClockSkew(self, value): 
    341         if isinstance(value, (float, int, long)): 
    342             self.__clockSkew = timedelta(seconds=value) 
    343              
    344         elif isinstance(value, basestring): 
    345             self.__clockSkew = timedelta(seconds=float(value)) 
    346         else: 
    347             raise TypeError('Expecting float, int, long or string type for ' 
    348                             '"clockSkew"; got %r' % type(value)) 
    349  
    350     clockSkew = property(fget=_getClockSkew,  
    351                          fset=_setClockSkew,  
    352                          doc="Allow a clock skew in seconds for SAML Attribute" 
    353                              " Query issueInstant parameter check") 
    354258         
    355259    def __getstate__(self): 
    356260        '''Specific implementation needed with __slots__''' 
    357         return dict([(attrName, getattr(self, attrName)) \ 
     261        return dict([(attrName, getattr(self, attrName))  
    358262                     for attrName in CertExtApp.__slots__]) 
    359263         
     
    367271        samlAssertionElem = AssertionElementTree.toXML(assertion) 
    368272        return ElementTree.tostring(samlAssertionElem) 
    369          
    370     def attributeQuery(self): 
    371         """Query an Attribute Authority to retrieve an assertion for the  
    372         given user""" 
    373                  
    374         # Create a SAML attribute query 
    375         attributeQuery = AttributeQuery() 
    376         attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20) 
    377         attributeQuery.id = str(uuid4()) 
    378         attributeQuery.issueInstant = datetime.utcnow() 
    379          
    380         attributeQuery.issuer = Issuer() 
    381         attributeQuery.issuer.format = Issuer.X509_SUBJECT 
    382         attributeQuery.issuer.value = self.issuerDN 
    383                          
    384         attributeQuery.subject = Subject()   
    385         attributeQuery.subject.nameID = NameID() 
    386         attributeQuery.subject.nameID.format = \ 
    387                             CertExtApp.ESG_NAME_ID_FORMAT 
    388         attributeQuery.subject.nameID.value = self.userOpenID 
    389                    
    390         # Add list of attributes to query                       
    391         for name, friendlyName, format in self.attributeDescr: 
    392             attribute = Attribute() 
    393             attribute.name = name 
    394             attribute.nameFormat = format 
    395             attribute.friendlyName = friendlyName 
    396      
    397             attributeQuery.attributes.append(attribute) 
    398  
    399         # Make query over SOAP interface to remote service 
    400         binding = SamlSoapBinding() 
    401         response = binding.attributeQuery(attributeQuery,  
    402                                           self.attributeAuthorityURI) 
    403          
    404         if log.level <= logging.DEBUG:             
    405             log.debug("Attribute Authority [%s] SAML Response:",  
    406                       self.attributeAuthorityURI) 
    407             log.debug("_"*80) 
    408             responseElem = ResponseElementTree.toXML(response) 
    409             log.debug(prettyPrint(responseElem)) 
    410          
    411         if response.status.statusCode.value != StatusCode.SUCCESS_URI: 
    412             samlResponseError = CertExtAppSamlResponseError() 
    413             samlResponseError.status = response.status 
    414             raise samlResponseError 
    415          
    416         # Check Query ID matches the query ID the service received 
    417         if response.inResponseTo != attributeQuery.id: 
    418             samlResponseError = CertExtAppSamlResponseError() 
    419             samlResponseError.status = response.status 
    420             raise samlResponseError 
    421          
    422         utcNow = datetime.utcnow()+ self.clockSkew 
    423         if response.issueInstant > utcNow: 
    424             samlResponseError = CertExtAppSamlResponseError() 
    425              
    426             msg = ('SAML Attribute Response issueInstant [%s] is after ' 
    427                    'the current clock time [%s]' %  
    428                    (attributeQuery.issueInstant, SAMLDateTime.toString(utcNow))) 
    429                        
    430             samlResponseError.status.statusCode.value = StatusCode.RESPONDER_URI 
    431             samlResponseError.status.statusMessage.value = msg 
    432             raise samlResponseError 
    433          
    434         if utcNow < response.assertions[-1].conditions.notBefore: 
    435             samlResponseError = CertExtAppSamlResponseError() 
    436              
    437             msg = ('The current clock time [%s] is before the SAML Attribute ' 
    438                    'Response assertion conditions not before time [%s]' %  
    439                    (SAMLDateTime.toString(utcNow), 
    440                     response.assertions[-1].conditions.notBefore)) 
    441                        
    442             samlResponseError.status.statusCode.value = StatusCode.RESPONDER_URI 
    443             samlResponseError.status.statusMessage.value = msg 
    444             raise samlResponseError 
    445           
    446         if utcNow >= response.assertions[-1].conditions.notOnOrAfter: 
    447             samlResponseError = CertExtAppSamlResponseError()             
    448              
    449             msg = ('The current clock time [%s] is on or after the SAML ' 
    450                    'Attribute Response assertion conditions not on or after ' 
    451                    'time [%s]' %  
    452                    (SAMLDateTime.toString(utcNow), 
    453                     response.assertions[-1].conditions.notOnOrAfter)) 
    454                        
    455             samlResponseError.status.statusCode.value = StatusCode.RESPONDER_URI 
    456             samlResponseError.status.statusMessage.value = msg 
    457             raise samlResponseError 
    458          
    459         return response 
    460273     
    461274    def queryOpenId(self, username): 
    462         """Given a username, query for user OpenID identifier from the user  
     275        """Given a username, query for user OpenID from the user  
    463276        database 
    464277 
     
    488301 
    489302        try: 
    490             identifier = [r for r in result][0][0] 
     303            openId = [r for r in result][0][0] 
    491304         
    492305        except Exception: 
     
    495308         
    496309        log.debug('Query succeeded for user %r' % username) 
    497         return identifier 
     310        return openId 
    498311     
    499312     
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/__init__.py

    r6040 r6051  
    212212                           Column('username', String), 
    213213                           Column('md5password', String), 
     214                           Column('openid', String), 
    214215                           Column('openid_identifier', String), 
    215216                           Column('firstname', String), 
     
    228229            id = Column(Integer, primary_key=True) 
    229230            username = Column('username', String(40)) 
    230             md5password = Column('md5password', String(40)) 
     231            md5password = Column('md5password', String(64)) 
     232            openid = Column('openid', String(128)) 
    231233            openid_identifier = Column('openid_identifier', String(40)) 
    232234            firstname = Column('firstname', String(40)) 
     
    234236            emailAddress = Column('emailaddress', String(40)) 
    235237         
    236             def __init__(self, username, md5password, openid_identifier,  
     238            def __init__(self, username, md5password, openid, openid_identifier,  
    237239                         firstname, lastname, emailaddress): 
    238240                self.username = username 
    239241                self.md5password = md5password 
     242                self.openid = openid 
    240243                self.openid_identifier = openid_identifier 
    241244                self.firstname = firstname 
     
    263266        user = User(BaseTestCase.USERNAME,  
    264267                    BaseTestCase.MD5_PASSWORD, 
     268                    BaseTestCase.OPENID_URI, 
    265269                    BaseTestCase.OPENID_IDENTIFIER, 
    266270                    BaseTestCase.FIRSTNAME, 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/config.ini

    r6018 r6051  
    1111[DEFAULT] 
    1212connectionString = sqlite:///$NDGSEC_TEST_CONFIG_DIR/user.db 
    13 openIdSqlQuery = select openid_identifier from users where username = '${username}'      
    14 identityUriTemplate = https://openid.localhost/${userIdentifier} 
     13openIdSqlQuery = select openid from users where username = '${username}'      
    1514attributeAuthorityURI = http://localhost:5000/AttributeAuthority/saml 
    16 issuerDN = /O=Site A/CN=Authorisation Service 
    17 clockSkew = 0 
     15attributeQuery.issuerDN = /O=Site A/CN=Authorisation Service 
     16attributeQuery.clockSkew = 0 
     17attributeQuery_queryAttributes.0 = urn:esg:email:address, EmailAddress, http://www.w3.org/2001/XMLSchema#string 
     18attributeQuery.queryAttributes.roles = urn:siteA:security:authz:1.0:attr, , http://www.w3.org/2001/XMLSchema#string 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/test_saml_attribute_assertion.py

    r6009 r6051  
    3131    OPENID = Template(OPENID_TMPL).substitute( 
    3232                        {'userIdentifier': BaseTestCase.OPENID_IDENTIFIER}) 
    33     OPENID_SQL_QUERY = ("select openid_identifier from users where username " 
     33    OPENID_SQL_QUERY = ("select openid from users where username " 
    3434                        "= '${username}'")  
    35          
     35    SITEA_SSL_ATTRIBUTEAUTHORITY_PORTNUM = 5443 
     36    SITEA_SSL_ATTRIBUTEAUTHORITY_URI = ('https://localhost:%d/AttributeAuthority' 
     37                                        '/saml' %  
     38                                        SITEA_SSL_ATTRIBUTEAUTHORITY_PORTNUM) 
     39    INI_FILEPATH = os.path.join(THIS_DIR, 'config.ini') 
     40     
    3641    def __init__(self, *arg, **kw): 
    3742        super(CertExtAppTestCase, self).__init__(*arg, **kw)             
    38         self.startSiteAAttributeAuthority() 
     43        self.startSiteAAttributeAuthority(withSSL=True,  
     44                    port=CertExtAppTestCase.SITEA_SSL_ATTRIBUTEAUTHORITY_PORTNUM) 
    3945        self.initDb() 
    4046         
     
    4652        myProxyCertExtApp.openIdSqlQuery = CertExtAppTestCase.OPENID_SQL_QUERY 
    4753         
    48         identifier = myProxyCertExtApp.queryOpenId(CertExtAppTestCase.USERNAME) 
    49         self.assert_(identifier == CertExtAppTestCase.OPENID_IDENTIFIER) 
     54        openid = myProxyCertExtApp.queryOpenId(CertExtAppTestCase.USERNAME) 
     55        self.assert_(openid == CertExtAppTestCase.OPENID_URI) 
    5056         
    5157    def test02AttributeQuery(self): 
    5258        myProxyCertExtApp = CertExtApp() 
    53         myProxyCertExtApp.attributeAuthorityURI = ( 
    54                             'http://localhost:%d/AttributeAuthority/saml' %  
    55                             CertExtAppTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM) 
    56         myProxyCertExtApp.issuerDN = "/O=Site A/CN=Authorisation Service" 
    57         myProxyCertExtApp.userOpenID = CertExtAppTestCase.OPENID 
     59        myProxyCertExtApp.attributeQuery.issuerDN = "/O=Site A/CN=Authorisation Service" 
     60        myProxyCertExtApp.attributeQuery.subjectID = CertExtAppTestCase.OPENID 
    5861                                 
    59         assertion = myProxyCertExtApp.attributeQuery() 
    60         print(assertion) 
     62        response = myProxyCertExtApp.attributeQuery.send( 
     63                    uri=CertExtAppTestCase.SITEA_SSL_ATTRIBUTEAUTHORITY_URI) 
     64        print(response) 
    6165         
    6266    def test03End2End(self): 
     
    6670                                        CertExtAppTestCase.DB_CONNECTION_STR 
    6771                     
    68         myProxyCertExtApp.openIdSqlQuery = ("select openid_identifier from " 
    69                                             "users where username = '%s'" % 
     72        myProxyCertExtApp.openIdSqlQuery = ("select openid from users where " 
     73                                            "username = '%s'" % 
    7074                                            CertExtAppTestCase.USERNAME) 
    71          
    72         myProxyCertExtApp.identityUriTemplate = CertExtAppTestCase.OPENID_TMPL 
    73                              
    74         myProxyCertExtApp.attributeAuthorityURI = ( 
    75                         'http://localhost:%d/AttributeAuthority/saml' %  
    76                         CertExtAppTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM) 
    77         myProxyCertExtApp.issuerDN = "/O=Site A/CN=Authorisation Service" 
     75 
     76        myProxyCertExtApp.attributeAuthorityURI = \ 
     77                            CertExtAppTestCase.SITEA_SSL_ATTRIBUTEAUTHORITY_URI 
     78        myProxyCertExtApp.attributeQuery.issuerDN = \ 
     79            "/O=Site A/CN=Authorisation Service" 
    7880         
    7981        assertion = myProxyCertExtApp(CertExtAppTestCase.USERNAME) 
     
    8284 
    8385    def test04FromConfigFile(self): 
    84         configFilePath = os.path.join(CertExtAppTestCase.THIS_DIR, 'config.ini') 
    85         myProxyCertExtApp = CertExtApp.fromConfigFile(configFilePath) 
     86        myProxyCertExtApp = CertExtApp.fromConfigFile( 
     87                                            CertExtAppTestCase.INI_FILEPATH) 
    8688        assertion = myProxyCertExtApp(CertExtAppTestCase.USERNAME) 
    8789        self.assert_(assertion) 
     
    8991 
    9092    def test05ConsoleApp(self): 
    91         configFilePath = os.path.join(CertExtAppTestCase.THIS_DIR, 'config.ini') 
    9293        import sys 
    9394        sys.argv = [ 
    94             None, "-f", configFilePath, "-u", CertExtAppTestCase.USERNAME 
     95            None,  
     96            "-f", CertExtAppTestCase.INI_FILEPATH,  
     97            "-u", CertExtAppTestCase.USERNAME 
    9598        ] 
    9699        try: 
Note: See TracChangeset for help on using the changeset viewer.