Search in sources :

Example 1 with ChangeParameterMetaData

use of liquibase.change.ChangeParameterMetaData in project liquibase by liquibase.

the class VerifyChangeClassesTest method minimumRequiredIsValidSql.

@Ignore
@Test
public void minimumRequiredIsValidSql() throws Exception {
    ChangeFactory changeFactory = ChangeFactory.getInstance();
    for (String changeName : changeFactory.getDefinedChanges()) {
        if (changeName.equals("addDefaultValue")) {
            //need to better handle strange "one of defaultValue* is required" logic
            continue;
        }
        if (changeName.equals("changeWithNestedTags") || changeName.equals("sampleChange")) {
            //not a real change
            continue;
        }
        for (Database database : DatabaseFactory.getInstance().getImplementedDatabases()) {
            if (database.getShortName() == null) {
                continue;
            }
            TestState state = new TestState(name.getMethodName(), changeName, database.getShortName(), TestState.Type.SQL);
            state.addComment("Database: " + database.getShortName());
            Change change = changeFactory.create(changeName);
            if (!change.supports(database)) {
                continue;
            }
            if (change.generateStatementsVolatile(database)) {
                continue;
            }
            ChangeMetaData changeMetaData = ChangeFactory.getInstance().getChangeMetaData(change);
            change.setResourceAccessor(new JUnitResourceAccessor());
            for (String paramName : new TreeSet<String>(changeMetaData.getRequiredParameters(database).keySet())) {
                ChangeParameterMetaData param = changeMetaData.getParameters().get(paramName);
                Object paramValue = param.getExampleValue(database);
                String serializedValue;
                serializedValue = formatParameter(paramValue);
                state.addComment("Change Parameter: " + param.getParameterName() + "=" + serializedValue);
                param.setValue(change, paramValue);
            }
            ValidationErrors errors = change.validate(database);
            assertFalse("Validation errors for " + changeMetaData.getName() + " on " + database.getShortName() + ": " + errors.toString(), errors.hasErrors());
            SqlStatement[] sqlStatements = change.generateStatements(database);
            for (SqlStatement statement : sqlStatements) {
                Sql[] sql = SqlGeneratorFactory.getInstance().generateSql(statement, database);
                if (sql == null) {
                    System.out.println("Null sql for " + statement + " on " + database.getShortName());
                } else {
                    for (Sql line : sql) {
                        String sqlLine = line.toSql();
                        assertFalse("Change " + changeMetaData.getName() + " contains 'null' for " + database.getShortName() + ": " + sqlLine, sqlLine.contains(" null "));
                        state.addValue(sqlLine + ";");
                    }
                }
            }
            state.test();
        }
    }
}
Also used : ValidationErrors(liquibase.exception.ValidationErrors) JUnitResourceAccessor(liquibase.test.JUnitResourceAccessor) Change(liquibase.change.Change) Sql(liquibase.sql.Sql) SqlStatement(liquibase.statement.SqlStatement) ChangeFactory(liquibase.change.ChangeFactory) Database(liquibase.database.Database) ChangeParameterMetaData(liquibase.change.ChangeParameterMetaData) ChangeMetaData(liquibase.change.ChangeMetaData) Ignore(org.junit.Ignore) Test(org.junit.Test) AbstractVerifyTest(liquibase.verify.AbstractVerifyTest)

Example 2 with ChangeParameterMetaData

use of liquibase.change.ChangeParameterMetaData in project liquibase by liquibase.

the class VerifyChangeClassesTest method lessThanMinimumFails.

/**
 * For every combination of database (e.g. Oracle) and change (e.g. DropForeignKeyConstraint),
 * construct a change object with some example values. For every required parameter, verify that
 * removing it causes the change object to change its state to "hasErrors".
 * @throws Exception
 */
