| /* |
| |
| Derby - Class org.apache.derbyTesting.functionTests.tests.jdbcapi.DboPowersTest |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to you under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| package org.apache.derbyTesting.functionTests.tests.jdbcapi; |
| |
| import java.sql.Connection; |
| import java.sql.SQLException; |
| import javax.sql.DataSource; |
| import junit.framework.Test; |
| import org.apache.derbyTesting.junit.BaseJDBCTestCase; |
| import org.apache.derbyTesting.junit.BaseTestSuite; |
| import org.apache.derbyTesting.junit.DatabasePropertyTestSetup; |
| import org.apache.derbyTesting.junit.JDBC; |
| import org.apache.derbyTesting.junit.JDBCDataSource; |
| import org.apache.derbyTesting.junit.TestConfiguration; |
| |
| /** |
| * This JUnit tests enforcement of dbo (=database owner) powers, cf. |
| * DERBY-2264. |
| * |
| * The tests are run in the cross product (cardinality 10) of contexts: |
| * |
| * {client/server, embedded} x |
| * {no authentication, authentication and authentication/sqlAuthorization} x |
| * {data base owner, other user } |
| * |
| * One could consider removing the client/server suites to speed up |
| * this test as it does not add much value given the nature of the changes. |
| * |
| */ |
| public class DboPowersTest extends BaseJDBCTestCase |
| { |
| /* internal state */ |
| final private int _authLevel; |
| final private String _dbo; |
| final private String _dboPassword; |
| |
| /* test execution security context: one of three below */ |
| final private static int NOAUTHENTICATION=0; |
| final private static int AUTHENTICATION=1; |
| final private static int SQLAUTHORIZATION=2; |
| |
| final private static String[] secLevelNames = { |
| "noAuthentication", |
| "authentication", |
| "authentication + sqlAuthorization"}; |
| |
| final private static boolean ENCRYPT = true; |
| final private static boolean DECRYPT = false; |
| |
| /** |
| * Create a new instance of DboPowersTest (for shutdown test) |
| * |
| * @param name Fixture name |
| * @param authLevel authentication level with which test is run |
| */ |
| public DboPowersTest(String name, int authLevel) |
| { |
| super(name); |
| this._authLevel = authLevel; |
| this._dbo = null; |
| this._dboPassword = null; |
| } |
| |
| /** |
| * Creates a new instance of DboPowersTest for cryptographic operations |
| * and hard upgrade tests. |
| * <p> |
| * The database owner credentials is needed to always be able to perform |
| * the restricted operations (when they are not under test, but used as |
| * part of a test fixture for another operation). |
| * |
| * @param name Fixture name |
| * @param authLevel authentication level with which test is run |
| * @param dbo Database owner |
| * @param dboPassword Database owner's password |
| */ |
| |
| public DboPowersTest(String name, int authLevel, |
| String dbo, String dboPassword) |
| { |
| super(name); |
| this._authLevel = authLevel; |
| this._dbo = dbo; |
| this._dboPassword = dboPassword; |
| } |
| |
| |
| /** |
| * Construct top level suite in this JUnit test |
| * |
| * @return A suite containing embedded and client suites |
| */ |
| public static Test suite() |
| { |
| BaseTestSuite suite = new BaseTestSuite("DboPowersTest"); |
| |
| /* Database shutdown powers */ |
| |
| suite.addTest(dboShutdownSuite("suite: shutdown powers, embedded")); |
| suite.addTest( |
| TestConfiguration.clientServerDecorator( |
| dboShutdownSuite("suite: shutdown powers, client"))); |
| |
| // Database (re)encryption powers and decryption powers. |
| // The cryptographic power tests are not run for JSR169, since Derby |
| // does not support database encryption for that platform, cf. |
| // the specification for JSR169 support in DERBY-97. |
| if (!JDBC.vmSupportsJSR169()) { |
| suite.addTest( |
| dboCryptoSuite("suite: cryptographic powers, embedded")); |
| suite.addTest( |
| TestConfiguration.clientServerDecorator( |
| dboCryptoSuite("suite: cryptographic powers, client"))); |
| } |
| |
| /* Database hard upgrade powers */ |
| |
| suite.addTest( |
| dboHardUpgradeSuite("suite: hard upgrade powers, embedded")); |
| suite.addTest( |
| TestConfiguration.clientServerDecorator( |
| dboHardUpgradeSuite("suite: hard upgrade powers, client"))); |
| |
| return suite; |
| } |
| |
| /** |
| * Users used by both dboShutdownSuite and dboCryptoSuite |
| */ |
| final static String[][] users = { |
| /* authLevel == AUTHENTICATION: dbo is APP/APP for db 'wombat', |
| * so use that as first user. |
| */ |
| {"APP", "U1"}, |
| /* authLevel == SQLAUTHORIZATION: sqlAuthorizationDecorator |
| * decorator presumes TEST_DBO as dbo, so add it to set of |
| * valid users. Uses a fresh db 'dbsqlauth', not 'wombat'. |
| */ |
| {"TEST_DBO", "U1"}}; |
| |
| final static String pwSuffix = "pwSuffix"; |
| |
| |
| /** |
| * |
| * Construct suite of tests for shutdown database action |
| * |
| * @param framework Derby framework name |
| * @return A suite containing the test case for shutdown |
| * incarnated for the three security levels no authentication, |
| * authentication, and authentication plus sqlAuthorization, The |
| * latter two has an instance for dbo, and one for an ordinary user, |
| * so there are in all five incarnations of tests. |
| */ |
| private static Test dboShutdownSuite(String framework) |
| { |
| Test tests[] = new Test[SQLAUTHORIZATION+1]; // one per authLevel |
| |
| /* Tests without any authorization active (level == |
| * NOAUTHENTICATION). |
| */ |
| BaseTestSuite noauthSuite = |
| new BaseTestSuite("suite: security level=" + |
| secLevelNames[NOAUTHENTICATION]); |
| noauthSuite.addTest(new DboPowersTest("testShutDown", |
| NOAUTHENTICATION)); |
| tests[NOAUTHENTICATION] = noauthSuite; |
| |
| /* First decorate with users, then with authentication. Do this |
| * twice, once for authentication only, and once for |
| * authentication + sqlAuthorization (see extra decorator |
| * added below). |
| */ |
| for (int autLev = AUTHENTICATION; |
| autLev <= SQLAUTHORIZATION ; autLev++) { |
| |
| tests[autLev] = wrapShutdownUserTests(autLev); |
| } |
| |
| BaseTestSuite suite = new BaseTestSuite("dboPowers:"+framework); |
| |
| /* run tests with no authentication enabled */ |
| suite.addTest(tests[NOAUTHENTICATION]); |
| |
| /* run test for all users with only authentication enabled */ |
| suite.addTest(tests[AUTHENTICATION]); |
| |
| /* run test for all users with authentication and |
| * sqlAuthorization enabled |
| */ |
| suite.addTest( |
| TestConfiguration. |
| sqlAuthorizationDecorator(tests[SQLAUTHORIZATION])); |
| |
| return suite; |
| } |
| |
| |
| /** |
| * Wraps the shutdown fixture in decorators to run with data |
| * base owner and one other valid user. |
| * |
| * @param autLev security context to use |
| */ |
| |
| private static Test wrapShutdownUserTests(int autLev) |
| { |
| // add decorator for different users authenticated |
| BaseTestSuite usersSuite = |
| new BaseTestSuite("usersSuite: security level=" + |
| secLevelNames[autLev]); |
| |
| // First decorate with users, then with |
| for (int userNo = 0; userNo < users.length; userNo++) { |
| usersSuite.addTest |
| (TestConfiguration.changeUserDecorator |
| (new DboPowersTest("testShutDown", autLev), |
| users[autLev-1][userNo], |
| users[autLev-1][userNo].concat(pwSuffix))); |
| } |
| |
| return DatabasePropertyTestSetup. |
| builtinAuthentication(usersSuite, users[autLev-1], pwSuffix); |
| } |
| |
| |
| /** |
| * Test database shutdown power enforcement |
| * |
| * @throws SQLException |
| */ |
| public void testShutDown() throws SQLException |
| { |
| println("testShutDown: auth=" + this._authLevel + |
| " user="+getTestConfiguration().getUserName()); |
| |
| // make sure db is booted |
| getConnection().close(); |
| |
| String user = getTestConfiguration().getUserName(); |
| String password = getTestConfiguration().getUserPassword(); |
| |
| DataSource ds = JDBCDataSource.getDataSource(); |
| JDBCDataSource.setBeanProperty( |
| ds, "connectionAttributes", "shutdown=true"); |
| JDBCDataSource.setBeanProperty(ds, "user", user); |
| JDBCDataSource.setBeanProperty(ds, "password", password); |
| try { |
| ds.getConnection(); |
| fail("shutdown failed: no exception"); |
| } catch (SQLException e) { |
| if ("08006".equals(e.getSQLState())) { |
| // reboot if shutdown succeeded |
| JDBCDataSource.setBeanProperty(ds, "connectionAttributes", ""); |
| ds.getConnection().close(); |
| } |
| |
| vetShutdownException(user, e); |
| } |
| } |
| |
| /** |
| * Decide if the result of trying to shut down the database is |
| * compliant with the semantics introduced by DERBY-2264. |
| * |
| */ |
| private void vetShutdownException (String user, SQLException e) |
| { |
| switch (_authLevel) { |
| case NOAUTHENTICATION: |
| assertSQLState("database shutdown, no authentication", |
| "08006", e); |
| break; |
| case AUTHENTICATION: |
| /* We don't enforce dbo powers if only connection level |
| * authentication is used, for now. This leniency was |
| * introduced late in 10.3 release cycle for compatibility |
| * reasons. |
| */ |
| assertSQLState("database shutdown, authentication", |
| "08006", e); |
| break; |
| case SQLAUTHORIZATION: |
| if ("TEST_DBO".equals(user)) { |
| assertSQLState("database shutdown, SQL authorization, db owner", |
| "08006", e); |
| } else { |
| assertSQLState("database shutdown restriction, " + |
| "SQL authorization, not db owner", |
| "08004", e); |
| } |
| break; |
| default: |
| fail("test error: invalid authLevel: " + _authLevel); |
| break; |
| } |
| } |
| |
| /** |
| * |
| * Constructs suite of tests for cryptographic actions, that is database |
| * encryption, re-encryption, and decryption. |
| * |
| * @param framework Derby framework name |
| * @return A suite containing the test cases for cryptographic operations |
| * incarnated for the three security levels no authentication, |
| * authentication, and authentication plus sqlAuthorization, The |
| * latter two has an instance for dbo, and one for an ordinary user, |
| * so there are in all five incarnations of tests. |
| */ |
| private static Test dboCryptoSuite(String framework) |
| { |
| Test tests[] = new Test[SQLAUTHORIZATION+1]; // one per authLevel |
| |
| /* Tests without any authorization active (level == |
| * NOAUTHENTICATION). Note use of no shutdown decorator |
| * variants: Necessary since framework doesn't know |
| * bootPassword. |
| */ |
| BaseTestSuite noauthSuite = |
| new BaseTestSuite("suite: security level=" + |
| secLevelNames[NOAUTHENTICATION]); |
| |
| for (int tNo = 0; tNo < cryptoTests.length; tNo++) { |
| noauthSuite.addTest( |
| TestConfiguration.singleUseDatabaseDecoratorNoShutdown( |
| new DboPowersTest(cryptoTests[tNo], NOAUTHENTICATION, |
| "foo", "bar"))); |
| } |
| |
| tests[NOAUTHENTICATION] = noauthSuite; |
| |
| /* Tests with authentication and sql authorization |
| */ |
| for (int autLev = AUTHENTICATION; |
| autLev <= SQLAUTHORIZATION ; autLev++) { |
| |
| tests[autLev] = wrapCryptoUserTests(autLev); |
| } |
| |
| BaseTestSuite suite = new BaseTestSuite("dboPowers:"+framework); |
| |
| /* run tests with no authentication enabled */ |
| suite.addTest(tests[NOAUTHENTICATION]); |
| |
| /* run test for all users with only authentication enabled */ |
| suite.addTest(tests[AUTHENTICATION]); |
| |
| /* run test for all users with authentication and |
| * sqlAuthorization enabled |
| */ |
| suite.addTest(tests[SQLAUTHORIZATION]); |
| |
| return suite; |
| } |
| |
| /** |
| * Wraps the encryption fixtures in decorators to run with data |
| * base owner and one other valid user. |
| * |
| * @param autLev security context to use |
| */ |
| |
| private static Test wrapCryptoUserTests(int autLev) |
| { |
| // add decorator for different users authenticated |
| BaseTestSuite usersSuite = |
| new BaseTestSuite("usersSuite: security level=" + |
| secLevelNames[autLev]); |
| |
| // First decorate with users, then with authentication. Note |
| // use of no teardown / no shutdown decorator variants: |
| // Necessary since framework doesnt know bootPassword |
| for (int userNo = 0; userNo < users.length; userNo++) { |
| for (int tNo = 0; tNo < cryptoTests.length; tNo++) { |
| Test test = TestConfiguration.changeUserDecorator |
| (new DboPowersTest(cryptoTests[tNo], |
| autLev, |
| users[autLev-1][0], // dbo |
| users[autLev-1][0].concat(pwSuffix)), |
| users[autLev-1][userNo], |
| users[autLev-1][userNo].concat(pwSuffix)); |
| test = DatabasePropertyTestSetup.builtinAuthenticationNoTeardown |
| (test, users[autLev-1], pwSuffix); |
| if (autLev == AUTHENTICATION) { |
| test = TestConfiguration. |
| singleUseDatabaseDecoratorNoShutdown(test); |
| } else { |
| test = TestConfiguration. |
| sqlAuthorizationDecoratorSingleUse(test); |
| } |
| usersSuite.addTest(test); |
| } |
| } |
| return usersSuite; |
| } |
| |
| /** |
| * Enumerates the cryptographic tests. |
| */ |
| final static String[] cryptoTests = { |
| "testEncrypt", "testReEncrypt", "testDecrypt"}; |
| |
| /** |
| * Test database encryption for an already created |
| * database. Note: The test needs to shut down the database for |
| * the single use decorators to work. |
| * |
| * @throws SQLException |
| */ |
| public void testEncrypt() throws SQLException |
| { |
| println("testEncrypt: auth=" + this._authLevel + |
| " user="+getTestConfiguration().getUserName()); |
| |
| // make sure db is created |
| getConnection().close(); |
| |
| // shut down database in preparation for encryption |
| bringDbDown(); |
| |
| // make encryption attempt |
| String user = getTestConfiguration().getUserName(); |
| String password = getTestConfiguration().getUserPassword(); |
| String bootPassword="12345678"; |
| DataSource ds = JDBCDataSource.getDataSource(); |
| |
| JDBCDataSource.setBeanProperty(ds, "connectionAttributes", |
| "dataEncryption=true;bootPassword=" + |
| bootPassword); |
| JDBCDataSource.setBeanProperty(ds, "user", user); |
| JDBCDataSource.setBeanProperty(ds, "password", password); |
| |
| Connection con; |
| try { |
| con = ds.getConnection(); |
| vetCryptoAttempt(ENCRYPT, user, null); |
| } catch (SQLException e) { |
| vetCryptoAttempt(ENCRYPT, user, e); |
| bringDbDown(); |
| return; |
| } |
| |
| try { |
| derby3038(con); |
| } catch (SQLException e) { |
| fail("derby3038 regression: " + e); |
| } |
| |
| // we managed to encrypt: bring db down and up again to verify |
| bringDbDown(); |
| bringDbUp(bootPassword); |
| bringDbDown(); |
| } |
| |
| |
| /** |
| * Test database re-encryption for an already encrypted |
| * database. Note: The test needs to shut down database for the |
| * single use decorators to work. |
| * |
| * @throws SQLException |
| */ |
| public void testReEncrypt() throws SQLException |
| { |
| println("testReEncrypt: auth=" + this._authLevel + |
| " user="+getTestConfiguration().getUserName()); |
| |
| // make sure db is created |
| getConnection().close(); |
| |
| // shut down database in preparation for encryption |
| bringDbDown(); |
| |
| String bootPassword="12345678"; |
| doEncrypt(bootPassword); |
| bringDbDown(); |
| |
| // make re-encryption attempt |
| String user = getTestConfiguration().getUserName(); |
| String password = getTestConfiguration().getUserPassword(); |
| String newBootPassword="87654321"; |
| DataSource ds = JDBCDataSource.getDataSource(); |
| |
| JDBCDataSource.setBeanProperty(ds, "connectionAttributes", |
| "bootPassword=" + bootPassword + |
| ";newBootPassword=" + newBootPassword); |
| JDBCDataSource.setBeanProperty(ds, "user", user); |
| JDBCDataSource.setBeanProperty(ds, "password", password); |
| |
| try { |
| ds.getConnection(); |
| vetCryptoAttempt(ENCRYPT, user, null); |
| } catch (SQLException e) { |
| vetCryptoAttempt(ENCRYPT, user, e); |
| bringDbDown(); |
| return; |
| } |
| |
| // we managed to encrypt: bring db down and up again to verify |
| bringDbDown(); |
| bringDbUp(newBootPassword); |
| bringDbDown(); |
| } |
| |
| /** |
| * Tests that only the DBO can decrypt a database. |
| */ |
| public void testDecrypt() |
| throws SQLException { |
| println("testDecrypt: auth=" + this._authLevel + |
| " user=" + getTestConfiguration().getUserName()); |
| |
| // make sure db is created |
| getConnection().close(); |
| |
| // shut down database in preparation for encryption |
| bringDbDown(); |
| String bootPassword = "conHippo08"; |
| doEncrypt(bootPassword); |
| // shut down database in preparation for decryption |
| bringDbDown(); |
| |
| String user = getTestConfiguration().getUserName(); |
| String password = getTestConfiguration().getUserPassword(); |
| DataSource ds = JDBCDataSource.getDataSource(); |
| JDBCDataSource.setBeanProperty(ds, "connectionAttributes", |
| "bootPassword=" + bootPassword + |
| ";decryptDatabase=true"); |
| JDBCDataSource.setBeanProperty(ds, "user", user); |
| JDBCDataSource.setBeanProperty(ds, "password", password); |
| |
| try { |
| ds.getConnection(); |
| vetCryptoAttempt(DECRYPT, user, null); |
| } catch (SQLException sqle) { |
| vetCryptoAttempt(DECRYPT, user, sqle); |
| return; |
| } finally { |
| bringDbDown(); |
| } |
| |
| // we managed to decrypt: bring db up again to verify |
| bringDbUp(null); |
| bringDbDown(); |
| } |
| |
| /** |
| * Encrypt database, as owner (not testing encryption power here) |
| * @param bootPassword |
| * @throws SQLException |
| */ |
| private void doEncrypt(String bootPassword) throws SQLException |
| { |
| DataSource ds = JDBCDataSource.getDataSource(); |
| JDBCDataSource.setBeanProperty(ds, "connectionAttributes", |
| "dataEncryption=true;bootPassword=" + |
| bootPassword); |
| JDBCDataSource.setBeanProperty(ds, "user", _dbo); |
| JDBCDataSource.setBeanProperty(ds, "password", _dboPassword); |
| ds.getConnection(); |
| } |
| |
| |
| /** |
| * Shut down database, as db owner (not testing that power here) |
| */ |
| private void bringDbDown() |
| { |
| DataSource ds = JDBCDataSource.getDataSource(); |
| JDBCDataSource.setBeanProperty( |
| ds, "connectionAttributes", "shutdown=true"); |
| JDBCDataSource.setBeanProperty(ds, "user", _dbo); |
| JDBCDataSource.setBeanProperty(ds, "password", _dboPassword); |
| try { |
| ds.getConnection(); |
| fail("shutdown failed: expected exception"); |
| } catch (SQLException e) { |
| assertSQLState("database shutdown", "08006", e); |
| } |
| } |
| |
| |
| /** |
| * Boots database back up after cryptographic operation using current user, |
| * should succeed. |
| * |
| * @param bootPassword boot using this bootPassword, may be {@code null} |
| * @throws SQLException |
| */ |
| private void bringDbUp(String bootPassword) throws SQLException |
| { |
| String user = getTestConfiguration().getUserName(); |
| String password = getTestConfiguration().getUserPassword(); |
| DataSource ds = JDBCDataSource.getDataSource(); |
| if (bootPassword != null) { |
| JDBCDataSource.setBeanProperty( |
| ds, "connectionAttributes", "bootPassword=" + bootPassword); |
| } |
| JDBCDataSource.setBeanProperty(ds, "user", user); |
| JDBCDataSource.setBeanProperty(ds, "password", password); |
| ds.getConnection().close(); |
| } |
| |
| /** |
| * Decides if the result of trying to (re-)encrypt or decrypt the database |
| * is compliant with the semantics introduced by DERBY-2264. |
| * |
| * @param encrypt whether we are (re-)encrypting or decrypting |
| * @param user The db user under which we tried to encrypt |
| * @param e Exception caught during attempt, if any |
| */ |
| private void vetCryptoAttempt(boolean encrypt, String user, SQLException e) |
| { |
| vetAttempt(user, e, "08004", encrypt ? "(re)encryption" : "decrypt"); |
| } |
| |
| /** |
| * |
| * Construct suite of tests for hard upgrade database action |
| * |
| * NOTE: there is no real upgrade going on here since the |
| * database is created with the same version, but the checking |
| * is performed nonetheless, which is what we are testing |
| * here. This saves us from having to create a database with |
| * an old version of Derby to test this power. |
| * |
| * @param framework Derby framework name |
| * @return A suite containing the test case for hard upgrade |
| * incarnated for the three security levels no authentication, |
| * authentication, and authentication plus sqlAuthorization, The |
| * latter two has an instance for dbo, and one for an ordinary user, |
| * so there are in all five incarnations of tests. |
| */ |
| private static Test dboHardUpgradeSuite(String framework) |
| { |
| Test tests[] = new Test[SQLAUTHORIZATION+1]; // one per authLevel |
| |
| /* Tests without any authorization active (level == |
| * NOAUTHENTICATION). |
| */ |
| BaseTestSuite noauthSuite = |
| new BaseTestSuite("suite: security level=" + |
| secLevelNames[NOAUTHENTICATION]); |
| noauthSuite.addTest(new DboPowersTest("testHardUpgrade", |
| NOAUTHENTICATION, |
| "foo", "bar")); |
| tests[NOAUTHENTICATION] = noauthSuite; |
| |
| /* First decorate with users, then with authentication. Do this |
| * twice, once for authentication only, and once for |
| * authentication + sqlAuthorization (see extra decorator |
| * added below). |
| */ |
| for (int autLev = AUTHENTICATION; |
| autLev <= SQLAUTHORIZATION ; autLev++) { |
| |
| tests[autLev] = wrapHardUpgradeUserTests(autLev); |
| } |
| |
| BaseTestSuite suite = new BaseTestSuite("dboPowers:"+framework); |
| |
| // A priori, doing a hard upgrade is a no-op here; we are only |
| // interested in checking if we have the powers to do it. However, |
| // sometimes the regression suite is run against a default database |
| // (system/wombat) created by an earlier release to check soft upgrade |
| // modes. To avoid interfering with such usage, we use a |
| // singleUseDatabaseDecorator below, so we avoid accidentally hard |
| // upgrading system/wombat in such runs. The SQLAUTHORIZATION run takes |
| // care of itself since it uses another database anyway. |
| |
| /* run tests with no authentication enabled */ |
| suite.addTest(TestConfiguration.singleUseDatabaseDecorator( |
| tests[NOAUTHENTICATION])); |
| |
| /* run test for all users with only authentication enabled */ |
| suite.addTest(TestConfiguration.singleUseDatabaseDecorator( |
| tests[AUTHENTICATION])); |
| |
| /* run test for all users with authentication and |
| * sqlAuthorization enabled |
| */ |
| suite.addTest( |
| TestConfiguration. |
| sqlAuthorizationDecorator(tests[SQLAUTHORIZATION])); |
| |
| return suite; |
| } |
| |
| /** |
| * Wraps the shutdown fixture in decorators to run with data |
| * base owner and one other valid user. |
| * |
| * @param autLev security context to use |
| */ |
| |
| private static Test wrapHardUpgradeUserTests(int autLev) |
| { |
| // add decorator for different users authenticated |
| BaseTestSuite usersSuite = |
| new BaseTestSuite("usersSuite: security level=" + |
| secLevelNames[autLev]); |
| |
| // First decorate with users, then with |
| for (int userNo = 0; userNo < users.length; userNo++) { |
| usersSuite.addTest |
| (TestConfiguration.changeUserDecorator |
| (new DboPowersTest("testHardUpgrade", |
| autLev, |
| users[autLev-1][0], // dbo |
| users[autLev-1][0].concat(pwSuffix)), |
| users[autLev-1][userNo], |
| users[autLev-1][userNo].concat(pwSuffix))); |
| } |
| |
| return DatabasePropertyTestSetup. |
| builtinAuthentication(usersSuite, users[autLev-1], pwSuffix); |
| } |
| |
| /** |
| * Test database upgrade power enforcement |
| * |
| * @throws SQLException |
| */ |
| public void testHardUpgrade() throws SQLException |
| { |
| println("testHardUpgrade: auth=" + this._authLevel + |
| " user="+getTestConfiguration().getUserName()); |
| |
| // make sure db is created |
| getConnection().close(); |
| // shut it down in preparation for upgrade boot |
| bringDbDown(); |
| |
| String user = getTestConfiguration().getUserName(); |
| String password = getTestConfiguration().getUserPassword(); |
| |
| DataSource ds = JDBCDataSource.getDataSource(); |
| JDBCDataSource.setBeanProperty( |
| ds, "connectionAttributes", "upgrade=true"); |
| JDBCDataSource.setBeanProperty(ds, "user", user); |
| JDBCDataSource.setBeanProperty(ds, "password", password); |
| try { |
| ds.getConnection(); |
| vetHardUpgradeAttempt(user, null); |
| } catch (SQLException e) { |
| vetHardUpgradeAttempt(user, e); |
| } |
| |
| bringDbDown(); |
| } |
| |
| |
| /** |
| * Decide if the result of trying to hard upgrade the database is |
| * compliant with the semantics introduced by DERBY-2264. |
| * |
| * @param user The db user under which we tried to upgrade |
| * @param e Exception caught during attempt, if any |
| */ |
| private void vetHardUpgradeAttempt (String user, SQLException e) |
| { |
| vetAttempt(user, e, "08004", "hard upgrade"); |
| } |
| |
| /** |
| * Decide if the result of trying operation yields expected result. |
| * |
| * @param user The db user under which we tried to upgrade |
| * @param e Exception caught during attempted operation, if any |
| * @param state The expected SQL state if this operation fails due to |
| * insufficient power |
| * @param operation string describing the operation attempted |
| */ |
| private void vetAttempt (String user, SQLException e, |
| String state, String operation) |
| { |
| switch (_authLevel) { |
| case NOAUTHENTICATION: |
| assertEquals(operation + ", no authentication", null, e); |
| break; |
| case AUTHENTICATION: |
| /* We don't enforce dbo powers if only connection level |
| * authentication is used, for now. This leniency was |
| * introduced late in 10.3 release cycle for compatibility |
| * reasons. |
| */ |
| assertEquals(operation + ", authentication", null, e); |
| break; |
| case SQLAUTHORIZATION: |
| if ("TEST_DBO".equals(user)) { |
| assertEquals(operation + ", SQL authorization, db owner", |
| null, e); |
| } else { |
| String msg = operation + ", SQL authorization, not db owner"; |
| assertNotNull( |
| msg + ": succeeded unexpectedly without exeption", e); |
| assertSQLState(msg, state, e); |
| } |
| break; |
| default: |
| fail("test error: invalid authLevel: " + _authLevel); |
| break; |
| } |
| } |
| |
| |
| /** |
| * Make and call a stored procedure which opens a nested |
| * connection to expose DERBY-3038. |
| */ |
| private void derby3038(Connection con) throws SQLException { |
| |
| java.sql.Statement s = con.createStatement(); |
| |
| try { |
| s.executeUpdate |
| ("CREATE PROCEDURE DERBY3038PROC () " + |
| "LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| DboPowersTest.class.getName() + ".derby3038Proc' " + |
| "READS SQL DATA"); |
| s.executeUpdate("CALL DERBY3038PROC()"); |
| } finally { |
| s.close(); |
| } |
| } |
| |
| |
| public static void derby3038Proc() |
| throws SQLException { |
| |
| // Before fixing DERBY-3038 this connect would fail. |
| Connection con = java.sql.DriverManager. |
| getConnection("jdbc:default:connection"); |
| con.close(); |
| } |
| } |
