MID-8842 upgrade, run-sql tests, still failing

tools/ninja/src/main/java/com/evolveum/midpoint/ninja/action/RunSqlOptions.java

@@ -78,6 +78,8 @@ public enum Mode {
     @Parameter(names = { P_RESULT }, descriptionKey = "runSql.result")
     private boolean result;
 
+    private File scriptsDirectory;
+
     public List<File> getScripts() {
         return scripts;
     }

tools/ninja/src/test/java/com/evolveum/midpoint/ninja/NinjaContextTest.java

@@ -37,13 +37,13 @@ public void setupRepositoryViaMidpointHome() throws Exception {
 
         ConnectionOptions options = NinjaUtils.getOptions(jc.getObjects(), ConnectionOptions.class);
 
-        NinjaContext ctx = new NinjaContext(List.of(options), NinjaApplicationContextLevel.FULL_REPOSITORY);
+        try (NinjaContext ctx = new NinjaContext(List.of(options), NinjaApplicationContextLevel.FULL_REPOSITORY)) {
+            RepositoryService service = ctx.getRepository();
 
-        RepositoryService service = ctx.getRepository();
+            OperationResult result = new OperationResult("get user");
+            PrismObject obj = service.getObject(UserType.class, SystemObjectsType.USER_ADMINISTRATOR.value(), null, result);
 
-        OperationResult result = new OperationResult("get user");
-        PrismObject obj = service.getObject(UserType.class, SystemObjectsType.USER_ADMINISTRATOR.value(), null, result);
-
-        System.out.println(obj.debugDump());
+            System.out.println(obj.debugDump());
+        }
     }
 }

tools/ninja/src/test/java/com/evolveum/midpoint/ninja/upgrade/BaseUpgradeTest.java

@@ -4,39 +4,42 @@
 import java.net.URI;
 import java.sql.Connection;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import javax.sql.DataSource;
 
-import com.evolveum.midpoint.ninja.action.BaseOptions;
-
-import com.evolveum.midpoint.ninja.action.ConnectionOptions;
-
-import com.evolveum.midpoint.ninja.action.RunSqlAction;
-import com.evolveum.midpoint.ninja.action.RunSqlOptions;
-import com.evolveum.midpoint.ninja.impl.NinjaContext;
-
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
 import org.apache.commons.io.FileUtils;
 import org.assertj.core.api.Assertions;
 import org.jetbrains.annotations.NotNull;