@Test
public void lessThanMinimumFails() throws Exception {
    ChangeFactory changeFactory = Scope.getCurrentScope().getSingleton(ChangeFactory.class);
    for (String changeName : changeFactory.getDefinedChanges()) {
        for (Database database : DatabaseFactory.getInstance().getImplementedDatabases()) {
            if (database.getShortName() == null) {
                continue;
            }
            if ("createProcedure".equals(changeName)) {
                // need to better handle strange "one of path or body is required" logic
                continue;
            }
            Change change = changeFactory.create(changeName);
            if (!change.supports(database)) {
                continue;
            }
            if (change.generateStatementsVolatile(database)) {
                continue;
            }
            ChangeMetaData changeMetaData = Scope.getCurrentScope().getSingleton(ChangeFactory.class).getChangeMetaData(change);
            ArrayList<String> requiredParams = new ArrayList<String>(changeMetaData.getRequiredParameters(database).keySet());
            for (String paramName : requiredParams) {
                ChangeParameterMetaData param = changeMetaData.getParameters().get(paramName);
                Object paramValue = param.getExampleValue(database);
                param.setValue(change, paramValue);
            }
            for (int i = 0; i < requiredParams.size(); i++) {
                String paramToRemove = requiredParams.get(i);
                ChangeParameterMetaData paramToRemoveMetadata = changeMetaData.getParameters().get(paramToRemove);
                Object currentValue = paramToRemoveMetadata.getCurrentValue(change);
                paramToRemoveMetadata.setValue(change, null);
                assertTrue("No errors even with " + changeMetaData.getName() + " with a null " + paramToRemove + " on " + database.getShortName(), change.validate(database).hasErrors());
                paramToRemoveMetadata.setValue(change, currentValue);
            }
        }
    }
}
Also used : ChangeFactory(liquibase.change.ChangeFactory) Db2zDatabase(liquibase.database.core.Db2zDatabase) Database(liquibase.database.Database) MockDatabase(liquibase.database.core.MockDatabase) ChangeParameterMetaData(liquibase.change.ChangeParameterMetaData) Change(liquibase.change.Change) ChangeMetaData(liquibase.change.ChangeMetaData) AbstractVerifyTest(liquibase.verify.AbstractVerifyTest) Test(org.junit.Test)

Example 3 with ChangeParameterMetaData

use of liquibase.change.ChangeParameterMetaData in project liquibase by liquibase.

the class VerifyChangeClassesTest method compareGeneratedSqlWithExpectedSqlForMinimalChangesets.

