Changeset 5774


Ignore:
Timestamp:
28/09/09 17:15:41 (10 years ago)
Author:
pjkersha
Message:

Added a wrapper class to Paste Deploy httpserver to enable automated setup and teardown of services for unit tests.

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

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/__init__.py

    r5770 r5774  
    2727    USERNAME_ENVIRON_KEYNAME = 'REMOTE_USER' 
    2828    USERDATA_ENVIRON_KEYNAME = 'REMOTE_USER_DATA' 
     29    USERNAME_SESSION_KEYNAME = 'username' 
    2930     
    3031    propertyDefaults = { 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/authn.py

    r5770 r5774  
    2727 
    2828 
    29 class AuthenticationMiddlewareBase(NDGSecurityMiddlewareBase): 
     29class SessionMiddlewareBase(NDGSecurityMiddlewareBase): 
    3030    """Base class for Authentication redirect middleware and Session Handler 
    3131    middleware 
     
    3737        'sessionKey': 'beaker.session.ndg.security' 
    3838    } 
    39     USERNAME_SESSION_KEYNAME = 'username' 
    40      
     39    
    4140    _isAuthenticated = lambda self: \ 
    42         AuthenticationMiddlewareBase.USERNAME_SESSION_KEYNAME in \ 
     41        SessionMiddlewareBase.USERNAME_SESSION_KEYNAME in \ 
    4342        self.environ.get(self.sessionKey, ()) 
    4443         
     
    4746 
    4847         
    49 class AuthnRedirectMiddleware(AuthenticationMiddlewareBase): 
     48class AuthnRedirectMiddleware(SessionMiddlewareBase): 
    5049    """Base class for Authentication HTTP redirect initiator and redirect 
    5150    response WSGI middleware 
     
    229228     
    230229     
    231 class SessionHandlerMiddleware(AuthenticationMiddlewareBase): 
    232     '''Middleware to handle: 
     230class SessionHandlerMiddleware(SessionMiddlewareBase): 
     231    '''Middleware to: 
    233232    - establish user session details following redirect from OpenID Relying  
    234233    Party sign-in or SSL Client authentication 
     
    243242     
    244243    SESSION_KEYNAMES = ( 
    245         AuthenticationMiddlewareBase.USERNAME_SESSION_KEYNAME,  
     244        SessionMiddlewareBase.USERNAME_SESSION_KEYNAME,  
    246245        SM_URI_SESSION_KEYNAME,  
    247246        ID_SESSION_KEYNAME,  
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/authz.py

    r5766 r5774  
    1313from time import time 
    1414from urlparse import urlunsplit 
     15from httplib import UNAUTHORIZED, FORBIDDEN 
    1516 
    1617from ndg.security.common.utils.classfactory import importClass 
     
    2122from ndg.security.server.wsgi import NDGSecurityMiddlewareBase, \ 
    2223    NDGSecurityMiddlewareConfigError 
     24from ndg.security.server.wsgi.authn import SessionMiddlewareBase 
    2325 
    2426from ndg.security.common.authz.msi import Policy, PIP, PDP, Request, \ 
    2527    Response, Resource, Subject 
    2628 
    27 class PEPResultHandlerMiddleware(NDGSecurityMiddlewareBase): 
     29class PEPResultHandlerMiddleware(SessionMiddlewareBase): 
    2830    """This middleware is invoked if access is denied to a given resource.  It 
    2931    is incorporated into the call stack by passing it in to a MultiHandler  
     
    3638    denied response e.g. include an interface to enable users to register for 
    3739    the dataset from which they have been denied access.  See  
    38     AuthorizationMiddleware pepResultHandler keyword 
     40    AuthorizationMiddleware pepResultHandler keyword. 
     41     
     42    SessionMiddlewareBase base class defines user session key and  
     43    isAuthenticated property 
    3944    """ 
    40     propertyDefaults = { 
    41         'sessionKey': 'beaker.session.ndg.security' 
    42     } 
    43  
    44     _isAuthenticated = lambda self: \ 
    45                             'username' in self.environ.get(self.sessionKey,()) 
    46     isAuthenticated = property(fget=_isAuthenticated, 
    47                                doc='boolean to indicate is user logged in') 
    48  
     45     
    4946    def __init__(self, app, global_conf, prefix='', **app_conf): 
    5047        ''' 
     
    7572            log.warning("PEPResultHandlerMiddleware: user is not " 
    7673                        "authenticated - setting HTTP 401 response") 
    77             return self._setErrorResponse(code=401) 
     74            return self._setErrorResponse(code=UNAUTHORIZED) 
    7875        else: 
    7976            # Get response message from PDP recorded by PEP 
     
    8279            msg = getattr(pdpResponse, 'message', '') 
    8380                 
    84             response = \ 
    85 """Access is forbidden for this resource: 
    86 %s 
    87 Please check with your site administrator that you have the required access privileges. 
    88 """ % msg.join('\n'*2) 
    89  
    90             return self._setErrorResponse(code=403, msg=response) 
     81            response = ("Access is forbidden for this resource:%s" 
     82                        "Please check with your site administrator that you " 
     83                        "have the required access privileges." %  
     84                        msg.join('\n\n'*2)) 
     85 
     86            return self._setErrorResponse(code=FORBIDDEN, msg=response) 
    9187 
    9288 
     
    9793    """Configuration related error for PEPFilter""" 
    9894 
    99 class PEPFilter(NDGSecurityMiddlewareBase): 
     95class PEPFilter(SessionMiddlewareBase): 
    10096    """PEP (Policy Enforcement Point) WSGI Middleware.  The PEP enforces 
    10197    access control decisions made by the PDP (Policy Decision Point).  In  
     
    104100    access denied decision is made, the PEP enforces this by returning a  
    105101    403 Forbidden HTTP response without the application middleware executing 
     102     
     103    SessionMiddlewareBase base class defines user session key and  
     104    isAuthenticated property 
    106105    """ 
    107     TRIGGER_HTTP_STATUS_CODE = '403' 
     106    TRIGGER_HTTP_STATUS_CODE = str(FORBIDDEN) 
    108107    MIDDLEWARE_ID = 'PEPFilter' 
    109      
    110     propertyDefaults = { 
    111         'sessionKey': 'beaker.session.ndg.security' 
    112     } 
    113  
    114     _isAuthenticated = lambda self: \ 
    115                             'username' in self.environ.get(self.sessionKey,()) 
    116     isAuthenticated = property(fget=_isAuthenticated, 
    117                                doc='boolean to indicate is user logged in') 
    118  
     108    POLICY_PARAM_PREFIX = 'policy.' 
     109    SESSION_KEYNAME = 'sessionKey' 
     110    POLICY_FILEPATH_PARAMNAME = 'filePath' 
     111     
    119112    def __init__(self, app, global_conf, prefix='', **local_conf): 
    120113        """Initialise the PIP (Policy Information Point) and PDP (Policy  
     
    135128        """        
    136129        # Initialise the PDP reading in the policy 
    137         policyCfg = PEPFilter._filterKeywords(local_conf, 'policy.') 
    138         self.policyFilePath = policyCfg['filePath'] 
    139         policy = Policy.Parse(policyCfg['filePath']) 
     130        policyCfg = PEPFilter._filterKeywords(local_conf,  
     131                                              PEPFilter.POLICY_PARAM_PREFIX) 
     132        self.policyFilePath = policyCfg[PEPFilter.POLICY_FILEPATH_PARAMNAME] 
     133        policy = Policy.Parse(policyCfg[PEPFilter.POLICY_FILEPATH_PARAMNAME]) 
    140134         
    141135        # Initialise the Policy Information Point to None.  This object is 
     
    143137        self.pdp = PDP(policy, None) 
    144138         
    145         self.sessionKey = local_conf.get('sessionKey',  
    146                                      PEPFilter.propertyDefaults['sessionKey']) 
     139        self.sessionKey = local_conf.get(PEPFilter.SESSION_KEYNAME,  
     140                                         PEPFilter.propertyDefaults[ 
     141                                                    PEPFilter.SESSION_KEYNAME]) 
    147142         
    148143        super(PEPFilter, self).__init__(app, 
     
    151146                                        **local_conf) 
    152147 
    153          
    154148    @NDGSecurityMiddlewareBase.initCall 
    155149    def __call__(self, environ, start_response): 
     
    162156        @return: response 
    163157        """ 
    164          
    165         log.debug("PEPFilter.__call__ ...") 
    166          
    167158        session = environ.get(self.sessionKey) 
    168159        if session is None: 
     
    177168        targetMatch = len(matchingTargets) > 0 
    178169        if not targetMatch: 
    179             log.info("PEPFilter.__call__: granting access - no matching URI " 
    180                      "path target was found in the policy for URI path [%s]",  
    181                      resourceURI) 
     170            log.debug("PEPFilter.__call__: granting access - no matching URI " 
     171                      "path target was found in the policy for URI path [%s]",  
     172                      resourceURI) 
    182173            return self._app(environ, start_response) 
    183174 
    184         log.info("PEPFilter.__call__: found matching target(s):\n\n %s\n" 
    185                  "\nfrom policy file [%s] for URI Path=[%s]\n", 
    186                  '\n'.join(["RegEx=%s" % t for t in matchingTargets]),  
    187                  self.policyFilePath, 
    188                  resourceURI) 
     175        log.debug("PEPFilter.__call__: found matching target(s):\n\n %s\n" 
     176                  "\nfrom policy file [%s] for URI Path=[%s]\n", 
     177                  '\n'.join(["RegEx=%s" % t for t in matchingTargets]),  
     178                  self.policyFilePath, 
     179                  resourceURI) 
    189180         
    190181        if not self.isAuthenticated: 
     
    193184             
    194185            # Set a 401 response for an authentication handler to capture 
    195             return self._setErrorResponse(code=401) 
     186            return self._setErrorResponse(code=UNAUTHORIZED) 
    196187         
    197188        log.debug("PEPFilter.__call__: creating request to call PDP to check " 
     
    224215         
    225216        if response.status == Response.DECISION_PERMIT: 
    226             log.debug("PEPFilter: PDP granted access for URI path [%s] " 
    227                       "using policy [%s]", resourceURI, self.policyFilePath) 
     217            log.info("PEPFilter.__call__: PDP granted access for URI path " 
     218                     "[%s] using policy [%s]",  
     219                     resourceURI,  
     220                     self.policyFilePath) 
    228221             
    229222            return self._app(environ, start_response) 
    230223        else: 
    231             log.info("PEPFilter: PDP returned a status of [%s] " 
     224            log.info("PEPFilter.__call__: PDP returned a status of [%s] " 
    232225                     "denying access for URI path [%s] using policy [%s]",  
    233226                     response.decisionValue2String[response.status], 
     
    236229             
    237230            # Trigger AuthZResultHandlerMiddleware by setting a response  
    238             # with HTTP status code equal to the TRIGGER_HTTP_STATUS_CODE class attribute 
    239             # value 
    240             return self._setErrorResponse(code=int(PEPFilter.TRIGGER_HTTP_STATUS_CODE)) 
     231            # with HTTP status code equal to the TRIGGER_HTTP_STATUS_CODE class 
     232            # attribute value 
     233            triggerStatusCode = int(PEPFilter.TRIGGER_HTTP_STATUS_CODE) 
     234            return self._setErrorResponse(code=triggerStatusCode) 
    241235 
    242236    def _getMatchingTargets(self, resourceURI): 
     
    277271             
    278272            if status.startswith(PEPFilter.TRIGGER_HTTP_STATUS_CODE): 
    279                 log.info("PEPFilter: found [%s] status for URI path [%s]: " 
    280                          "invoking access denied response", 
    281                          PEPFilter.TRIGGER_HTTP_STATUS_CODE, 
    282                          environ['PATH_INFO']) 
     273                log.debug("PEPFilter: found [%s] status for URI path [%s]: " 
     274                          "invoking access denied response", 
     275                          PEPFilter.TRIGGER_HTTP_STATUS_CODE, 
     276                          environ['PATH_INFO']) 
    283277                return True 
    284278            else: 
     
    479473    ndg.security.server.wsgi.authn.AuthenticationMiddleware 
    480474    ''' 
     475    PEP_PARAM_PREFIX = 'pep.filter.' 
     476    PIP_PARAM_PREFIX = 'pip.' 
     477    PEP_RESULT_HANDLER_PARAMNAME = "pepResultHandler" 
    481478     
    482479    def __init__(self, app, global_conf, prefix='', **app_conf): 
     
    496493        dictionary 
    497494        """ 
    498          
     495        authzPrefix = prefix + AuthorizationMiddleware.PEP_PARAM_PREFIX 
    499496        pepFilter = PEPFilter(app, 
    500497                              global_conf, 
    501                               prefix=prefix+'pep.filter.', 
     498                              prefix=authzPrefix, 
    502499                              **app_conf) 
    503500        pepInterceptFunc = pepFilter.multiHandlerInterceptFactory() 
     
    506503        # so that it can take a copy of the beaker session object from environ 
    507504        # ahead of the PDP's request to it for an Attribute Certificate 
     505        pipPrefix = AuthorizationMiddleware.PIP_PARAM_PREFIX 
    508506        pipFilter = PIPMiddleware(pepFilter, 
    509507                                  global_conf, 
    510                                   prefix='pip.', 
     508                                  prefix=pipPrefix, 
    511509                                  **app_conf) 
    512510        pepFilter.pdp.pip = pipFilter 
     
    514512        app = MultiHandler(pipFilter) 
    515513 
    516         pepResultHandlerClassName = app_conf.pop(prefix+"pepResultHandler",  
    517                                                  None)  
     514        pepResultHandlerClassName = app_conf.pop( 
     515                prefix+AuthorizationMiddleware.PEP_RESULT_HANDLER_PARAMNAME,  
     516                None) 
    518517        if pepResultHandlerClassName is None: 
    519518            pepResultHandler = PEPResultHandlerMiddleware 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/ssl.py

    r5771 r5774  
    271271                                          msg='No client SSL Certificate set') 
    272272             
    273         if self.isValidClientCert():             
     273        if self.isValidClientCert(): 
     274            self._setUser()           
    274275            return self._setResponse() 
    275276        else: 
     
    343344             
    344345        if len(self.clientCertDNMatchList) > 0: 
    345             if self.__clientCert.dn not in self.clientCertDNMatchList: 
    346                 return False 
     346            dn = self.__clientCert.dn 
     347            for expectedDN in self.clientCertDNMatchList:  
     348                if dn == expectedDN: 
     349                    return True 
     350                 
     351            return False 
    347352             
    348353        return True 
    349      
     354 
     355    def _setUser(self): 
     356        """Interface hook for a derived class to set user ID from certificate  
     357        set or other context info. 
     358        """ 
     359 
    350360 
    351361class AuthKitSSLAuthnMiddleware(ApacheSSLAuthnMiddleware): 
     
    353363    flag logged in status to other middleware 
    354364    """ 
     365    SET_USER_ENVIRON_KEYNAME = 'paste.auth_tkt.set_user' 
     366     
    355367    @NDGSecurityMiddlewareBase.initCall          
    356368    def __call__(self, environ, start_response): 
     
    384396             
    385397        elif self.isValidClientCert(): 
    386             # Update environ so that downstream AuthenticationMiddleware can 
    387             # set the session cookie 
    388             environ['REMOTE_USER'] = self.clientCert.dn['CN'] 
    389             environ['paste.auth_tkt.set_user'](environ['REMOTE_USER']) 
    390              
    391             # Set-up redirect back to original request URI 
    392         else: 
    393             # IsValidCert will log warnings/errors no need to flag this 
    394             # condition 
    395             pass 
     398            # Update session cookie with user ID 
     399            self._setUser() 
     400             
     401        # ... isValidCert will log warnings/errors no need to flag the False 
     402        # condition 
    396403             
    397404        # Pass request to next middleware in the chain without setting an 
    398405        # error response - see method doc string for explanation. 
    399406        return self._setResponse() 
     407 
     408    def _setUser(self): 
     409        """Set user ID in AuthKit cookie from client certificate submitted 
     410        """ 
     411        userId = self.clientCert.dn['CN'] 
     412         
     413        self.environ[AuthKitSSLAuthnMiddleware.USERNAME_ENVIRON_KEYNAME]=userId 
     414        self.environ[AuthKitSSLAuthnMiddleware.SET_USER_ENVIRON_KEYNAME](userId) 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservices.ini

    r5771 r5774  
    104104prefix = ssl. 
    105105ssl.caCertFilePathList = %(testConfigDir)s/ca/ndg-test-ca.crt 
    106  
    107 # HTTP_ prefix is set when passed through a proxy 
     106#ssl.clientCertDNMatchList = /O=NDG/OU=BADC/CN=mytest /O=gabriel/OU=BADC/CN=test /O=NDG/OU=BADC/CN=test 
     107 
     108# 'HTTP_' prefix is set when passed through a proxy 
    108109ssl.sslKeyName = HTTP_HTTPS 
    109110ssl.sslClientCertKeyName = HTTP_SSL_CLIENT_CERT 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservicesapp.py

    r5739 r5774  
    1313from os.path import dirname, abspath, join 
    1414 
    15      
     15from ndg.security.test.unit.wsgi import PasteDeployAppServer 
     16 
    1617# To start run  
    1718# $ paster serve services.ini or run this file as a script 
     
    1920if __name__ == '__main__': 
    2021    import sys 
    21     import logging 
    22     logging.basicConfig(level=logging.DEBUG) 
    23  
    2422    if len(sys.argv) > 1: 
    2523        port = int(sys.argv[1]) 
     
    2725        port = 7443 
    2826         
    29     cfgFilePath = os.path.join(dirname(abspath(__file__)),  
    30                                'securityservices.ini') 
    31          
    32     from paste.httpserver import serve 
    33     from paste.deploy import loadapp 
    34     from paste.script.util.logging_config import fileConfig 
    35      
    36     fileConfig(cfgFilePath) 
    37     app = loadapp('config:%s' % cfgFilePath) 
    38     serve(app, host='0.0.0.0', port=port) 
     27    cfgFileName='securityservices.ini' 
     28    cfgFilePath = os.path.join(dirname(abspath(__file__)), cfgFileName)     
     29    server = PasteDeployAppServer(cfgFilePath, port=port)  
     30    server.start() 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/__init__.py

    r5499 r5774  
    1212import unittest 
    1313import logging 
     14import socket 
    1415logging.basicConfig() 
    1516 
     
    1920TEST_CONFIG_DIR = join(abspath(dirname(dirname(__file__))), 'config') 
    2021 
     22mkDataDirPath = lambda file:join(TEST_CONFIG_DIR, file) 
     23 
     24from ndg.security.test.unit.wsgi import PasteDeployAppServer 
     25 
    2126class BaseTestCase(unittest.TestCase): 
    2227    '''Convenience base class from which other unit tests can extend.  Its 
    2328    sets the generic data directory path''' 
    2429    configDirEnvVarName = 'NDGSEC_TEST_CONFIG_DIR' 
     30     
     31    mkDataDirPath = staticmethod(mkDataDirPath) 
    2532     
    2633    def __init__(self, *arg, **kw): 
     
    2936                 
    3037        unittest.TestCase.__init__(self, *arg, **kw) 
     38        self.services = [] 
     39         
     40    def addService(self, cfgFilePath, port): 
     41        """Utility for setting up threads to run Paste HTTP based services with 
     42        unit tests 
     43         
     44        @param cfgFilePath: ini file containing configuration for the service 
     45        @type cfgFilePath: basestring 
     46        @param port: port number to run the service from 
     47        @type port: int 
     48        """ 
     49        try: 
     50            self.services.append(PasteDeployAppServer(cfgFilePath, port=port)) 
     51            self.services[-1].startThread() 
     52             
     53        except socket.error: 
     54            pass 
    3155 
    32 mkDataDirPath = lambda file:join(TEST_CONFIG_DIR, file) 
     56    def startAttributeAuthorities(self): 
     57        """Serve test Attribute Authorities to test against""" 
     58        siteACfgFilePath = mkDataDirPath(join('attributeauthority',  
     59                                              'sitea',  
     60                                              'site-a.ini')) 
     61        self.addService(siteACfgFilePath, 5000) 
     62         
     63        siteBCfgFilePath = mkDataDirPath(join('attributeauthority', 
     64                                              'siteb',  
     65                                              'site-b.ini')) 
     66        self.addService(siteBCfgFilePath, 5100)         
     67         
    3368 
     69    def __del__(self): 
     70        """Stop any services started with the addService method""" 
     71        if hasattr(self, 'services'): 
     72            for service in self.services: 
     73                service.terminateThread() 
     74             
    3475def _getParentDir(depth=0, path=dirname(__file__)): 
    3576    """ 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_attributeauthorityclient.py

    r5741 r5774  
    2424from xml.etree import ElementTree 
    2525 
    26 from ndg.security.test.unit import BaseTestCase 
     26from ndg.security.test.unit import BaseTestCase, mkDataDirPath 
    2727 
    2828from ndg.security.common.utils.etree import prettyPrint 
     
    4444from ndg.security.common.saml.bindings import SOAPBinding as SamlSoapBinding 
    4545 
     46 
    4647class AttributeAuthorityClientBaseTestCase(BaseTestCase): 
    4748    def __init__(self, *arg, **kw): 
     
    6667        except KeyError: 
    6768            self.sslCACertList = [] 
    68  
     69             
     70        self.startAttributeAuthorities()         
     71       
    6972       
    7073class AttributeAuthorityClientTestCase(AttributeAuthorityClientBaseTestCase): 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/credentialwallet/test_credentialwallet.py

    r5648 r5774  
    3636    class. 
    3737    """ 
     38    def __init__(self, *arg, **kw): 
     39        super(CredentialWalletTestCase, self).__init__(*arg, **kw) 
     40        self.startAttributeAuthorities() 
    3841     
    3942    def setUp(self): 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/nosetests.ini

    r5712 r5774  
    1414[nosetests] 
    1515verbosity: 3 
    16 tests: ndg.security.test.unit.x509.test_x509, 
    17         ndg.security.test.unit.soap.test_soap, 
    18         ndg.security.test.unit.configfileparsers.test_configfileparsers, 
     16tests: 
     17#tests: ndg.security.test.unit.x509.test_x509, 
     18#       ndg.security.test.unit.soap.test_soap, 
     19#       ndg.security.test.unit.configfileparsers.test_configfileparsers, 
    1920        ndg.security.test.unit.credentialwallet.test_credentialwallet, 
    20         ndg.security.test.unit.xacml.test_xacml, 
    21         ndg.security.test.unit.attributeauthorityclient.test_attributeauthorityclient, 
    22         ndg.security.test.unit.sessionmanager.test_sessionmanager, 
    23         ndg.security.test.unit.authz.pdp.test_proftp_pdp, 
    24 #       ./sslclientauthnmiddleware/test_sslclientauthn.py, 
    25         ndg.security.test.unit.openid.relyingparty.validation.test_validation, 
    26         ndg.security.test.unit.xmlsec.etree.test_etree, 
    27 #       ./wsgi/authn/test_authn.py, 
    28 #       ./wsgi/ssl/test_ssl.py, 
    29         ndg.security.test.unit.wsgi.authz.test_authz, 
    30         ndg.security.test.unit.sessionmanagerclient.test_sessionmanagerclient, 
    31         ndg.security.test.unit.attributeauthority.test_attributeauthority, 
    32         ndg.security.test.unit.saml.test_samlinterface, 
    33         ndg.security.test.unit.wssecurity.foursuite.client.test_echoclient.py, 
    34         ndg.security.test.unit.wssecurity.dom.client.test_echoclient.py 
     21#       ndg.security.test.unit.xacml.test_xacml, 
     22        ./attributeauthorityclient.test_attributeauthorityclient.py 
     23#       ndg.security.test.unit.sessionmanager.test_sessionmanager, 
     24#       ndg.security.test.unit.authz.pdp.test_proftp_pdp, 
     25##      ./sslclientauthnmiddleware/test_sslclientauthn.py, 
     26#       ndg.security.test.unit.openid.relyingparty.validation.test_validation, 
     27#       ndg.security.test.unit.xmlsec.etree.test_etree, 
     28##      ./wsgi/authn/test_authn.py, 
     29##      ./wsgi/ssl/test_ssl.py, 
     30#       ndg.security.test.unit.wsgi.authz.test_authz, 
     31#       ndg.security.test.unit.sessionmanagerclient.test_sessionmanagerclient, 
     32#       ndg.security.test.unit.attributeauthority.test_attributeauthority, 
     33#       ndg.security.test.unit.saml.test_samlinterface, 
     34#       ndg.security.test.unit.wssecurity.foursuite.client.test_echoclient.py, 
     35#       ndg.security.test.unit.wssecurity.dom.client.test_echoclient.py 
    3536 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/nosetests.py

    r5292 r5774  
    33Suite to wrap all granulator test cases 
    44 
    5 NERC Data Grid Project 
     5NERC DataGrid Project 
    66 
    77""" 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/wsgi/__init__.py

    r5015 r5774  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id$' 
     11 
     12import paste.httpserver 
     13from threading import Thread 
     14from paste.deploy import loadapp 
     15from paste.script.util.logging_config import fileConfig 
     16 
     17import logging 
     18logging.basicConfig(level=logging.DEBUG) 
     19 
     20class PasteDeployAppServer(object): 
     21    """Wrapper to paste.httpserver to enable background threading""" 
     22     
     23    def __init__(self, cfgFilePath, port=7443, host='0.0.0.0'): 
     24        """Load an application configuration from cfgFilePath ini file and  
     25        instantiate Paste server object 
     26        """        
     27        self.__thread = None 
     28        fileConfig(cfgFilePath) 
     29        app = loadapp('config:%s' % cfgFilePath) 
     30        self.__pasteServer = paste.httpserver.serve(app, host=host, port=port,  
     31                                                    start_loop=False) 
     32     
     33    def _getPasteServer(self): 
     34        return self.__pasteServer 
     35     
     36    pasteServer = property(fget=_getPasteServer) 
     37     
     38    def _getThread(self): 
     39        return self.__thread 
     40     
     41    thread = property(fget=_getThread) 
     42     
     43    def start(self): 
     44        """Start server""" 
     45        self.pasteServer.serve_forever() 
     46         
     47    def startThread(self): 
     48        """Start server in a separate thread""" 
     49        self.__thread = Thread(target=PasteDeployAppServer.start, args=(self,)) 
     50        self.thread.start() 
     51         
     52    def terminateThread(self): 
     53        self.pasteServer.server_close() 
     54 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/wsgi/authn/ssl-test.ini

    r5770 r5774  
    55# 
    66[DEFAULT] 
    7 testConfigDir = ../../../config 
     7testConfigDir = %(here)s/../../../config 
    88beakerSessionKeyName = beaker.session.ndg.security 
    99 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/wsgi/ssl/test.ini

    r5757 r5774  
    55# 
    66[DEFAULT] 
    7 testConfigDir = ../../../config 
     7testConfigDir = %(here)s/../../../config 
    88 
    99[server:main] 
Note: See TracChangeset for help on using the changeset viewer.