Changeset 6009


Ignore:
Timestamp:
13/11/09 13:56:02 (10 years ago)
Author:
pjkersha
Message:

1.3.2 Release

  • includes Genshi template plugins for OpenID
  • SQLAlchemy plugins for OpenID AX and authentication and Attribute Authority attribute interface
  • SQLite database set-up for unittests
Location:
TI12-security/trunk/python
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security/setup.cfg

    r5792 r6009  
    1818 
    1919[egg_info] 
    20 tag_build = rc2 
     20tag_build =  
    2121tag_svn_revision = true 
    2222 
  • TI12-security/trunk/python/ndg_security/setup.py

    r5961 r6009  
    4242setup( 
    4343    name =                      'ndg_security', 
    44     version =                   '1.3.1', 
     44    version =                   '1.3.2', 
    4545    description =               'NERC DataGrid Security Utilities', 
    4646    long_description =          _longDescription, 
  • TI12-security/trunk/python/ndg_security_client/setup.cfg

    r5792 r6009  
    1616 
    1717[egg_info] 
    18 tag_build = rc2 
     18tag_build =  
    1919tag_svn_revision = true 
    2020 
  • TI12-security/trunk/python/ndg_security_client/setup.py

    r5961 r6009  
    4444setup( 
    4545    name =                      'ndg_security_client', 
    46     version =                   '1.3.1', 
     46    version =                   '1.3.2', 
    4747    description =               'NERC DataGrid Security Client side interface', 
    4848    long_description =          _longDescription, 
  • TI12-security/trunk/python/ndg_security_common/ndg/security/common/authz/msi.py

    r5433 r6009  
    575575            # problem occurs here 
    576576            try: 
    577                 attributeResponse=self.pip.attributeQuery(attributeQuery) 
     577                attributeResponse = self.pip.attributeQuery(attributeQuery) 
    578578                 
    579579            except SubjectRetrievalError, e: 
  • TI12-security/trunk/python/ndg_security_common/setup.cfg

    r5792 r6009  
    1616 
    1717[egg_info] 
    18 tag_build = rc2 
     18tag_build =  
    1919tag_svn_revision = true 
    2020 
  • TI12-security/trunk/python/ndg_security_common/setup.py

    r5961 r6009  
    6969setup( 
    7070    name =                      'ndg_security_common', 
    71     version =                   '1.3.1', 
     71    version =                   '1.3.2', 
    7272    description =           'NERC DataGrid Security package containing common ' 
    7373                            'utilities used by both server and client ' 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/attributeauthority.py

    r5982 r6009  
    3434                             Status, StatusCode, StatusMessage) 
    3535 
     36from ndg.security.common.saml.esg import EsgSamlNamespaces 
    3637from ndg.security.common.utils import TypedList 
    3738from ndg.security.common.utils.classfactory import instantiateClass 
    3839from ndg.security.common.utils.configfileparsers import ( 
    39     CaseSensitiveConfigParser, ) 
     40    CaseSensitiveConfigParser) 
    4041     
    4142# X.509 Certificate handling 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/authnservice/dbauthn.py

    r4840 r6009  
    55Interface uses SQLAlchemy to enable support for multiple database vendors 
    66 
    7 NERC Data Grid Project 
     7NERC DataGrid Project 
    88""" 
    99__author__ = "P J Kershaw" 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r5982 r6009  
    244244                            (CertExtApp.CONNECTION_STRING_OPTNAME, 
    245245                             type(value))) 
    246         self.__connectionString = value 
     246        self.__connectionString = os.path.expandvars(value) 
    247247 
    248248    connectionString = property(fget=_getConnectionString,  
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/__init__.py

    r5929 r6009  
    1111import logging 
    1212log = logging.getLogger(__name__) 
     13 
    1314 
    1415class AuthNInterfaceError(Exception): 
     
    7475    Derive from this class to define the authentication interface for users 
    7576    logging into the OpenID Provider''' 
     77     
     78    # Slot declaration here enables derived classes to use slots if they want to 
    7679    __slots__ = () 
    7780     
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/sqlalchemy_authn.py

    r5870 r6009  
    2323 
    2424from ndg.security.common.utils import str2Bool as _str2Bool 
    25 from ndg.security.server.wsgi.openid.provider.authninterface import \ 
    26     AbstractAuthNInterface, AuthNInterfaceInvalidCredentials, \ 
    27     AuthNInterfaceRetrieveError, AuthNInterfaceConfigError, \ 
    28     AuthNInterfaceUsername2IdentifierMismatch 
     25from ndg.security.server.wsgi.openid.provider.authninterface import ( 
     26    AbstractAuthNInterface, AuthNInterfaceInvalidCredentials,  
     27    AuthNInterfaceRetrieveError, AuthNInterfaceConfigError,  
     28    AuthNInterfaceUsername2IdentifierMismatch) 
    2929 
    3030 
     
    3535    str2Bool = staticmethod(_str2Bool) 
    3636     
     37    USERNAME_SQLQUERY_KEYNAME = 'username' 
     38    PASSWD_SQLQUERY_KEYNAME = 'password' 
    3739    CONNECTION_STRING_OPTNAME = 'connectionString' 
    3840    LOGON_SQLQUERY_OPTNAME = 'logonSqlQuery' 
     
    4648        IS_MD5_ENCODED_PWD 
    4749    ) 
     50    __slots__ += tuple(["_SQLAlchemyAuthnInterface__%s" % name 
     51                        for name in __slots__]) 
    4852     
    4953    def __init__(self, **prop): 
     
    150154         
    151155        @type password: basestring 
    152         @param password: corresponding password for username givens 
     156        @param password: corresponding password for username given 
    153157         
    154158        @raise AuthNInterfaceInvalidCredentials: invalid username/password 
     
    178182         
    179183        try: 
    180             queryInputs = dict(username=username, password=_password) 
     184            queryInputs = { 
     185                SQLAlchemyAuthnInterface.USERNAME_SQLQUERY_KEYNAME: username, 
     186                SQLAlchemyAuthnInterface.PASSWD_SQLQUERY_KEYNAME: _password 
     187            } 
    181188            query = Template(self.logonSqlQuery).substitute(queryInputs) 
     189             
     190        except KeyError, e: 
     191            raise AuthNInterfaceConfigError("Invalid key %r for logon SQL " 
     192                "query string.  Valid keys are %r and %r" % 
     193                (e,  
     194                 SQLAlchemyAuthnInterface.USERNAME_SQLQUERY_KEYNAME, 
     195                 SQLAlchemyAuthnInterface.PASSWD_SQLQUERY_KEYNAME)) 
     196             
     197        try: 
    182198            result = connection.execute(query) 
    183199 
    184         except exc.ProgrammingError: 
    185             raise AuthNInterfaceRetrieveError("Error with SQL Syntax: %s" % 
     200        except (exc.ProgrammingError, exc.OperationalError): 
     201            raise AuthNInterfaceRetrieveError("Error with SQL: %s" % 
    186202                                              traceback.format_exc()) 
    187203        finally: 
    188204            connection.close() 
    189  
    190         if result.rowcount != 1: 
    191             raise AuthNInterfaceInvalidCredentials() 
     205             
     206        nEntries = int([r[0] for r in result][0]) 
     207        if nEntries != 1: 
     208            raise AuthNInterfaceInvalidCredentials("Invalid password for user " 
     209                                                   "%r" % username) 
    192210         
    193211        log.debug('Logon succeeded for user %r' % username) 
     
    230248         
    231249        try: 
    232             queryInputs = dict(username=username) 
     250            queryInputs = { 
     251                SQLAlchemyAuthnInterface.USERNAME_SQLQUERY_KEYNAME: username, 
     252            } 
    233253            queryTmpl = Template(self.username2UserIdentifierSqlQuery) 
    234254            query = queryTmpl.substitute(queryInputs) 
     255             
     256        except KeyError, e: 
     257            raise AuthNInterfaceConfigError("Invalid key %r for username to " 
     258                                            "user identifier SQL query string. " 
     259                                            " The valid key is %r" % (e, 
     260                            SQLAlchemyAuthnInterface.USERNAME_SQLQUERY_KEYNAME)) 
     261         
     262        try: 
    235263            result = connection.execute(query) 
    236264 
    237         except exc.ProgrammingError: 
    238             raise AuthNInterfaceRetrieveError("Error with SQL Syntax: %s" % 
     265        except (exc.ProgrammingError, exc.OperationalError): 
     266            raise AuthNInterfaceRetrieveError("Error with SQL query: %s" % 
    239267                                              traceback.format_exc()) 
    240268        finally: 
    241269            connection.close() 
    242270             
    243         if result.rowcount == 0: 
     271        userIdentifiers = tuple([i[0] for i in result.fetchall()])      
     272        if len(userIdentifiers) == 0: 
    244273            raise AuthNInterfaceInvalidCredentials('No entries for "%s" user' %  
    245                                                   username) 
    246              
    247         userIdentifiers = tuple([i[0] for i in result.fetchall()]) 
     274                                                   username) 
    248275           
    249276        log.debug('username %r maps to OpenID identifiers: %r', username, 
     
    254281    def __getstate__(self): 
    255282        '''Explicit pickling required with __slots__''' 
    256         return dict([(attrName, getattr(self, attrName)) \ 
     283        return dict([(attrName, getattr(self, attrName))  
    257284                     for attrName in SQLAlchemyAuthnInterface.__slots__]) 
    258285         
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/sqlalchemy_ax.py

    r5984 r6009  
    4141        IDENTITY_URI_TMPL_OPTNAME 
    4242    ) 
     43    __slots__ += tuple(["_SQLAlchemyAXInterface__%s" % name  
     44                        for name in __slots__]) 
     45    del name 
    4346     
    4447    def __init__(self, **properties): 
     
    5558        self.__sqlQuery = None 
    5659        self.__attributeNames = None 
    57         self.__identityUriTemplate = None 
    5860         
    5961        self.setProperties(**properties) 
    60  
    61     def _getIdentityUriTemplate(self): 
    62         return self.__identityUriTemplate 
    63  
    64     def _setIdentityUriTemplate(self, value): 
    65         if not isinstance(value, basestring): 
    66             raise TypeError('Expecting string type for "%s" ' 
    67                             'attribute; got %r' %  
    68                             (SQLAlchemyAXInterface.IDENTITY_URI_TMPL_OPTNAME, 
    69                              type(value))) 
    70         self.__identityUriTemplate = value 
    71  
    72     identityUriTemplate = property(_getIdentityUriTemplate,  
    73                                    _setIdentityUriTemplate,  
    74                                    doc="Identity URI template string - sets " 
    75                                        "the common component of user's " 
    76                                        "identity URI.  It should contain the " 
    77                                        "${userIdentifier} template " 
    78                                        "substitution parameter") 
    7962 
    8063    def _getConnectionString(self): 
     
    164147         
    165148        requiredAttributeURIs = ax_req.getRequiredAttrs() 
    166                                       
     149         
     150        if self.attributeNames is None: 
     151            raise AXInterfaceConfigError('No "attributeNames" setting has ' 
     152                                         'been made') 
     153 
    167154        missingAttributeURIs = [ 
    168155            requiredAttributeURI  
     
    177164 
    178165        # Query for available attributes 
    179         connection = self._makeDbConnection() 
    180166        userAttributeMap = self._attributeQuery(identityURI) 
    181167         
     
    203189                         requestedAttributeURI) 
    204190 
    205         return  
    206  
    207191    def _attributeQuery(self, username): 
    208192        '''Query the database for attributes and map these to the attribute 
     
    210194        correct mapping between the SQL query results and the attribute names  
    211195        they refer to 
    212         ''' 
    213          
     196        '''             
    214197        if self.connectionString is None: 
    215             raise AuthNInterfaceConfigError('No "connectionString" setting ' 
    216                                             'has been made') 
     198            raise AXInterfaceConfigError('No "connectionString" setting has ' 
     199                                         'been made') 
    217200        dbEngine = create_engine(self.connectionString) 
    218201         
     
    224207             
    225208        except KeyError, e: 
    226             raise AuthNInterfaceConfigError("Invalid key for attribute query " 
    227                                             "string.  The valid key is %r" %  
    228                                 SQLAlchemyAXInterface.SQLQUERY_USERID_KEYNAME) 
     209            raise AXInterfaceConfigError("Invalid key %r for attribute query " 
     210                                         "string.  The valid key is %r" % (e,  
     211                                SQLAlchemyAXInterface.SQLQUERY_USERID_KEYNAME)) 
     212             
     213        connection = dbEngine.connect() 
    229214             
    230215        try: 
    231             dbEngine.connect() 
    232216            result = connection.execute(query) 
    233217 
     
    238222            connection.close() 
    239223 
    240         if result.rowcount == 0: 
    241             raise AXInterfaceConfigError("No attribute entry for user [%s] " % 
    242                                          username) 
    243         elif result.rowcount > 1: 
    244             raise AXInterfaceConfigError("Multiple attribute entries for user " 
    245                                          "[%s] " % username) 
    246          
    247224        attributeValues = result.fetchall()[0] 
     225         
    248226        if len(self.attributeNames) != len(attributeValues): 
    249227            raise AXInterfaceConfigError("Attribute query results %r, don't " 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/buffet/__init__.py

    r5080 r6009  
    160160    def decidePage(self, environ, start_response, oidRequest): 
    161161        """Handle user interaction required before final submit back to Relying 
    162         Party""" 
     162        Party 
     163        @type oidRequest: openid.server.server.CheckIDRequest 
     164        @param oidRequest: OpenID Check ID Request object 
     165        """ 
    163166        self.title = 'Approve OpenID Request?' 
    164167        self.trust_root = oidRequest.trust_root 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/genshi/__init__.py

    r5984 r6009  
    1818from genshi.template import TemplateLoader 
    1919from openid.consumer import discover 
     20from openid.server.server  import CheckIDRequest 
    2021 
    2122# Rendering classes for OpenID Provider must derive from generic render  
     
    5354        'trust_root', 
    5455        'environ', 
    55         'identityURI' 
     56        'identityURI', 
     57        'oidRequest' 
    5658    ) 
    5759    __slots__ += tuple(["_GenshiRendering__%s" % name for name in __slots__]) 
     
    9698        self.success_to = '' 
    9799        self.fail_to = '' 
     100         
     101        self.__oidRequest = None 
     102        self.__identityURI = None 
     103        self.__environ = None 
     104        self.__trust_root = None 
    98105 
    99106    def getEnviron(self): 
    100107        return self.__environ 
    101108 
    102  
    103109    def getIdentityURI(self): 
    104110        return self.__identityURI 
    105111 
    106  
    107112    def setEnviron(self, value): 
    108113        self.__environ = value 
    109114 
    110  
    111115    def setIdentityURI(self, value): 
    112116        self.__identityURI = value 
    113117 
    114  
    115118    def getTrust_root(self): 
    116119        return self.__trust_root 
    117120 
    118  
    119121    def getOidRequest(self): 
    120122        return self.__oidRequest 
    121123 
    122  
    123124    def setTrust_root(self, value): 
     125        if not isinstance(value, basestring): 
     126            raise TypeError('Expecting string type for trust_root attribute; ' 
     127                            'got %r' % type(value)) 
    124128        self.__trust_root = value 
    125129 
    126  
    127130    def setOidRequest(self, value): 
     131        if not isinstance(value, CheckIDRequest): 
     132            raise TypeError('Expecting %r type for oidRequest attribute; ' 
     133                            'got %r' % (CheckIDRequest, type(value))) 
    128134        self.__oidRequest = value 
    129  
    130135 
    131136    def getSuccess_to(self): 
  • TI12-security/trunk/python/ndg_security_server/setup.cfg

    r5792 r6009  
    1515 
    1616[egg_info] 
    17 tag_build = rc2 
     17tag_build =  
    1818tag_svn_revision = true 
    1919 
  • TI12-security/trunk/python/ndg_security_server/setup.py

    r5961 r6009  
    2222_pkgDependencies = [ 
    2323    'ndg_security_common', 
    24     'Pylons <= 0.9.6.2', # TODO: drop Pylons dependency in future release 
    2524    'AuthKit', 
    2625    'MyProxyClient' 
     
    6463setup( 
    6564    name =                      'ndg_security_server', 
    66     version =                   '1.3.1', 
     65    version =                   '1.3.2', 
    6766    description =               'Server side components for running NERC DataGrid ' 
    6867                            'Security Services', 
     
    7574    license =               'BSD - See LICENCE file for details', 
    7675    install_requires =          _pkgDependencies, 
    77      
     76    
    7877    # Set ndg.security.common dependency 
    7978    dependency_links =      ["http://ndg.nerc.ac.uk/dist"], 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/__init__.py

    r5982 r6009  
    1818from os.path import expandvars, join, dirname, abspath 
    1919 
     20try: 
     21    from hashlib import md5 
     22except ImportError: 
     23    # Allow for < Python 2.5 
     24    from md5 import md5 
     25 
     26 
    2027TEST_CONFIG_DIR = join(abspath(dirname(dirname(__file__))), 'config') 
    2128 
     
    5461                                         "for unit tests") 
    5562     
     63    NDGSEC_TEST_CONFIG_DIR = os.environ.get(configDirEnvVarName,  
     64                                            TEST_CONFIG_DIR) 
     65     
    5666    # Test database set-up 
    5767    DB_FILENAME = 'user.db' 
    58     DB_CONNECTION_STR = 'sqlite:///%s' % DB_FILENAME 
     68    DB_FILEPATH = join(NDGSEC_TEST_CONFIG_DIR, DB_FILENAME) 
     69    DB_CONNECTION_STR = 'sqlite:///%s' % DB_FILEPATH 
     70     
    5971    USERNAME = 'pjk' 
     72    PASSWORD = 'testpassword' 
     73    MD5_PASSWORD = md5(PASSWORD).hexdigest() 
     74     
    6075    OPENID_URI_STEM = 'https://openid.localhost/' 
    6176    OPENID_IDENTIFIER = 'philip.kershaw' 
     77    OPENID_URI = OPENID_URI_STEM + OPENID_IDENTIFIER 
     78     
    6279    FIRSTNAME = 'Philip' 
    6380    LASTNAME = 'Kershaw' 
     
    135152            for service in self.services: 
    136153                service.terminateThread() 
     154  
     155    def initDb(self): 
     156        """Wrapper to _createDb - Create database only if it doesn't already  
     157        exist""" 
     158        if not os.path.isfile(BaseTestCase.DB_FILEPATH): 
     159            self._createDb() 
    137160             
    138161    def _createDb(self): 
     
    150173                           Column('id', Integer, primary_key=True), 
    151174                           Column('username', String), 
     175                           Column('md5password', String), 
    152176                           Column('openid_identifier', String), 
    153177                           Column('firstname', String), 
     
    166190            id = Column(Integer, primary_key=True) 
    167191            username = Column('username', String(40)) 
     192            md5password = Column('md5password', String(40)) 
    168193            openid_identifier = Column('openid_identifier', String(40)) 
    169194            firstname = Column('firstname', String(40)) 
     
    171196            emailAddress = Column('emailaddress', String(40)) 
    172197         
    173             def __init__(self, username, openid_identifier, firstname, 
    174                          lastname, emailaddress): 
     198            def __init__(self, username, md5password, openid_identifier,  
     199                         firstname, lastname, emailaddress): 
    175200                self.username = username 
     201                self.md5password = md5password 
    176202                self.openid_identifier = openid_identifier 
    177203                self.firstname = firstname 
     
    198224             
    199225        user = User(BaseTestCase.USERNAME,  
     226                    BaseTestCase.MD5_PASSWORD, 
    200227                    BaseTestCase.OPENID_IDENTIFIER, 
    201228                    BaseTestCase.FIRSTNAME, 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthority/test_attributeauthority.py

    r5982 r6009  
    292292                       ] = os.path.abspath(os.path.dirname(__file__)) 
    293293             
    294         if not os.path.exists(mkPath('user.db')): 
    295             self._createDb() 
     294        self.initDb() 
    296295         
    297296    def test01TrySamlAttribute2SqlQuery__setattr__(self): 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_attributeauthorityclient.py

    r5982 r6009  
    2828from ndg.security.common.utils.etree import prettyPrint 
    2929 
    30 from ndg.security.common.attributeauthority import AttributeAuthorityClient, \ 
    31     NoMatchingRoleInTrustedHosts 
     30from ndg.security.common.attributeauthority import (AttributeAuthorityClient,  
     31                                                NoMatchingRoleInTrustedHosts) 
    3232from ndg.security.common.AttCert import AttCertRead 
    3333from ndg.security.common.X509 import X509CertParse, X509CertRead 
    34 from ndg.security.common.utils.configfileparsers import \ 
    35     CaseSensitiveConfigParser 
     34from ndg.security.common.utils.configfileparsers import ( 
     35    CaseSensitiveConfigParser) 
    3636 
    3737from saml.common.xml import SAMLConstants 
    38 from saml.saml2.core import Response, Assertion, Attribute, AttributeValue, \ 
    39     AttributeStatement, SAMLVersion, Subject, NameID, Issuer, AttributeQuery, \ 
    40     XSStringAttributeValue, XSGroupRoleAttributeValue, Conditions, Status, \ 
    41     StatusCode 
     38from saml.saml2.core import (Attribute, SAMLVersion, Subject, NameID, Issuer,  
     39                             AttributeQuery, XSStringAttributeValue, StatusCode) 
    4240from saml.xml.etree import ResponseElementTree 
    43     
     41 
    4442from ndg.security.common.saml.bindings import SOAPBinding as SamlSoapBinding 
    45 from ndg.security.common.saml.esg import EsgSamlNamespaces 
     43from ndg.security.common.saml.esg import (EsgSamlNamespaces,  
     44                                          XSGroupRoleAttributeValue) 
    4645 
    4746 
     
    5150 
    5251        if 'NDGSEC_AACLNT_UNITTEST_DIR' not in os.environ: 
    53             os.environ['NDGSEC_AACLNT_UNITTEST_DIR'] = \ 
    54                 os.path.abspath(os.path.dirname(__file__)) 
     52            os.environ['NDGSEC_AACLNT_UNITTEST_DIR' 
     53                       ] = os.path.abspath(os.path.dirname(__file__)) 
    5554 
    5655        self.cfgParser = CaseSensitiveConfigParser() 
     
    6463 
    6564        try: 
    66             self.sslCACertList = [X509CertRead(xpdVars(caFile)) for caFile in \ 
    67                          self.cfg['setUp']['sslcaCertFilePathList'].split()] 
     65            self.sslCACertList = [X509CertRead(xpdVars(caFile))  
     66                                  for caFile in self.cfg['setUp'][ 
     67                                            'sslcaCertFilePathList'].split()] 
    6868        except KeyError: 
    6969            self.sslCACertList = [] 
     
    8484        x509CertList = pemPatRE.findall(proxyCertFileTxt) 
    8585         
    86         signingCertChain = [X509CertParse(x509Cert) for x509Cert in \ 
    87                             x509CertList] 
     86        signingCertChain = [X509CertParse(x509Cert)  
     87                            for x509Cert in x509CertList] 
    8888     
    8989        # Expecting proxy cert first - move this to the end.  This will 
     
    117117        """test02GetTrustedHostInfo: retrieve trusted host info matching a 
    118118        given role""" 
    119         trustedHostInfo = self.siteAClnt.getTrustedHostInfo(\ 
     119        trustedHostInfo = self.siteAClnt.getTrustedHostInfo( 
    120120                                 self.cfg['test02GetTrustedHostInfo']['role']) 
    121121        for hostname, hostInfo in trustedHostInfo.items(): 
     
    136136             
    137137        except NoMatchingRoleInTrustedHosts, e: 
    138             print 'As expected - no match for role "%s": %s' % \ 
    139                 (_cfg['role'], e) 
     138            print('As expected - no match for role "%s": %s' %  
     139                  (_cfg['role'], e)) 
    140140 
    141141 
     
    178178                 
    179179        except IOError, ioErr: 
    180             raise Exception("Error reading certificate file \"%s\": %s" % \ 
    181                                     (ioErr.filename, ioErr.strerror)) 
     180            raise Exception("Error reading certificate file \"%s\": %s" %  
     181                            (ioErr.filename, ioErr.strerror)) 
    182182 
    183183        # Make attribute certificate request 
     
    206206                 
    207207        except IOError, ioErr: 
    208             raise Exception("Error reading certificate file \"%s\": %s" % \ 
    209                                     (ioErr.filename, ioErr.strerror)) 
     208            raise Exception("Error reading certificate file \"%s\": %s" %  
     209                            (ioErr.filename, ioErr.strerror)) 
    210210 
    211211        # Make attribute certificate request 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/config.ini

    r5935 r6009  
    1010# BSD - See LICENCE file for details 
    1111[DEFAULT] 
    12 connectionString = sqlite:///user.db 
     12connectionString = sqlite:///$NDGSEC_TEST_CONFIG_DIR/user.db 
    1313openIdSqlQuery = select openid_identifier from users where username = '${username}'      
    1414identityUriTemplate = https://openid.localhost/${userIdentifier} 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/test_saml_attribute_assertion.py

    r5961 r6009  
    2828class CertExtAppTestCase(BaseTestCase): 
    2929    THIS_DIR = os.path.dirname(__file__) 
    30     USERNAME = 'pjk' 
    31     OPENID_IDENTIFIER = 'philip.kershaw' 
    3230    OPENID_TMPL = "https://openid.localhost/${userIdentifier}" 
    3331    OPENID = Template(OPENID_TMPL).substitute( 
    34                                         dict(userIdentifier=OPENID_IDENTIFIER)) 
     32                        {'userIdentifier': BaseTestCase.OPENID_IDENTIFIER}) 
    3533    OPENID_SQL_QUERY = ("select openid_identifier from users where username " 
    3634                        "= '${username}'")  
    37      
    38     DB_FILENAME = 'user.db' 
    39     DB_CONNECTION_STR = 'sqlite:///%s' % DB_FILENAME 
    40      
     35         
    4136    def __init__(self, *arg, **kw): 
    4237        super(CertExtAppTestCase, self).__init__(*arg, **kw)             
    4338        self.startSiteAAttributeAuthority() 
    44          
    45         if not os.path.isfile(os.path.join(CertExtAppTestCase.THIS_DIR, 
    46                                            CertExtAppTestCase.DB_FILENAME)): 
    47             self._createDb() 
    48          
    49     def _createDb(self): 
    50         db = create_engine(CertExtAppTestCase.DB_CONNECTION_STR) 
    51          
    52         metadata = MetaData() 
    53         table = Table('users', metadata, 
    54                       Column('id', Integer, primary_key=True), 
    55                       Column('username', String), 
    56                       Column('openid_identifier', String)) 
    57         metadata.create_all(db) 
    58          
    59         class User(declarative_base()): 
    60             __tablename__ = 'users' 
    61          
    62             id = Column(Integer, primary_key=True) 
    63             username = Column('username', String(40)) 
    64             openid_identifier = Column('openid_identifier', String(40)) 
    65          
    66             def __init__(self, username, openid_identifier): 
    67                 self.username = username 
    68                 self.openid_identifier = openid_identifier 
    69          
    70         user = User(CertExtAppTestCase.USERNAME,  
    71                     CertExtAppTestCase.OPENID_IDENTIFIER) 
    72          
    73         Session = sessionmaker(bind=db) 
    74         session = Session() 
    75         session.add(user) 
    76         session.commit() 
     39        self.initDb() 
    7740         
    7841    def test01DbQuery(self): 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/openid/provider/authninterface/test_authninterface.py

    r6008 r6009  
    1010__revision__ = '$Id$' 
    1111from os import path 
    12          
     12import unittest 
     13       
    1314from ndg.security.test.unit import BaseTestCase 
    1415from ndg.security.server.wsgi.openid.provider.authninterface import ( 
     
    1819 
    1920 
    20  
    2121class SQLAlchemyAuthnInterfaceTestCase(BaseTestCase): 
    22     DB_FILEPATH = path.join(path.dirname(__file__), BaseTestCase.DB_FILENAME) 
    23      
    2422    LOGON_SQLQUERY = ("select count(*) from users where username = " 
    2523                      "'${username}' and md5password = '${password}'") 
     
    3230        self.__interface = None 
    3331         
    34         if not path.exists(SQLAlchemyAuthnInterfaceTestCase.DB_FILEPATH): 
    35             self._createDb() 
     32        self.initDb() 
    3633          
    3734    def setUp(self): 
     
    5350        self.__interface.username2UserIdentifiers({},  
    5451                               SQLAlchemyAuthnInterfaceTestCase.USERNAME) 
     52         
     53                                                         
     54if __name__ == "__main__": 
     55    unittest.main() 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/openid/provider/axinterface/test_axinterface.py

    r6008 r6009  
    2727        super(SQLAlchemyAXInterfaceTestCase, self).__init__(*arg, **kw) 
    2828         
    29         if not path.exists(SQLAlchemyAXInterfaceTestCase.DB_FILEPATH): 
    30             self._createDb() 
     29        self.initDb() 
    3130             
    3231    def test01InvalidQueryUsernameKey(self): 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/saml/test_samlinterface.py

    r5982 r6009  
    1414 
    1515from datetime import datetime, timedelta 
    16 import base64  
    1716import os 
    1817from uuid import uuid4 
     
    2827from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
    2928 
     29from ndg.security.common.soap.client import (UrlLib2SOAPClient,  
     30                                             UrlLib2SOAPRequest) 
    3031from ndg.security.common.soap.etree import SOAPEnvelope 
    3132from ndg.security.common.utils.etree import QName, prettyPrint 
     
    3435from ndg.security.common.saml.esg.xml.etree import ( 
    3536                                        XSGroupRoleAttributeValueElementTree) 
     37from ndg.security.test.unit import BaseTestCase 
     38 
    3639 
    3740class SamlSoapBindingApp(object): 
     
    154157 
    155158         
    156 class SamlAttributeAuthorityInterfaceTestCase(unittest.TestCase): 
     159class SamlAttributeAuthorityInterfaceTestCase(BaseTestCase): 
    157160    """TODO: test SAML Attribute Authority interface""" 
    158161    thisDir = os.path.dirname(os.path.abspath(__file__)) 
     
    162165        self.app = paste.fixture.TestApp(wsgiApp) 
    163166          
    164         unittest.TestCase.__init__(self, *args, **kwargs) 
     167        BaseTestCase.__init__(self, *args, **kwargs) 
    165168         
    166169 
     
    245248       
    246249    def test02AttributeQueryWithSOAPClient(self): 
    247         from ndg.security.common.soap.client import UrlLib2SOAPClient, \ 
    248             UrlLib2SOAPRequest 
    249              
     250             
     251        # Thread a separate attribute authority instance 
     252        self.startSiteAAttributeAuthority() 
     253           
    250254        client = UrlLib2SOAPClient() 
    251255         
     
    339343            <saml:Issuer Format="urn:esg:issuer">ESG-NCAR</saml:Issuer> 
    340344            <saml:Subject> 
    341                <saml:NameID Format=EsgSamlNamespaces.NAMEID_FORMAT>https://esg.prototype.ucar.edu/myopenid/testUser</saml:NameID> 
     345               <saml:NameID Format="urn:esg:openid">https://esg.prototype.ucar.edu/myopenid/testUser</saml:NameID> 
    342346            </saml:Subject> 
    343347            <saml:Conditions NotBefore="2009-08-17T12:28:37.347Z" NotOnOrAfter="2009-08-18T12:28:37.347Z" /> 
  • TI12-security/trunk/python/ndg_security_test/setup.cfg

    r5792 r6009  
    99# BSD - See LICENCE file for details 
    1010[egg_info] 
    11 tag_build = rc2 
     11tag_build =  
    1212tag_svn_revision = true 
    1313 
  • TI12-security/trunk/python/ndg_security_test/setup.py

    r5961 r6009  
    2020setup( 
    2121    name =                      'ndg_security_test', 
    22     version =                   '1.3.1', 
     22    version =                   '1.3.2', 
    2323    description =               'NERC DataGrid Security Unit tests', 
    2424    long_description =          'Unit tests client - server side', 
Note: See TracChangeset for help on using the changeset viewer.