@Test
public void compareGeneratedSqlWithExpectedSqlForMinimalChangesets() throws Exception {
    ChangeFactory changeFactory = Scope.getCurrentScope().getSingleton(ChangeFactory.class);
    for (String changeName : changeFactory.getDefinedChanges()) {
        if ("addDefaultValue".equals(changeName)) {
            // need to better handle strange "one of defaultValue* is required" logic
            continue;
        }
        if ("createProcedure".equals(changeName)) {
            // need to better handle strange "one of path or body is required" logic
            continue;
        }
        if ("changeWithNestedTags".equals(changeName) || "sampleChange".equals(changeName) || "output".equals(changeName) || "tagDatabase".equals(changeName)) {
            // not a real change
            continue;
        }
        for (Database database : DatabaseFactory.getInstance().getImplementedDatabases()) {
            if (database.getShortName() == null || database instanceof MockDatabase) {
                continue;
            }
            TestState state = new TestState(name.getMethodName(), changeName, database.getShortName(), TestState.Type.SQL);
            state.addComment("Database: " + database.getShortName());
            Change change = changeFactory.create(changeName);
            if (!change.supports(database)) {
                continue;
            }
            if (change.generateStatementsVolatile(database)) {
                continue;
            }
            ChangeMetaData changeMetaData = Scope.getCurrentScope().getSingleton(ChangeFactory.class).getChangeMetaData(change);
            // Prepare a list of required parameters, plus a few extra for complicated cases (e.g. where at least
            // one of two parameters in a group is required.
            TreeSet<String> requiredParams = new TreeSet<String>(changeMetaData.getRequiredParameters(database).keySet());
            /* dropColumn allows either one column or a list of columns; we choose to test with a single column. */
            if ("dropColumn".equalsIgnoreCase(changeName))
                requiredParams.add("columnName");
            /* When testing table and column remarks, do not test with an empty remark. */
            if ("setColumnRemarks".equalsIgnoreCase(changeName))
                requiredParams.add("remarks");
            if ("setTableRemarks".equalsIgnoreCase(changeName))
                requiredParams.add("remarks");
            if ("createView".equalsIgnoreCase(changeName))
                requiredParams.add("selectQuery");
            /* ALTER SEQUENCE should change at least one property
                 * hsqldb/h2 do not support incrementBy. */
            if ("alterSequence".equalsIgnoreCase(changeName)) {
                if ("h2".equalsIgnoreCase(database.getShortName())) {
                    requiredParams.add("ordered");
                } else if ("hsqldb".equalsIgnoreCase(database.getShortName())) {
                    requiredParams.add("minValue");
                } else {
                    requiredParams.add("incrementBy");
                }
            }
            if ("dropNotNullConstraint".equalsIgnoreCase(changeName)) {
                if ("oracle".equalsIgnoreCase(database.getShortName())) {
                    // oracle must have either columnName or constraintName
                    requiredParams.add("columnName");
                }
            }
            if (database instanceof Db2zDatabase && "addLookupTable".equalsIgnoreCase(changeName)) {
                requiredParams.add("newColumnDataType");
            }
            // For every required parameter of the change, fetch an example value.
            for (String paramName : requiredParams) {
                ChangeParameterMetaData param = changeMetaData.getParameters().get(paramName);
                Object paramValue = param.getExampleValue(database);
                String serializedValue;
                serializedValue = formatParameter(paramValue);
                state.addComment("Change Parameter: " + param.getParameterName() + "=" + serializedValue);
                param.setValue(change, paramValue);
            }
            ValidationErrors errors = change.validate(database);
            assertFalse("Validation errors for " + changeMetaData.getName() + " on " + database.getShortName() + ": " + errors.toString(), errors.hasErrors());
            SqlStatement[] sqlStatements = {};
            try {
                sqlStatements = change.generateStatements(database);
            } catch (UnexpectedLiquibaseException ex) {
                if (ex.getCause() instanceof IOException) {
                // Do nothing. I/O exceptions at this point come from the example value "my/path/file.sql"
                // for the <sql> type change and can be safely ignored.
                }
            }
            for (SqlStatement statement : sqlStatements) {
                Sql[] sql = SqlGeneratorFactory.getInstance().generateSql(statement, database);
                if (sql == null) {
                    Scope.getCurrentScope().getLog(getClass()).severe("Null sql for " + statement + " on " + database.getShortName());
                } else {
                    for (Sql line : sql) {
                        String sqlLine = line.toSql();
                        assertFalse("Change " + changeMetaData.getName() + " contains 'null' for " + database.getShortName() + ": " + sqlLine, sqlLine.contains(" null "));
                        state.addValue(sqlLine + ";");
                    }
                }
            }
            state.test();
        }
    }
}
Also used : ValidationErrors(liquibase.exception.ValidationErrors) Change(liquibase.change.Change) IOException(java.io.IOException) Sql(liquibase.sql.Sql) SqlStatement(liquibase.statement.SqlStatement) ChangeFactory(liquibase.change.ChangeFactory) Db2zDatabase(liquibase.database.core.Db2zDatabase) Db2zDatabase(liquibase.database.core.Db2zDatabase) Database(liquibase.database.Database) MockDatabase(liquibase.database.core.MockDatabase) ChangeParameterMetaData(liquibase.change.ChangeParameterMetaData) MockDatabase(liquibase.database.core.MockDatabase) UnexpectedLiquibaseException(liquibase.exception.UnexpectedLiquibaseException) ChangeMetaData(liquibase.change.ChangeMetaData) AbstractVerifyTest(liquibase.verify.AbstractVerifyTest) Test(org.junit.Test)

Example 4 with ChangeParameterMetaData

use of liquibase.change.ChangeParameterMetaData in project liquibase by liquibase.

the class VerifyChangeClassesTest method extraParamsIsValidSql.

