Changeset 4127


Ignore:
Timestamp:
18/08/08 11:54:37 (11 years ago)
Author:
cbyrom
Message:

Get SessionMgr? client working + update conf files, keys and docs with details
+ fix the various tests running against the various SessionMgr? tests.

Location:
TI12-security/trunk/java
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/java/axis2/conf/axis2-sessionMgr.xml

    r4116 r4127  
    3434      <action> 
    3535        <items>Signature Timestamp</items> 
    36         <signaturePropFile>client.properties</signaturePropFile> 
     36        <signaturePropFile>client-sessionMgr.properties</signaturePropFile> 
    3737        <passwordCallbackClass>wssecurity.test.security.ndg.PWCBHandler</passwordCallbackClass> 
    3838      </action> 
     
    155155                     class="org.apache.axis2.transport.http.CommonsHTTPTransportSender"> 
    156156        <parameter name="PROTOCOL" locked="false">HTTP/1.1</parameter> 
     157        <!--  
    157158        <parameter name="Transfer-Encoding" locked="false">chunked</parameter> 
     159                --> 
    158160    </transportSender> 
    159161 
  • TI12-security/trunk/java/axis2/src/client-sessionMgr.properties

    r4112 r4127  
    33org.apache.ws.security.crypto.merlin.keystore.password=apache 
    44org.apache.ws.security.crypto.merlin.file=/home/users/cbyrom/eclipseWorkspace/TI12-security-java/axis2/src/ndg/security/sessionMgr/keys/client.jks 
     5#org.apache.ws.security.crypto.merlin.file=C:/Users/byrc/5509/eclipseWorkspace/TI12-security-java/axis2/src/ndg/security/sessionMgr/keys/client.jks 
  • TI12-security/trunk/java/axis2/src/ndg/security/sessionMgr/README.txt

    r4112 r4127  
    66- when prompted, enter '1' to write the server certs to a local keystore, 'jssecacerts'.   
    77This then needs to be copied to $JAVA_HOME/jre/lib/security/ to be used by the client. 
     8 
     9NB, if this isn't done you'll get the following error: 
     10 
     11org.apache.axis2.AxisFault: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested targetBack to the drawing board...: 
     12 
     13- if this keystore doesn't get picked up automatically (it didn't on windows for some reason), add 
     14the following VM arg when running the tests: 
     15 
     16-Djavax.net.ssl.trustStore=<add_path>\TI12-security-java\jssecacerts 
     17 
     18For the tests to run correctly, the test.properties file in this folder needs to 
     19be edited to provide valid inputs.  Additionally, if the SessionMgrClientADB client 
     20is to be ran as a java app, the class should be edited to include a valid userID and 
     21password. 
  • TI12-security/trunk/java/axis2/src/ndg/security/sessionMgr/SessionMgrClientADB.java

    r4112 r4127  
    11package ndg.security.sessionMgr; 
    22 
     3import java.io.FileNotFoundException; 
     4import java.io.FileReader; 
     5import java.io.IOException; 
    36import java.rmi.RemoteException; 
     7import java.util.Properties; 
    48 
    59import ndg.security.sessionMgr.SessionMgrServiceStub.Connect; 
     
    2832{ 
    2933        private static final String LINE_BREAK = "-------------------------------"; 
     34        private static final String PROPERTIES_FILE = "test.properties"; 
     35        private static final String USER_ID = null; 
     36        private static final String PW = null; 
    3037        private SessionMgrServiceStub service = null; 
     38         
     39        private Properties properties = null; 
     40        private String VALID_USER_ID; 
     41        private String VALID_PW; 
     42        private String VALID_USER_DN; 
     43        private String VALID_ATT_AUTH_URI; 
    3144         
    3245    public static void main(java.lang.String args[]) 
     
    3447        try 
    3548        { 
    36                 SessionMgrClientADB client = new SessionMgrClientADB(); 
    37  
    38                 client.configureServiceConnection("/home/users/cbyrom/eclipseWorkspace/TI12-security-java/axis2", 
    39 //                      "https://ndgbeta.badc.rl.ac.uk/SessionManager"); 
    40                         "http://localhost:5000/SessionManager"); 
     49                SessionMgrClientADB client = new SessionMgrClientADB(); 
     50                 
     51                client.loadProperties(PROPERTIES_FILE); 
     52 
     53                client.configureServiceConnection( 
     54                                client.properties.getProperty("confDir"),  
     55                                client.properties.getProperty("endpoint")); 
    4156                 
    4257                client.runServices(); 
     
    4964    } 
    5065 
    51     /** 
     66    private void loadProperties(String propertiesFile) throws IOException  
     67    { 
     68                this.properties = new Properties(); 
     69                FileReader reader = new FileReader(getClass().getResource(propertiesFile).getFile()); 
     70                this.properties.load(reader); 
     71                VALID_USER_ID = this.properties.getProperty("userID"); 
     72                VALID_PW = this.properties.getProperty("pw"); 
     73                VALID_USER_DN = this.properties.getProperty("userDN"); 
     74                VALID_ATT_AUTH_URI = this.properties.getProperty("attAuthURI"); 
     75        } 
     76 
     77        /** 
    5278     * Set up the connection from the client to the service - via the generated stub class 
    5379     * @param configDir - axis2 conf directory, with axis2.xml file to set up the connection 
     
    6995        { 
    7096                this.callGetX509Service(); 
    71         this.callConnectService("cbyrom", "xx", false); 
    72         this.callDisconnectService(null, null); 
    73         this.callGetSessionStatusService(null, null); 
    74         this.callGetAttCertService(null, null, null, null, false, null, false, null, null); 
     97                ConnectResponse res = this.callConnectService(VALID_USER_ID, VALID_PW, true); 
     98        this.callGetSessionStatusService(null, res.localSessID); 
     99        this.callGetAttCertService(null, VALID_ATT_AUTH_URI, null, null, false, null,  
     100                                true, res.localSessID, null); 
     101        this.callDisconnectService(res.localSessID, null); 
    75102        } 
    76103 
  • TI12-security/trunk/java/axis2/src/ndg/security/sessionMgr/SessionMgrClientADBTest.java

    r4112 r4127  
    66import java.io.IOException; 
    77import java.rmi.RemoteException; 
    8 import java.util.ArrayList; 
    98import java.util.Properties; 
    109 
    11 import org.apache.axis2.AxisFault; 
    12  
     10import junit.framework.TestCase; 
    1311import ndg.security.sessionMgr.SessionMgrServiceStub.ConnectResponse; 
    1412import ndg.security.sessionMgr.SessionMgrServiceStub.DisconnectResponse; 
     
    1715import ndg.security.sessionMgr.SessionMgrServiceStub.GetX509CertResponse; 
    1816 
    19 import junit.framework.TestCase; 
     17import org.apache.axis2.AxisFault; 
    2018 
    2119/** 
     
    3028        private static final String START_CERTIFICATE_STRING = "-----BEGIN CERTIFICATE-----"; 
    3129        private static final String END_CERTIFICATE_STRING = "-----END CERTIFICATE-----"; 
    32         private static final String VALID_PW = "m0rebeer"; 
    33         private static final String VALID_USER_ID = "cbyrom"; 
    34         private static final String VALID_ATT_AUTH_CERT = "xxx"; 
    35         private static final String VALID_ATT_AUTH_URI = "http://localhost:5100/AttributeAuthority"; 
    36         private static final String[] VALID_EXT_ATT_CERTS = null; 
    37         private static final String[] VALID_EXT_TRUSTED_HOSTS = null; 
    38         private static final String VALID_USER_CERT = null; 
    39         private static final String VALID_ROLE = null; 
    40         private static final String VALID_USER_DN = null; 
     30        private static String VALID_PW = null; 
     31        private static String VALID_USER_ID = null; 
     32        private static String VALID_ATT_AUTH_URI = null; 
     33        private static final String VALID_ROLE = "academic"; 
     34        private static String VALID_USER_DN = null; 
    4135        private static final String INVALID_ATT_AUTH_CERT = "blah"; 
    4236        private static final String INVALID_ATT_AUTH_URI = "blah"; 
    4337        private static final String[] INVALID_EXT_ATT_CERTS = {"blah1", "blah2"}; 
    4438        private static final String[] INVALID_EXT_TRUSTED_HOSTS = {"blah1", "blah2"}; 
    45         private static final String INVALID_ROLE = "blah"; 
     39        private static final String INVALID_ROLE = "lumberjack"; 
    4640        private static final String INVALID_USER_CERT = "blah"; 
     41        private static final String STANDARD_AXIS_FAULT = "Processing Failure"; 
    4742 
    4843        private Properties properties = null; 
    49         private ArrayList<String> VALID_ROLES = new ArrayList<String>(); 
    5044         
    5145        public SessionMgrClientADBTest() throws IOException  
     
    5448                FileReader reader = new FileReader(getClass().getResource(PROPERTIES_FILE).getFile()); 
    5549                this.properties.load(reader); 
    56                 VALID_ROLES.add("academic"); 
    57                 VALID_ROLES.add("eoGroup"); 
    58                 VALID_ROLES.add("student"); 
     50                VALID_USER_ID = this.properties.getProperty("userID"); 
     51                VALID_PW = this.properties.getProperty("pw"); 
     52                VALID_USER_DN = this.properties.getProperty("userDN"); 
     53                VALID_ATT_AUTH_URI = this.properties.getProperty("attAuthURI"); 
    5954        } 
    6055 
     
    125120                        fail("Could not find server cert file to compare results with"); 
    126121                } 
     122                catch (Exception e) 
     123                { 
     124                        e.printStackTrace(); 
     125                        fail("An exception should not have been thrown here"); 
     126                } 
    127127        } 
    128128         
     
    135135                                        VALID_USER_ID, VALID_PW, true);                  
    136136                        GetAttCertResponse res = client.callGetAttCertService( 
    137                                         VALID_ATT_AUTH_CERT, VALID_ATT_AUTH_URI, 
    138                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
     137                                        null, VALID_ATT_AUTH_URI, null, null, true, VALID_ROLE,  
     138                                        true, res1.localSessID, null); 
     139                                         
     140                        // just to quick check of content - to avoid need for xml parsing 
     141                        assertNotNull(res.localAttCert); 
     142                        res.localAttCert.contains("<name>coapec</name>"); 
     143                        res.localAttCert.contains("<provenance>original</provenance>"); 
     144                        assertNull(res.localMsg); 
     145                        assertNull(res.localExtAttCertOut); 
     146                } 
     147                catch (Exception e) 
     148                { 
     149                        e.printStackTrace(); 
     150                        fail("An exception should not have been thrown here"); 
     151                } 
     152        } 
     153         
     154         
     155        public void testGetAttCertWithoutMapFromTrustedHosts() 
     156        { 
     157                try  
     158                { 
     159                        ConnectResponse res1 = this.client.callConnectService( 
     160                                        VALID_USER_ID, VALID_PW, true);                  
     161                        GetAttCertResponse res = client.callGetAttCertService( 
     162                                        null, VALID_ATT_AUTH_URI, null, null, false, null,  
     163                                        true, res1.localSessID, null); 
     164                                         
     165                        // just to quick check of content - to avoid need for xml parsing 
     166                        assertNotNull(res.localAttCert); 
     167                        res.localAttCert.contains("<name>coapec</name>"); 
     168                        res.localAttCert.contains("<provenance>original</provenance>"); 
     169                        assertNull(res.localMsg); 
     170                        assertNull(res.localExtAttCertOut); 
     171                } 
     172                catch (Exception e) 
     173                { 
     174                        e.printStackTrace(); 
     175                        fail("An exception should not have been thrown here"); 
     176                } 
     177        } 
     178         
     179         
     180        public void testGetAttCertInvalidAttAuthCert() 
     181        { 
     182                try  
     183                { 
     184                        ConnectResponse res1 = this.client.callConnectService( 
     185                                        VALID_USER_ID, VALID_PW, true);                  
     186                        GetAttCertResponse res = client.callGetAttCertService( 
     187                                        INVALID_ATT_AUTH_CERT, VALID_ATT_AUTH_URI, 
     188                                        null, null, true, null, true, res1.localSessID , null); 
     189                                         
     190                        // just to quick check of content - to avoid need for xml parsing 
     191                        assertNotNull(res.localAttCert); 
     192                        res.localAttCert.contains("<name>coapec</name>"); 
     193                        res.localAttCert.contains("<provenance>original</provenance>"); 
     194                        assertNull(res.localMsg); 
     195                        assertNull(res.localExtAttCertOut); 
     196                } 
     197                catch (Exception e) 
     198                { 
     199                        e.printStackTrace(); 
     200                        fail("An exception should not have been thrown here"); 
     201                } 
     202        } 
     203         
     204         
     205        public void testGetAttCertInvalidAttAuthURI() 
     206        { 
     207                try  
     208                { 
     209                        ConnectResponse res1 = this.client.callConnectService( 
     210                                        VALID_USER_ID, VALID_PW, true);                  
     211                        GetAttCertResponse res = client.callGetAttCertService( 
     212                                        null, INVALID_ATT_AUTH_URI, 
     213                                        null, null, 
    139214                                        true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    140215                                         
    141                         // just to quick queck of content - to avoid need for xml parsing 
    142                         assertNotNull(res.localAttCert); 
    143                         res.localAttCert.contains("<name>coapec</name>"); 
    144                         res.localAttCert.contains("<provenance>original</provenance>"); 
    145                         assertNull(res.localMsg); 
    146                         assertNotNull(res.localExtAttCertOut); 
    147                         assertTrue(res.localExtAttCertOut.length > 0); 
    148                          
    149                 } catch (RemoteException e) { 
    150                         e.printStackTrace(); 
    151                         fail("A remote exception should not have been thrown here"); 
    152                 } 
    153         } 
    154          
    155          
    156         public void testGetAttCertWithoutMapFromTrustedHosts() 
    157         { 
    158                 try  
    159                 { 
    160                         ConnectResponse res1 = this.client.callConnectService( 
    161                                         VALID_USER_ID, VALID_PW, true);                  
    162                         GetAttCertResponse res = client.callGetAttCertService( 
    163                                         VALID_ATT_AUTH_CERT, VALID_ATT_AUTH_URI, 
    164                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
    165                                         false, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    166                                          
    167                         // just to quick queck of content - to avoid need for xml parsing 
    168                         assertNotNull(res.localAttCert); 
    169                         res.localAttCert.contains("<name>coapec</name>"); 
    170                         res.localAttCert.contains("<provenance>original</provenance>"); 
    171                         assertNull(res.localMsg); 
    172                         assertNotNull(res.localExtAttCertOut); 
    173                         assertTrue(res.localExtAttCertOut.length > 0); 
    174                          
    175                 } catch (RemoteException e) { 
    176                         e.printStackTrace(); 
    177                         fail("A remote exception should not have been thrown here"); 
    178                 } 
    179         } 
    180          
    181          
    182         public void testGetAttCertInvalidAttAuthCert() 
    183         { 
    184                 try  
    185                 { 
    186                         ConnectResponse res1 = this.client.callConnectService( 
    187                                         VALID_USER_ID, VALID_PW, true);                  
    188                         GetAttCertResponse res = client.callGetAttCertService( 
    189                                         INVALID_ATT_AUTH_CERT, VALID_ATT_AUTH_URI, 
    190                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
     216                        fail("An AxisFault should have been thrown here"); 
     217                } 
     218                catch (AxisFault e)  
     219                { 
     220                        assertEquals(STANDARD_AXIS_FAULT, e.getMessage()); 
     221                } 
     222                catch (Exception e) 
     223                { 
     224                        e.printStackTrace(); 
     225                        fail("An AxisFault should have been thrown here"); 
     226                } 
     227        } 
     228         
     229         
     230        public void testGetAttCertInvalidExtAttCerts() 
     231        { 
     232                try  
     233                { 
     234                        ConnectResponse res1 = this.client.callConnectService( 
     235                                        VALID_USER_ID, VALID_PW, true);                  
     236                        GetAttCertResponse res = client.callGetAttCertService( 
     237                                        null, VALID_ATT_AUTH_URI, 
     238                                        INVALID_EXT_ATT_CERTS, null, 
    191239                                        true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    192240                                         
    193                         // just to quick queck of content - to avoid need for xml parsing 
    194                         assertNotNull(res.localAttCert); 
    195                         res.localAttCert.contains("<name>coapec</name>"); 
    196                         res.localAttCert.contains("<provenance>original</provenance>"); 
    197                         assertNull(res.localMsg); 
    198                         assertNotNull(res.localExtAttCertOut); 
    199                         assertTrue(res.localExtAttCertOut.length > 0); 
     241                        // just to quick check of content - to avoid need for xml parsing 
     242                        assertNotNull(res.localAttCert); 
     243                        res.localAttCert.contains("<name>coapec</name>"); 
     244                        res.localAttCert.contains("<provenance>original</provenance>"); 
     245                        assertNull(res.localMsg); 
     246                        assertNull(res.localExtAttCertOut); 
     247                } 
     248                catch (Exception e) 
     249                { 
     250                        e.printStackTrace(); 
     251                        fail("An exception should not have been thrown here"); 
     252                } 
     253        } 
     254 
     255         
     256        public void testGetAttCertInvalidExtTrustedHosts() 
     257        { 
     258                try  
     259                { 
     260                        ConnectResponse res1 = this.client.callConnectService( 
     261                                        VALID_USER_ID, VALID_PW, true);                  
     262                        GetAttCertResponse res = client.callGetAttCertService( 
     263                                        null, VALID_ATT_AUTH_URI, 
     264                                        null, INVALID_EXT_TRUSTED_HOSTS, 
     265                                        true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
     266                                         
     267                        // just to quick check of content - to avoid need for xml parsing 
     268                        assertNotNull(res.localAttCert); 
     269                        res.localAttCert.contains("<name>coapec</name>"); 
     270                        res.localAttCert.contains("<provenance>original</provenance>"); 
     271                        assertNull(res.localMsg); 
     272                        assertNull(res.localExtAttCertOut); 
     273                } 
     274                catch (Exception e) 
     275                { 
     276                        e.printStackTrace(); 
     277                        fail("An exception should not have been thrown here"); 
     278                } 
     279        } 
     280 
     281         
     282        public void testGetAttCertValidExtTrustedHosts() 
     283        { 
     284                try  
     285                { 
     286                        // firstly do a call to retrieve an attcert 
     287                        ConnectResponse res1 = this.client.callConnectService( 
     288                                        VALID_USER_ID, VALID_PW, true);                  
     289                        GetAttCertResponse res = client.callGetAttCertService( 
     290                                        null, VALID_ATT_AUTH_URI, null, null, true, null,  
     291                                        true, res1.localSessID, null); 
     292                                         
     293                        // just to quick check of content - to avoid need for xml parsing 
     294                        assertNotNull(res.localAttCert); 
     295                        String[] extAttCerts = {res.localAttCert}; 
     296                        res = client.callGetAttCertService( 
     297                                        null, VALID_ATT_AUTH_URI,  
     298                                        extAttCerts, null, 
     299                                        true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
     300                                         
     301                        // just to quick check of content - to avoid need for xml parsing 
     302                        assertNotNull(res.localAttCert); 
     303                        res.localAttCert.contains("<name>coapec</name>"); 
     304                        res.localAttCert.contains("<provenance>original</provenance>"); 
     305                        assertNull(res.localMsg); 
     306                        assertNull(res.localExtAttCertOut); 
     307                } 
     308                catch (Exception e) 
     309                { 
     310                        e.printStackTrace(); 
     311                        fail("An exception should not have been thrown here"); 
     312                } 
     313        } 
     314         
     315         
     316        public void testGetAttCertInvalidUserCert() 
     317        { 
     318                try  
     319                { 
     320                        ConnectResponse res1 = this.client.callConnectService( 
     321                                        VALID_USER_ID, VALID_PW, true);                  
     322                        GetAttCertResponse res = client.callGetAttCertService( 
     323                                        null, VALID_ATT_AUTH_URI, 
     324                                        null, null, 
     325                                        true, VALID_ROLE, true, res1.localSessID , INVALID_USER_CERT); 
     326                                         
     327                        // just to quick check of content - to avoid need for xml parsing 
     328                        assertNotNull(res.localAttCert); 
     329                        res.localAttCert.contains("<name>coapec</name>"); 
     330                        res.localAttCert.contains("<provenance>original</provenance>"); 
     331                        assertNull(res.localMsg); 
     332                        assertNull(res.localExtAttCertOut); 
     333                } 
     334                catch (Exception e) 
     335                { 
     336                        e.printStackTrace(); 
     337                        fail("An exception should not have been thrown here"); 
     338                } 
     339        } 
     340         
     341         
     342        public void testGetAttCertInvalidRole() 
     343        { 
     344                try  
     345                { 
     346                        ConnectResponse res1 = this.client.callConnectService( 
     347                                        VALID_USER_ID, VALID_PW, true);                  
     348                        GetAttCertResponse res = client.callGetAttCertService( 
     349                                        null, VALID_ATT_AUTH_URI, 
     350                                        null, null, 
     351                                        true, INVALID_ROLE, true, res1.localSessID , res1.localUserCert); 
     352                                         
     353                        // just to quick check of content - to avoid need for xml parsing 
     354                        assertNotNull(res.localAttCert); 
     355                        res.localAttCert.contains("<name>coapec</name>"); 
     356                        res.localAttCert.contains("<provenance>original</provenance>"); 
     357                        assertNull(res.localMsg); 
     358                        assertNull(res.localExtAttCertOut); 
     359                } 
     360                catch (Exception e) 
     361                { 
     362                        e.printStackTrace(); 
     363                        fail("An exception should not have been thrown here"); 
     364                } 
     365        } 
     366         
     367         
     368        public void testGetAttCertInvalidSessionID() 
     369        { 
     370                try  
     371                { 
     372                        ConnectResponse res1 = this.client.callConnectService( 
     373                                        VALID_USER_ID, VALID_PW, true);                  
     374                        GetAttCertResponse res = client.callGetAttCertService( 
     375                                        null, VALID_ATT_AUTH_URI, 
     376                                        null, null, 
     377                                        true, VALID_ROLE, true, "blah", res1.localUserCert); 
     378                                         
    200379                        fail("A remote exception should have been thrown here"); 
    201                          
    202                 } catch (RemoteException e) { 
    203                         e.printStackTrace(); 
    204                         fail("A remote exception should not have been thrown here"); 
    205                 } 
    206         } 
    207          
    208          
    209         public void testGetAttCertInvalidAttAuthURI() 
    210         { 
    211                 try  
    212                 { 
    213                         ConnectResponse res1 = this.client.callConnectService( 
    214                                         VALID_USER_ID, VALID_PW, true);                  
    215                         GetAttCertResponse res = client.callGetAttCertService( 
    216                                         VALID_ATT_AUTH_CERT, INVALID_ATT_AUTH_URI, 
    217                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
    218                                         true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    219                                          
    220                         // just to quick queck of content - to avoid need for xml parsing 
    221                         assertNotNull(res.localAttCert); 
    222                         res.localAttCert.contains("<name>coapec</name>"); 
    223                         res.localAttCert.contains("<provenance>original</provenance>"); 
    224                         assertNull(res.localMsg); 
    225                         assertNotNull(res.localExtAttCertOut); 
    226                         assertTrue(res.localExtAttCertOut.length > 0); 
    227                         fail("A remote exception should have been thrown here"); 
    228                          
    229                 } catch (RemoteException e) { 
    230                         e.printStackTrace(); 
    231                         fail("A remote exception should not have been thrown here"); 
    232                 } 
    233         } 
    234          
    235          
    236         public void testGetAttCertInvalidExtAttCerts() 
    237         { 
    238                 try  
    239                 { 
    240                         ConnectResponse res1 = this.client.callConnectService( 
    241                                         VALID_USER_ID, VALID_PW, true);                  
    242                         GetAttCertResponse res = client.callGetAttCertService( 
    243                                         VALID_ATT_AUTH_CERT, INVALID_ATT_AUTH_URI, 
    244                                         INVALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
    245                                         true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    246                                          
    247                         // just to quick queck of content - to avoid need for xml parsing 
    248                         assertNotNull(res.localAttCert); 
    249                         res.localAttCert.contains("<name>coapec</name>"); 
    250                         res.localAttCert.contains("<provenance>original</provenance>"); 
    251                         assertNull(res.localMsg); 
    252                         fail("A remote exception should have been thrown here"); 
    253                          
    254                 } catch (RemoteException e) { 
    255                         e.printStackTrace(); 
    256                         fail("A remote exception should not have been thrown here"); 
    257                 } 
    258         } 
    259  
    260          
    261         public void testGetAttCertInvalidExtTrustedHosts() 
    262         { 
    263                 try  
    264                 { 
    265                         ConnectResponse res1 = this.client.callConnectService( 
    266                                         VALID_USER_ID, VALID_PW, true);                  
    267                         GetAttCertResponse res = client.callGetAttCertService( 
    268                                         VALID_ATT_AUTH_CERT, INVALID_ATT_AUTH_URI, 
    269                                         VALID_EXT_ATT_CERTS, INVALID_EXT_TRUSTED_HOSTS, 
    270                                         true, VALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    271                                          
    272                         // just to quick queck of content - to avoid need for xml parsing 
    273                         assertNotNull(res.localAttCert); 
    274                         res.localAttCert.contains("<name>coapec</name>"); 
    275                         res.localAttCert.contains("<provenance>original</provenance>"); 
    276                         assertNull(res.localMsg); 
    277                         assertNotNull(res.localExtAttCertOut); 
    278                         assertTrue(res.localExtAttCertOut.length > 0); 
    279                         fail("A remote exception should have been thrown here"); 
    280                          
    281                 } catch (RemoteException e) { 
    282                         e.printStackTrace(); 
    283                         fail("A remote exception should not have been thrown here"); 
    284                 } 
    285         } 
    286          
    287          
    288         public void testGetAttCertInvalidUserCert() 
    289         { 
    290                 try  
    291                 { 
    292                         ConnectResponse res1 = this.client.callConnectService( 
    293                                         VALID_USER_ID, VALID_PW, true);                  
    294                         GetAttCertResponse res = client.callGetAttCertService( 
    295                                         VALID_ATT_AUTH_CERT, INVALID_ATT_AUTH_URI, 
    296                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
    297                                         true, VALID_ROLE, true, res1.localSessID , INVALID_USER_CERT); 
    298                                          
    299                         // just to quick queck of content - to avoid need for xml parsing 
    300                         assertNotNull(res.localAttCert); 
    301                         res.localAttCert.contains("<name>coapec</name>"); 
    302                         res.localAttCert.contains("<provenance>original</provenance>"); 
    303                         assertNull(res.localMsg); 
    304                         assertNotNull(res.localExtAttCertOut); 
    305                         assertTrue(res.localExtAttCertOut.length > 0); 
    306                         fail("A remote exception should have been thrown here"); 
    307                          
    308                 } catch (RemoteException e) { 
    309                         e.printStackTrace(); 
    310                         fail("A remote exception should not have been thrown here"); 
    311                 } 
    312         } 
    313          
    314          
    315         public void testGetAttCertInvalidRole() 
    316         { 
    317                 try  
    318                 { 
    319                         ConnectResponse res1 = this.client.callConnectService( 
    320                                         VALID_USER_ID, VALID_PW, true);                  
    321                         GetAttCertResponse res = client.callGetAttCertService( 
    322                                         VALID_ATT_AUTH_CERT, INVALID_ATT_AUTH_URI, 
    323                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
    324                                         true, INVALID_ROLE, true, res1.localSessID , res1.localUserCert); 
    325                                          
    326                         // just to quick queck of content - to avoid need for xml parsing 
    327                         assertNotNull(res.localAttCert); 
    328                         res.localAttCert.contains("<name>coapec</name>"); 
    329                         res.localAttCert.contains("<provenance>original</provenance>"); 
    330                         assertNull(res.localMsg); 
    331                         assertNotNull(res.localExtAttCertOut); 
    332                         assertTrue(res.localExtAttCertOut.length > 0); 
    333                         fail("A remote exception should have been thrown here"); 
    334                          
    335                 } catch (RemoteException e) { 
    336                         e.printStackTrace(); 
    337                         fail("A remote exception should not have been thrown here"); 
    338                 } 
    339         } 
    340          
    341          
    342         public void testGetAttCertInvalidSessionID() 
    343         { 
    344                 try  
    345                 { 
    346                         ConnectResponse res1 = this.client.callConnectService( 
    347                                         VALID_USER_ID, VALID_PW, true);                  
    348                         GetAttCertResponse res = client.callGetAttCertService( 
    349                                         VALID_ATT_AUTH_CERT, INVALID_ATT_AUTH_URI, 
    350                                         VALID_EXT_ATT_CERTS, VALID_EXT_TRUSTED_HOSTS, 
    351                                         true, VALID_ROLE, true, "blah", res1.localUserCert); 
    352                                          
    353                         // just to quick queck of content - to avoid need for xml parsing 
    354                         assertNotNull(res.localAttCert); 
    355                         res.localAttCert.contains("<name>coapec</name>"); 
    356                         res.localAttCert.contains("<provenance>original</provenance>"); 
    357                         assertNull(res.localMsg); 
    358                         assertNotNull(res.localExtAttCertOut); 
    359                         assertTrue(res.localExtAttCertOut.length > 0); 
    360                         fail("A remote exception should have been thrown here"); 
    361                          
    362                 } catch (RemoteException e) { 
    363                         e.printStackTrace(); 
    364                         fail("A remote exception should not have been thrown here"); 
     380                } 
     381                catch (AxisFault e)  
     382                { 
     383                        assertEquals(STANDARD_AXIS_FAULT, e.getMessage()); 
     384                } 
     385                catch (Exception e) 
     386                { 
     387                        e.printStackTrace(); 
     388                        fail("An AxisFault should have been thrown here"); 
    365389                } 
    366390        } 
     
    372396                        ConnectResponse res = this.client.callConnectService( 
    373397                                        VALID_USER_ID, VALID_PW, true);                  
    374                          
    375                         // just to quick queck of content - to avoid need for xml parsing 
    376                         assertNotNull(res.localIssuingCert); 
    377                         res.localIssuingCert.contains("<name>coapec</name>"); 
    378                         res.localIssuingCert.contains("<provenance>original</provenance>"); 
     398                        // TODO: issuing cert is null - is this ok? 
     399//                      assertNotNull(res.localIssuingCert); 
    379400                        assertNotNull(res.localSessID); 
    380401                        assertNotNull(res.localUserCert); 
     
    394415                                        VALID_USER_ID, VALID_PW, false);                         
    395416                         
    396                         // just to quick queck of content - to avoid need for xml parsing 
    397                         assertNotNull(res.localIssuingCert); 
    398                         res.localIssuingCert.contains("<name>coapec</name>"); 
    399                         res.localIssuingCert.contains("<provenance>original</provenance>"); 
     417//                      assertNotNull(res.localIssuingCert); 
    400418                        assertNull(res.localSessID); 
    401419                        assertNotNull(res.localUserCert); 
     
    409427         
    410428         
    411         public void testDisconnectWithUserID() 
     429        public void testDisconnectWithSessionID() 
    412430        { 
    413431                try  
     
    423441                        // check session is no longer valid 
    424442                        GetSessionStatusResponse res3 = client.callGetSessionStatusService( 
    425                                         VALID_USER_DN, res1.localSessID); 
     443                                        null, res1.localSessID); 
    426444                         
    427445                        assertFalse(res3.localIsAlive); 
     
    434452         
    435453         
    436         public void testDisconnectWithUserCert() 
     454        public void testDisconnectWithOnlyUserCert() 
    437455        { 
    438456                try  
     
    444462                        DisconnectResponse res2 = client.callDisconnectService( 
    445463                                        null, res1.localUserCert); 
    446                         assertNotNull(res2); 
    447                          
    448                         // check session is no longer valid 
    449                         GetSessionStatusResponse res3 = client.callGetSessionStatusService( 
    450                                         VALID_USER_DN, res1.localSessID); 
    451                          
    452                         assertFalse(res3.localIsAlive); 
    453                          
    454                 } catch (RemoteException e) { 
    455                         e.printStackTrace(); 
    456                         fail("A remote exception should not have been thrown here"); 
     464                } 
     465                catch (AxisFault e)  
     466                { 
     467                        assertEquals(STANDARD_AXIS_FAULT, e.getMessage()); 
     468                } 
     469                catch (Exception e) 
     470                { 
     471                        e.printStackTrace(); 
     472                        fail("An AxisFault should have been thrown here"); 
    457473                } 
    458474        } 
     
    474490                        // check session is no longer valid 
    475491                        GetSessionStatusResponse res3 = client.callGetSessionStatusService( 
    476                                         VALID_USER_DN, res1.localSessID); 
     492                                        null, res1.localSessID); 
    477493                         
    478494                        assertFalse(res3.localIsAlive); 
     
    496512                catch (AxisFault e)  
    497513                { 
     514                        assertEquals(STANDARD_AXIS_FAULT, e.getMessage()); 
    498515                } 
    499516                catch (Exception e) 
     
    516533                                        VALID_USER_DN, res1.localSessID); 
    517534                         
     535                        fail("An exception should have been thrown; can only specify DN OR session ID - not both"); 
     536                } 
     537                catch (AxisFault e)  
     538                { 
     539                        assertEquals(STANDARD_AXIS_FAULT, e.getMessage()); 
     540                } 
     541                catch (Exception e) 
     542                { 
     543                        e.printStackTrace(); 
     544                        fail("An AxisFault should have been thrown here"); 
     545                } 
     546        } 
     547         
     548         
     549        public void testGetSessionStatusWithOnlyUserDN() 
     550        { 
     551                try  
     552                { 
     553                        // firstly set up a connection 
     554                        ConnectResponse res1 = this.client.callConnectService( 
     555                                        VALID_USER_ID, VALID_PW, true);                  
     556 
     557                        GetSessionStatusResponse res2 = client.callGetSessionStatusService( 
     558                                        VALID_USER_ID, null); 
     559                         
    518560                        assertTrue(res2.localIsAlive); 
    519                          
    520                 } catch (RemoteException e) { 
    521                         e.printStackTrace(); 
    522                         fail("A remote exception should not have been thrown here"); 
     561                }  
     562                catch (Exception e) { 
     563                        e.printStackTrace(); 
     564                        fail("An exception should not have been thrown here"); 
     565                } 
     566        } 
     567         
     568         
     569        public void testGetSessionStatusWithOnlySessionID() 
     570        { 
     571                try  
     572                { 
     573                        // firstly set up a connection 
     574                        ConnectResponse res1 = this.client.callConnectService( 
     575                                        VALID_USER_ID, VALID_PW, true);                  
     576 
     577                        GetSessionStatusResponse res2 = client.callGetSessionStatusService( 
     578                                        null, res1.localSessID); 
     579                         
     580                        assertTrue(res2.localIsAlive); 
     581                }  
     582                catch (Exception e) { 
     583                        e.printStackTrace(); 
     584                        fail("An exception should not have been thrown here"); 
    523585                } 
    524586        } 
     
    530592                { 
    531593                        GetSessionStatusResponse res = client.callGetSessionStatusService( 
    532                                         VALID_USER_DN, "blah"); 
     594                                        null, "blah"); 
    533595                         
    534596                        assertFalse(res.localIsAlive); 
    535                          
    536                 } catch (RemoteException e) { 
    537                         e.printStackTrace(); 
    538                         fail("A remote exception should not have been thrown here"); 
     597                }  
     598                catch (Exception e) { 
     599                        e.printStackTrace(); 
     600                        fail("An exception should not have been thrown here"); 
    539601                } 
    540602        } 
  • TI12-security/trunk/java/axis2/src/ndg/security/sessionMgr/test.properties

    r4112 r4127  
    1 certFile=/home/users/cbyrom/eclipseWorkspace/TI12-security-trunk/python/ndg.security.test/ndg/security/test/attAuthority/siteA-aa.crt 
     1certFile=/home/users/cbyrom/eclipseWorkspace/TI12-security-java/axis2/src/ndg/security/sessionMgr/keys/serviceCA.cert 
     2#certFile=c:/users/byrc/5509/eclipseWorkspace/TI12-security-java/axis2/src/ndg/security/sessionMgr/keys/serviceCA.cert 
    23confDir=/home/users/cbyrom/eclipseWorkspace/TI12-security-java/axis2 
    3 endpoint=http://localhost:5000/SessionManager 
     4#confDir=c:/users/byrc/5509/eclipseWorkspace/TI12-security-java/axis2 
     5endpoint=https://ndgbeta.badc.rl.ac.uk:443/SessionManager 
     6#endpoint=https://localhost:5000/SessionManager 
     7userID=cbyrom 
     8pw=xxx 
     9userDN=CN=Calum Byrom, OU=Unknown, O=BADC, ST=Unknown, C=UK 
     10attAuthURI=http://ndgbeta.badc.rl.ac.uk:50010/AttributeAuthority 
Note: See TracChangeset for help on using the changeset viewer.