Changeset 1752


Ignore:
Timestamp:
23/11/06 17:32:48 (13 years ago)
Author:
pjkersha
Message:

test/SessionMgrClientTest.py: copied from old Tests/SecurityClient?.py into new unit tests package
structure
common/SessionMgr/init.py: delete to make way for old SecurityClient?.py code to replace it.

Location:
TI12-security/trunk/python
Files:
1 deleted
1 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/SessionMgrClientTest.py

    r1750 r1752  
    11#!/usr/bin/env python 
    22 
    3 """Test harness for NDG Security client - makes requests for authentication  
    4 and authorisation 
     3"""Test harness for NDG Session Manager client - makes requests for  
     4authentication and authorisation.  An Attribute Authority and Simple CA 
     5services must be running for the reqAuthorisation and addUser tests 
    56 
    67NERC Data Grid Project 
     
    89P J Kershaw 23/02/06 
    910 
    10 (Renamed from SessionClientTest.py 27/0/4/06) 
     11Renamed from SessionClientTest.py 27/0/4/06 
     12Moved and renamed SessionMgrClientTest.py 23/11/06 
    1113 
    1214Copyright (C) 2006 CCLRC & NERC 
     
    2022from Cookie import SimpleCookie 
    2123 
    22 from ndg.security.SecurityClient import * 
     24from ndg.security.common.SessionMgrClient import * 
    2325 
    2426 
     
    2628     
    2729    def setUp(self): 
    28         try: 
    29             self.config = {} 
     30        self.config = {} 
    3031 
    31             # Gabriel settings 
    32             gabrielConfig = {} 
    33             gabrielConfig['smWSDL'] = 'http://gabriel.bnsc.rl.ac.uk/sessionMgr.wsdl' 
    34             gabrielConfig['aaWSDL'] = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
     32        # Gabriel settings 
     33        gabrielConfig = {} 
     34        gabrielConfig['smWSDL'] = 'http://gabriel.bnsc.rl.ac.uk/sessionMgr.wsdl' 
     35        gabrielConfig['aaWSDL'] = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
    3536 
    36              
    37             gabrielConfig['newUserName'] = 'BugsBunny'             
    38             gabrielConfig['userName'] = 'gabriel' 
    39             gabrielConfig['trustedHostRequiredRole'] = 'academic' 
     37         
     38        gabrielConfig['newUserName'] = 'BugsBunny'             
     39        gabrielConfig['userName'] = 'gabriel' 
     40        gabrielConfig['trustedHostRequiredRole'] = 'academic' 
    4041 
    41             gabrielConfig['aaPubKeyFilePath'] = None 
    42      
    43             # Public key of session manager used to encrypt requests 
    44             # If no public key is set, it will be retrieved using the 
    45             # getPubKey WS method 
    46             gabrielConfig['smPubKeyFilePath'] = None 
     42        gabrielConfig['aaPubKeyFilePath'] = None 
    4743 
    48              
    49             # Glue settings 
    50             glueConfig = {} 
    51             glueConfig['smWSDL'] = 'http://glue.badc.rl.ac.uk/sessionMgr.wsdl' 
    52             glueConfig['aaWSDL'] = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
     44        # Public key of session manager used to encrypt requests 
     45        # If no public key is set, it will be retrieved using the 
     46        # getPubKey WS method 
     47        gabrielConfig['smPubKeyFilePath'] = None 
    5348 
    54              
    55             glueConfig['newUserName'] = 'YosemiteSam'             
    56             glueConfig['userName'] = 'lawrence' 
    57             glueConfig['trustedHostRequiredRole'] = 'acsoe' 
    58             #glueConfig['trustedHostRequiredRole'] = 'coapec' 
     49         
     50        # Glue settings 
     51        glueConfig = {} 
     52        glueConfig['smWSDL'] = 'http://glue.badc.rl.ac.uk/sessionMgr.wsdl' 
     53        glueConfig['aaWSDL'] = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
    5954 
    60             glueConfig['aaPubKeyFilePath'] = None 
    61      
    62             # Public key of session manager used to encrypt requests 
    63             # If no public key is set, it will be retrieved using the 
    64             # getPubKey WS method 
    65             glueConfig['smPubKeyFilePath'] = None 
     55         
     56        glueConfig['newUserName'] = 'YosemiteSam'             
     57        glueConfig['userName'] = 'lawrence' 
     58        glueConfig['trustedHostRequiredRole'] = 'acsoe' 
     59        #glueConfig['trustedHostRequiredRole'] = 'coapec' 
     60 
     61        glueConfig['aaPubKeyFilePath'] = None 
     62 
     63        # Public key of session manager used to encrypt requests 
     64        # If no public key is set, it will be retrieved using the 
     65        # getPubKey WS method 
     66        glueConfig['smPubKeyFilePath'] = None 
    6667 
    6768 
    68             # Uncomment for required test 
    69             self.config = gabrielConfig 
    70             #self.config = glueConfig 
     69        # Uncomment for required test 
     70        self.config = gabrielConfig 
     71        #self.config = glueConfig 
    7172 
    72              
    73             self.__clntPriKeyPwd = open("./tmp2").read().strip() 
     73         
     74        self.__clntPriKeyPwd = open("./tmp2").read().strip() 
    7475 
    75             clntPubKeyFilePath = "./Junk-cert.pem" 
    76             clntPriKeyFilePath = "./Junk-key.pem" 
    77             traceFile = None#sys.stderr 
    78              
    79             # Initialise the Session Manager client connection 
    80             # Omit traceFile keyword to leave out SOAP debug info 
    81             self.sessClnt = SessionClient(smWSDL=self.config['smWSDL'], 
    82                             smPubKeyFilePath=self.config['smPubKeyFilePath'], 
    83                             clntPubKeyFilePath=clntPubKeyFilePath, 
    84                             clntPriKeyFilePath=clntPriKeyFilePath, 
    85                             traceFile=traceFile)  
    86  
    87             # Attribute Authority client tests             
    88             self.aaClnt = AttAuthorityClient(aaWSDL=self.config['aaWSDL'], 
    89                             aaPubKeyFilePath=self.config['aaPubKeyFilePath'], 
    90                             clntPubKeyFilePath=clntPubKeyFilePath, 
    91                             clntPriKeyFilePath=clntPriKeyFilePath, 
    92                             traceFile=traceFile)  
    93             self.sessCookie = None 
    94             self.proxyCert = None 
     76        clntPubKeyFilePath = "./Junk-cert.pem" 
     77        clntPriKeyFilePath = "./Junk-key.pem" 
     78        traceFile = None#sys.stderr 
    9579         
    96         except Exception, e: 
    97             self.fail(str(e)) 
    98              
    99              
    100     def tearDown(self): 
    101         pass 
     80        # Initialise the Session Manager client connection 
     81        # Omit traceFile keyword to leave out SOAP debug info 
     82        self.sessClnt = SessionMgrClient(smURI=self.config['smWSDL'], 
     83                        smPubKeyFilePath=self.config['smPubKeyFilePath'], 
     84                        clntPubKeyFilePath=clntPubKeyFilePath, 
     85                        clntPriKeyFilePath=clntPriKeyFilePath, 
     86                        traceFile=traceFile)  
     87         
     88        self.sessCookie = None 
     89        self.proxyCert = None 
    10290 
    10391 
    10492    def testAddUser(self): 
     93        """Add a new user ID to the MyProxy repository""" 
    10594         
    106         try: 
    107             # Uncomment to add a new user ID to the MyProxy repository 
    108             # Note the pass-phrase is read from the file tmp.  To pass 
    109             # explicitly as a string use the 'pPhrase' keyword instead 
    110             self.sessClnt.addUser(self.config['newUserName'],  
    111                                   pPhraseFilePath="./tmp", 
    112                                   clntPriKeyPwd=self.__clntPriKeyPwd) 
    113             print "Added user '%s'" % self.config['newUserName'] 
    114              
    115         except Exception, e: 
    116             self.fail(str(e)) 
     95        # Note the pass-phrase is read from the file tmp.  To pass 
     96        # explicitly as a string use the 'pPhrase' keyword instead 
     97        self.sessClnt.addUser(self.config['newUserName'],  
     98                              pPhraseFilePath="./tmp", 
     99                              clntPriKeyPwd=self.__clntPriKeyPwd) 
     100        print "Added user '%s'" % self.config['newUserName'] 
    117101         
    118102 
    119103    def testCookieConnect(self): 
     104        """testCookieConnect: Connect as if acting as a browser client -  
     105        a cookie is returned""" 
    120106         
    121 #        import pdb 
    122 #        pdb.set_trace() 
    123         try: 
    124             # Connect as if acting as a browser client - a cookie is returned 
    125             sSessCookie = self.sessClnt.connect(self.config['userName'],  
    126                                         pPhraseFilePath="./tmp", 
    127                                         clntPriKeyPwd=self.__clntPriKeyPwd) 
    128             self.sessCookie = SimpleCookie(sSessCookie) 
    129             print "User '%s' connected to Session Manager:\n%s" % \ 
    130                 (self.config['userName'], sSessCookie) 
    131  
    132         except Exception, e: 
    133             self.fail(str(e)) 
     107        # Note the pass-phrase is read from the file tmp.  To pass 
     108        # explicitly as a string use the 'pPhrase' keyword instead 
     109        sSessCookie = self.sessClnt.connect(self.config['userName'],  
     110                                    pPhraseFilePath="./tmp", 
     111                                    clntPriKeyPwd=self.__clntPriKeyPwd) 
     112        self.sessCookie = SimpleCookie(sSessCookie) 
     113        print "User '%s' connected to Session Manager:\n%s" % \ 
     114            (self.config['userName'], sSessCookie) 
    134115             
    135116 
    136117    def testProxyCertConnect(self): 
    137          
    138         try: 
    139             # Connect as a command line client - a proxyCert is returned         
    140             self.proxyCert = self.sessClnt.connect(self.config['userName'],  
    141                                           pPhraseFilePath="./tmp", 
    142                                           createServerSess=True, 
    143                                           getCookie=False, 
    144                                           clntPriKeyPwd=self.__clntPriKeyPwd) 
    145             print "User '%s' connected to Session Manager:\n%s" % \ 
    146                 (self.config['userName'], self.proxyCert) 
    147  
    148         except Exception, e: 
    149             self.fail(str(e)) 
     118        """testProxyCertConnect: Connect as a command line client -  
     119        a proxyCert is returned""" 
     120              
     121        self.proxyCert = self.sessClnt.connect(self.config['userName'],  
     122                                      pPhraseFilePath="./tmp", 
     123                                      createServerSess=True, 
     124                                      getCookie=False, 
     125                                      clntPriKeyPwd=self.__clntPriKeyPwd) 
     126        print "User '%s' connected to Session Manager:\n%s" % \ 
     127            (self.config['userName'], self.proxyCert) 
    150128 
    151129 
    152130    def testCookieReqAuthorisation(self): 
    153         try: 
    154             # Request an attribute certificate from an Attribute Authority  
    155             # using the cookie returned from connect() 
    156             self.testCookieConnect() 
    157             authResp = self.sessClnt.reqAuthorisation(\ 
    158                         sessID=self.sessCookie['NDG-ID1'].value,  
    159                         aaWSDL=self.config['aaWSDL'], 
    160                         encrSessMgrWSDLuri=self.sessCookie['NDG-ID2'].value, 
    161                         clntPriKeyPwd=self.__clntPriKeyPwd) 
    162                                                                    
    163             # The authorisation response is returned as an object which  
    164             # behaves like a python dictionary.  See  
    165             # ndg.security.SessionMgrIO.AuthorisationResp 
    166             if 'errMsg' in authResp: 
    167                 print "Authorisation failed for user: %s" % authResp['errMsg']             
    168             else: 
    169                 print "User authorised" 
    170                  
    171             print authResp 
    172  
    173         except Exception, e: 
    174             self.fail(str(e)) 
     131        """testCookieReqAuthorisation: make an authorisation request using 
     132        a cookie as authentication credential""" 
     133         
     134        self.testCookieConnect() 
     135        authResp = self.sessClnt.reqAuthorisation(\ 
     136                    sessID=self.sessCookie['NDG-ID1'].value,  
     137                    aaWSDL=self.config['aaWSDL'], 
     138                    encrSessMgrWSDLuri=self.sessCookie['NDG-ID2'].value, 
     139                    clntPriKeyPwd=self.__clntPriKeyPwd) 
     140                                                               
     141        # The authorisation response is returned as an object which  
     142        # behaves like a python dictionary.  See  
     143        # ndg.security.SessionMgrIO.AuthorisationResp 
     144        if 'errMsg' in authResp: 
     145            print "Authorisation failed for user: %s" % authResp['errMsg']             
     146        else: 
     147            print "User authorised" 
     148             
     149        print authResp 
    175150 
    176151 
    177152    def testProxyCertReqAuthorisation(self): 
    178         try: 
    179             self.testProxyCertConnect() 
     153        """testProxyCertReqAuthorisation: make an authorisation request using 
     154        a proxy cert as authentication credential""" 
     155        self.testProxyCertConnect() 
     156         
     157        # Request an attribute certificate from an Attribute Authority  
     158        # using the proxyCert returned from connect() 
     159        authResp = self.sessClnt.reqAuthorisation(\ 
     160                                     proxyCert=self.proxyCert, 
     161                                     aaWSDL=self.config['aaWSDL'], 
     162                                     clntPriKeyPwd=self.__clntPriKeyPwd) 
     163                                              
     164        # The authorisation response is returned as an object which  
     165        # behaves like a python dictionary.  See  
     166        # ndg.security.SessionMgrIO.AuthorisationResp 
     167        if 'errMsg' in authResp: 
     168            print "Authorisation failed for user %s" % authResp['errMsg']            
     169        else: 
     170            print "User authorised" 
    180171             
    181             # Request an attribute certificate from an Attribute Authority  
    182             # using the proxyCert returned from connect() 
    183             authResp = self.sessClnt.reqAuthorisation(\ 
    184                                          proxyCert=self.proxyCert, 
    185                                          aaWSDL=self.config['aaWSDL'], 
    186                                          clntPriKeyPwd=self.__clntPriKeyPwd) 
    187                                                   
    188             # The authorisation response is returned as an object which  
    189             # behaves like a python dictionary.  See  
    190             # ndg.security.SessionMgrIO.AuthorisationResp 
    191             if 'errMsg' in authResp: 
    192                 print "Authorisation failed for user %s" % authResp['errMsg']            
    193             else: 
    194                 print "User authorised" 
    195                  
    196             print authResp 
    197  
    198         except Exception, e: 
    199             self.fail(str(e)) 
     172        print authResp 
    200173 
    201174 
    202175    def testGetPubKey(self): 
    203         try: 
    204             # Request an attribute certificate from an Attribute Authority  
    205             # using the proxyCert returned from connect() 
    206             pubKey = self.sessClnt.getPubKey() 
    207                                                   
    208             print "Public Key:\n" + pubKey 
    209  
    210         except Exception, e: 
    211             self.fail(str(e)) 
    212             
    213  
    214     def testAAgetHostInfo(self): 
    215         """Call Attribute Authority getHostInfo""" 
    216          
    217         try: 
    218             hostInfo = self.aaClnt.getHostInfo( 
    219                                            clntPriKeyPwd=self.__clntPriKeyPwd) 
    220             print hostInfo 
    221              
    222         except Exception, e: 
    223             self.fail(str(e)) 
    224             
    225  
    226     def testAAgetTrustedHostInfo(self): 
    227         """Call Attribute Authority getTrustedHostInfo with a given role 
    228         to match against""" 
    229          
    230 #        import pdb 
    231 #        pdb.set_trace() 
    232         try: 
    233             trustedHosts = self.aaClnt.getTrustedHostInfo( 
    234                                role=self.config['trustedHostRequiredRole'], 
    235                                clntPriKeyPwd=self.__clntPriKeyPwd) 
    236             print trustedHosts 
    237              
    238         except Exception, e: 
    239             self.fail(str(e)) 
    240             
    241  
    242     def testAAgetTrustedHostInfoWithNoRoleSet(self): 
    243         """Call Attribute Authority getTrustedHostInfo""" 
    244          
    245         import pdb 
    246         pdb.set_trace() 
    247         try: 
    248             trustedHosts = self.aaClnt.getTrustedHostInfo( 
    249                                        clntPriKeyPwd=self.__clntPriKeyPwd) 
    250             print trustedHosts 
    251              
    252         except Exception, e: 
    253             self.fail(str(e)) 
    254             
    255  
    256     def testAAReqAuthorisation(self): 
    257         """Call Attribute Authority authorisation request""" 
    258          
    259         import pdb 
    260         pdb.set_trace() 
    261         try: 
    262             # Alternative means of getting proxy cert - from file 
    263             #self.proxyCert = open("./proxy.pem").read().strip() 
    264             self.testProxyCertConnect() 
    265             userAttCert = None 
    266              
    267             ac = self.aaClnt.reqAuthorisation( 
    268                                        proxyCert=self.proxyCert, 
    269                                        userAttCert=userAttCert, 
    270                                        clntPriKeyPwd=self.__clntPriKeyPwd) 
    271             print ac 
    272              
    273         except Exception, e: 
    274             self.fail(str(e)) 
     176        "testGetPubKey: return the Session Manager's public key" 
     177        pubKey = self.sessClnt.getPubKey() 
     178                                              
     179        print "Public Key:\n" + pubKey 
    275180             
    276181             
    277182#_____________________________________________________________________________        
    278 class SecurityClientTestSuite(unittest.TestSuite): 
     183class SessionMgrClientTestSuite(unittest.TestSuite): 
    279184     
    280185    def __init__(self): 
    281         map = map(SecurityClientTestCase, 
     186        map = map(SessionMgrClientTestCase, 
    282187                  ( 
    283188                    "testAddUser", 
    284189                    "testConnect", 
     190                    "testDisconnect", 
    285191                    "testReqAuthorisation", 
    286192                    "testGetPubKey", 
    287                     "testAAgetTrustedHostInfo", 
    288                     "testAAReqAuthorisation", 
    289193                  )) 
    290194        unittest.TestSuite.__init__(self, map) 
Note: See TracChangeset for help on using the changeset viewer.