@Ignore
@Test
public void extraParamsIsValidSql() throws Exception {
    ChangeFactory changeFactory = Scope.getCurrentScope().getSingleton(ChangeFactory.class);
    for (String changeName : changeFactory.getDefinedChanges()) {
        if ("addDefaultValue".equals(changeName)) {
            // need to better handle strange "one of defaultValue* is required" logic
            continue;
        }
        if ("createProcedure".equals(changeName)) {
            // need to better handle strange "one of path or body is required" logic
            continue;
        }
        for (Database database : DatabaseFactory.getInstance().getImplementedDatabases()) {
            if (database.getShortName() == null) {
                continue;
            }
            TestState state = new TestState(name.getMethodName(), changeName, database.getShortName(), TestState.Type.SQL);
            state.addComment("Database: " + database.getShortName());
            Change baseChange = changeFactory.create(changeName);
            if (!baseChange.supports(database)) {
                continue;
            }
            if (baseChange.generateStatementsVolatile(database)) {
                continue;
            }
            ChangeMetaData changeMetaData = Scope.getCurrentScope().getSingleton(ChangeFactory.class).getChangeMetaData(baseChange);
            ArrayList<String> optionalParameters = new ArrayList<String>(changeMetaData.getOptionalParameters(database).keySet());
            Collections.sort(optionalParameters);
            List<List<String>> paramLists = powerSet(optionalParameters);
            Collections.sort(paramLists, new Comparator<List<String>>() {

                @Override
                public int compare(List<String> o1, List<String> o2) {
                    int comp = Integer.valueOf(o1.size()).compareTo(o2.size());
                    if (comp == 0) {
                        comp = StringUtil.join(o1, ",").compareTo(StringUtil.join(o2, ","));
                    }
                    return comp;
                }
            });
            for (List<String> permutation : paramLists) {
                Change change = changeFactory.create(changeName);
                // 
                for (String paramName : new TreeSet<String>(changeMetaData.getRequiredParameters(database).keySet())) {
                    ChangeParameterMetaData param = changeMetaData.getParameters().get(paramName);
                    Object paramValue = param.getExampleValue(database);
                    String serializedValue;
                    serializedValue = formatParameter(paramValue);
                    state.addComment("Required Change Parameter: " + param.getParameterName() + "=" + serializedValue);
                    param.setValue(change, paramValue);
                }
                for (String paramName : permutation) {
                    ChangeParameterMetaData param = changeMetaData.getParameters().get(paramName);
                    if (!param.supports(database)) {
                        continue;
                    }
                    Object paramValue = param.getExampleValue(database);
                    String serializedValue;
                    serializedValue = formatParameter(paramValue);
                    state.addComment("Optional Change Parameter: " + param.getParameterName() + "=" + serializedValue);
                    param.setValue(change, paramValue);
                }
                ValidationErrors errors = change.validate(database);
                assertFalse("Validation errors for " + changeMetaData.getName() + " on " + database.getShortName() + ": " + errors.toString(), errors.hasErrors());
            // 
            // SqlStatement[] sqlStatements = change.generateStatements(database);
            // for (SqlStatement statement : sqlStatements) {
            // Sql[] sql = SqlGeneratorFactory.getInstance().generateSql(statement, database);
            // if (sql == null) {
            // System.out.println("Null sql for "+statement+" on "+database.getShortName());
            // } else {
            // for (Sql line : sql) {
            // state.addValue(line.toSql()+";");
            // }
            // }
            // }
            // state.test();
            }
        }
    }
}
Also used : ValidationErrors(liquibase.exception.ValidationErrors) Change(liquibase.change.Change) ChangeFactory(liquibase.change.ChangeFactory) Db2zDatabase(liquibase.database.core.Db2zDatabase) Database(liquibase.database.Database) MockDatabase(liquibase.database.core.MockDatabase) ChangeParameterMetaData(liquibase.change.ChangeParameterMetaData) ChangeMetaData(liquibase.change.ChangeMetaData) Ignore(org.junit.Ignore) AbstractVerifyTest(liquibase.verify.AbstractVerifyTest) Test(org.junit.Test)

Aggregations

Change (liquibase.change.Change)4 ChangeFactory (liquibase.change.ChangeFactory)4 ChangeMetaData (liquibase.change.ChangeMetaData)4 ChangeParameterMetaData (liquibase.change.ChangeParameterMetaData)4 Database (liquibase.database.Database)4 AbstractVerifyTest (liquibase.verify.AbstractVerifyTest)4 Test (org.junit.Test)4 Db2zDatabase (liquibase.database.core.Db2zDatabase)3 MockDatabase (liquibase.database.core.MockDatabase)3 ValidationErrors (liquibase.exception.ValidationErrors)3 Sql (liquibase.sql.Sql)2 SqlStatement (liquibase.statement.SqlStatement)2 Ignore (org.junit.Ignore)2 IOException (java.io.IOException)1 UnexpectedLiquibaseException (liquibase.exception.UnexpectedLiquibaseException)1 JUnitResourceAccessor (liquibase.test.JUnitResourceAccessor)1