+import org.postgresql.Driver;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.datasource.SingleConnectionDataSource;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 
+import com.evolveum.midpoint.ninja.action.BaseOptions;
+import com.evolveum.midpoint.ninja.action.ConnectionOptions;
+import com.evolveum.midpoint.ninja.action.RunSqlAction;
+import com.evolveum.midpoint.ninja.action.RunSqlOptions;
+import com.evolveum.midpoint.ninja.impl.NinjaContext;
 import com.evolveum.midpoint.repo.sqlbase.DataSourceFactory;
 import com.evolveum.midpoint.test.AbstractIntegrationTest;
 
 public abstract class BaseUpgradeTest extends AbstractIntegrationTest {
 
-    protected static final String NINJA_TESTS_USER = "ninja_upgrade_tests";
+    public static final String NINJA_TESTS_USER = "ninja_upgrade_tests";
+
+    public static final File UPGRADE_MIDPOINT_HOME = new File("./target/midpoint-home-upgrade");
 
-    protected static final File UPGRADE_MIDPOINT_HOME = new File("./target/midpoint-home-upgrade");
+    public static final String CURRENT_SCHEMA_CHANGE_NUMBER = "15";
+
+    public static final String CURRENT_AUDIT_SCHEMA_CHANGE_NUMBER = "4";
 
     @Autowired
     protected DataSourceFactory dataSourceFactory;
@@ -47,32 +50,47 @@ public abstract class BaseUpgradeTest extends AbstractIntegrationTest {
 
     protected HikariDataSource ninjaTestDatabase;
 
-    protected String ninjaTestsJdbcUrl;
+    private String jdbcUrlPrefix;
 
     @BeforeClass
     public void beforeClass() throws Exception {
         FileUtils.forceMkdir(UPGRADE_MIDPOINT_HOME);
         FileUtils.copyFileToDirectory(new File("./src/test/resources/upgrade/midpoint-home/config.xml"), UPGRADE_MIDPOINT_HOME);
 
-        recreateEmptyTestDatabase();
-
-        HikariConfig config = new HikariConfig();
-        config.setUsername(NINJA_TESTS_USER);
-        config.setPassword(NINJA_TESTS_USER);
-        config.setAutoCommit(true);
-
         String jdbcUrl = dataSourceFactory.configuration().getJdbcUrl().replaceFirst("jdbc:", "");
         URI jdbcURI = URI.create(jdbcUrl);
 
-        ninjaTestsJdbcUrl = "jdbc:postgresql://" + jdbcURI.getHost() + ":" + jdbcURI.getPort() + "/" + NINJA_TESTS_USER;
-        config.setJdbcUrl(ninjaTestsJdbcUrl);
+        jdbcUrlPrefix = "jdbc:postgresql://" + jdbcURI.getHost() + ":" + jdbcURI.getPort();
+
+        recreateEmptyNinjaTestsDatabase();
 
-        ninjaTestDatabase = new HikariDataSource(config);
+        ninjaTestDatabase = createHikariDataSource(getJdbcUrlForNinjaTestsUser(), NINJA_TESTS_USER, NINJA_TESTS_USER);
 
         runWith(ninjaTestDatabase, jdbcTemplate -> jdbcTemplate.execute("DROP SCHEMA IF EXISTS public CASCADE;"));
     }
 
-    protected void recreateEmptyTestDatabase() throws SQLException {
+    protected HikariDataSource createHikariDataSource(String url, String username, String password) {
+        HikariConfig config = new HikariConfig();
+        config.setDriverClassName(Driver.class.getName());
+        config.setJdbcUrl(url);
+        config.setUsername(username);
+        config.setPassword(password);
+        config.setAutoCommit(true);
+        config.setMinimumIdle(1);
+        config.setMaximumPoolSize(3);
+
+        return new HikariDataSource(config);
+    }
+
+    protected String getJdbcUrlForNinjaTestsUser() {
+        return getJdbcUrlForDatabase(NINJA_TESTS_USER);
+    }
+
+    protected String getJdbcUrlForDatabase(String database) {
+        return jdbcUrlPrefix + "/" + database;
+    }
+
+    protected void recreateEmptyNinjaTestsDatabase() throws SQLException {
         runWith(midpointDatasource, jdbcTemplate -> {
             jdbcTemplate.execute("DROP DATABASE IF EXISTS " + NINJA_TESTS_USER + ";");
             jdbcTemplate.execute("DROP USER IF EXISTS " + NINJA_TESTS_USER + ";");
@@ -83,6 +101,13 @@ protected void recreateEmptyTestDatabase() throws SQLException {
         });
     }
 
+    protected List<File> getCreateScripts(File scriptsDirectory) {
+        List<File> scripts = new ArrayList<>();
+        RunSqlOptions.Mode.REPOSITORY.updateScripts.forEach(f -> scripts.add(new File(scriptsDirectory, f.getName())));
+        RunSqlOptions.Mode.AUDIT.updateScripts.forEach(f -> scripts.add(new File(scriptsDirectory, f.getName())));
+        return scripts;
+    }
+
     protected void recreateSchema(@NotNull File scriptsDirectory) throws Exception {
         runWith(ninjaTestDatabase, jdbcTemplate -> jdbcTemplate.execute("DROP SCHEMA IF EXISTS public;"));
 
@@ -91,12 +116,11 @@ protected void recreateSchema(@NotNull File scriptsDirectory) throws Exception {
         ConnectionOptions connectionOptions = new ConnectionOptions();
         connectionOptions.setMidpointHome(UPGRADE_MIDPOINT_HOME.getPath());
 
-        Assertions.assertThat(ninjaTestsJdbcUrl).isNotNull();
-        connectionOptions.setUrl(ninjaTestsJdbcUrl);
+        Assertions.assertThat(getJdbcUrlForNinjaTestsUser()).isNotNull();
+        connectionOptions.setUrl(getJdbcUrlForNinjaTestsUser());
 
         RunSqlOptions runSqlOptions = new RunSqlOptions();
-//        runSqlOptions.setScriptsDirectory(scriptsDirectory);
-//        runSqlOptions
+        runSqlOptions.setScripts(getCreateScripts(scriptsDirectory));
 
         List<Object> options = List.of(baseOptions, connectionOptions, runSqlOptions);
 
@@ -149,6 +173,14 @@ protected Long countTablesInPublicSchema() throws SQLException {
                 jdbcTemplate.queryForObject("SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = 'public'", Long.class));
     }
 
+    protected String getAuditSchemaChangeNumber(@NotNull DataSource dataSource) throws SQLException {
+        return getGlobalMetadataValue(ninjaTestDatabase, "schemaAuditChangeNumber");
+    }
+
+    protected String getSchemaChangeNumber(@NotNull DataSource dataSource) throws SQLException {
+        return getGlobalMetadataValue(ninjaTestDatabase, "schemaChangeNumber");
+    }
+
     protected String getGlobalMetadataValue(@NotNull DataSource dataSource, @NotNull String key) throws SQLException {
         return runWithResult(dataSource, jdbcTemplate ->
                 jdbcTemplate.queryForObject("SELECT value FROM m_global_metadata WHERE name=?", new Object[] { key }, String.class));

tools/ninja/src/test/java/com/evolveum/midpoint/ninja/upgrade/CreateDatabaseTest.java

@@ -0,0 +1,121 @@
+package com.evolveum.midpoint.ninja.upgrade;
+
+import java.io.File;
+import java.sql.SQLException;
+import java.util.List;
+
+import com.zaxxer.hikari.HikariDataSource;
+import org.assertj.core.api.Assertions;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Listeners;
+import org.testng.annotations.Test;
+
+import com.evolveum.midpoint.ninja.action.BaseOptions;
+import com.evolveum.midpoint.ninja.action.ConnectionOptions;
+import com.evolveum.midpoint.ninja.action.RunSqlAction;
+import com.evolveum.midpoint.ninja.action.RunSqlOptions;
+import com.evolveum.midpoint.ninja.impl.NinjaContext;
+
+@ContextConfiguration(locations = "classpath:ctx-ninja-test.xml")
+@DirtiesContext
+@Listeners({ com.evolveum.midpoint.tools.testng.AlphabeticalMethodInterceptor.class })
+public class CreateDatabaseTest extends BaseUpgradeTest {
+
+    public static final File UPGRADE_RESOURCES = new File("./src/test/resources/upgrade");
+    public static final String CREATE_MIDPOINT_SCHEMA_TEST = "create_midpoint_schema_test";
+
+    @BeforeClass
+    @Override
+    public void beforeClass() throws Exception {
+        super.beforeClass();
+
+        dropUserAndDatabaseIfExists();
+    }
+
+    @Override
+    public void afterClass() throws SQLException {
+        dropUserAndDatabaseIfExists();
+
+        super.afterClass();
+    }
+
+    private void dropUserAndDatabaseIfExists() throws SQLException {
+        runWith(ninjaTestDatabase, jdbcTemplate -> jdbcTemplate.execute(
+                "DROP DATABASE IF EXISTS " + CREATE_MIDPOINT_SCHEMA_TEST + ";\n"
+                        + "DROP USER IF EXISTS " + CREATE_MIDPOINT_SCHEMA_TEST + ";"));
+    }
+
+    @Test
+    public void test100CreateUserAndDatabase() throws Exception {
+        BaseOptions baseOptions = new BaseOptions();
+        baseOptions.setVerbose(true);
+
+        final File FAKE_MIDPOINT_HOME = new File("./target/midpoint-home-upgrade-non-existing");
+
+        ConnectionOptions connectionOptions = new ConnectionOptions();
+        connectionOptions.setMidpointHome(FAKE_MIDPOINT_HOME.getPath());
+
+        RunSqlOptions runSqlOptions = new RunSqlOptions();
+        runSqlOptions.setJdbcUrl(getJdbcUrlForNinjaTestsUser());
+        runSqlOptions.setJdbcUsername(NINJA_TESTS_USER);
+        runSqlOptions.setJdbcPassword(NINJA_TESTS_USER);
+        runSqlOptions.setScripts(List.of(new File(UPGRADE_RESOURCES, "sql/create-database.sql")));
+        runSqlOptions.setResult(true);
+
+        List<Object> options = List.of(baseOptions, connectionOptions, runSqlOptions);
+
+        RunSqlAction action = new RunSqlAction();
+        try (NinjaContext context = new NinjaContext(options, action.getApplicationContextLevel(options))) {
+            action.init(context, runSqlOptions);
+
+            action.execute();
+        }
+
+        Assertions.assertThat(FAKE_MIDPOINT_HOME.exists()).isFalse();
+
+        try (HikariDataSource dataSource = createHikariDataSource(getJdbcUrlForDatabase(CREATE_MIDPOINT_SCHEMA_TEST), CREATE_MIDPOINT_SCHEMA_TEST, CREATE_MIDPOINT_SCHEMA_TEST)) {
+            Object one = runWithResult(dataSource, jdbcTemplate -> jdbcTemplate.queryForObject("select 1", Long.class));
+            Assertions.assertThat(one).isEqualTo(1L);
+        }
+    }
+
+    @Test
+    public void test200CreateSchema() throws Exception {
+        BaseOptions baseOptions = new BaseOptions();
+        baseOptions.setVerbose(true);
+
+        final File FAKE_MIDPOINT_HOME = new File("./target/midpoint-home-upgrade-non-existing");
+
+        ConnectionOptions connectionOptions = new ConnectionOptions();
+        connectionOptions.setMidpointHome(FAKE_MIDPOINT_HOME.getPath());
+
+        final String jdbcUrl = getJdbcUrlForDatabase(CREATE_MIDPOINT_SCHEMA_TEST);
+        RunSqlOptions runSqlOptions = new RunSqlOptions();
+        runSqlOptions.setJdbcUrl(jdbcUrl);
+        runSqlOptions.setJdbcUsername(CREATE_MIDPOINT_SCHEMA_TEST);
+        runSqlOptions.setJdbcPassword(CREATE_MIDPOINT_SCHEMA_TEST);
+        runSqlOptions.setScripts(List.of(
+                new File("../../config/sql/native-new/postgres-new.sql"),
+                new File("../../config/sql/native-new/postgres-new-quartz.sql"),
+                new File("../../config/sql/native-new/postgres-new-audit.sql")));
+
+        List<Object> options = List.of(baseOptions, connectionOptions, runSqlOptions);
+
+        RunSqlAction action = new RunSqlAction();
+        try (NinjaContext context = new NinjaContext(options, action.getApplicationContextLevel(options))) {
+            action.init(context, runSqlOptions);
+
+            action.execute();
+        }
+
+        Assertions.assertThat(FAKE_MIDPOINT_HOME.exists()).isFalse();
+
+        try (HikariDataSource dataSource = createHikariDataSource(jdbcUrl, CREATE_MIDPOINT_SCHEMA_TEST, CREATE_MIDPOINT_SCHEMA_TEST)) {
+            Assertions.assertThat(getSchemaChangeNumber(dataSource)).isEqualTo(CURRENT_SCHEMA_CHANGE_NUMBER);
+            Assertions.assertThat(getAuditSchemaChangeNumber(dataSource)).isEqualTo(CURRENT_AUDIT_SCHEMA_CHANGE_NUMBER);
+        }
+    }
+}