Expand test coverage and fix some small issues with the HSQLDB support

embedded-db-junit-liquibase/src/main/java/org/zapodot/junit/db/plugin/LiquibaseInitializer.java

@@ -104,7 +104,7 @@ public Builder withContexts(final String... contexts) {
          * @return the same builder instance
          */
         public Builder addDatabaseNameToContext() {
-            this.addNameToContext = false;
+            this.addNameToContext = true;
             return this;
         }
 
@@ -189,7 +189,7 @@ public void connectionMade(final String name, final Connection connection) {
                     String.format("CREATE SCHEMA IF NOT EXISTS %s", defaultSchemaName))) {
                 preparedStatement.execute();
             } catch (SQLException e) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException("Could not create schema \"" + defaultSchemaName + "\"", e);
             }
         }
 
@@ -204,7 +204,7 @@ public void connectionMade(final String name, final Connection connection) {
                 liquibase.update(changesLimit, contexts, labelExpression);
             }
         } catch (LiquibaseException e) {
-            throw new RuntimeException("An exception occurred while applying Liquibase changesets", e);
+            throw new IllegalArgumentException("An exception occurred while applying Liquibase changesets", e);
         }
     }
 
@@ -218,7 +218,7 @@ private Liquibase createLiquibase(final Connection connection) {
             }
             return new Liquibase(changeLog, resourceAccessor, database);
         } catch (LiquibaseException e) {
-            throw new RuntimeException("Could not initialize Liquibase", e);
+            throw new IllegalStateException("Could not initialize Liquibase", e);
         }
     }
 

embedded-db-junit-liquibase/src/test/java/org/zapodot/junit/db/plugin/LiquibaseInitializerIllegalMigrationTest.java

@@ -0,0 +1,25 @@
+package org.zapodot.junit.db.plugin;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.zapodot.junit.db.EmbeddedDatabaseRule;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class LiquibaseInitializerIllegalMigrationTest {
+
+    @Rule
+    public final EmbeddedDatabaseRule databaseRule = EmbeddedDatabaseRule.hsqldb().build();
+
+    @Test(expected = IllegalArgumentException.class)
+    public void connectionMade() throws SQLException {
+        final LiquibaseInitializer liquibaseInitializer = LiquibaseInitializer.builder()
+                                                                              .withChangelogResource(
+                                                                                      "example-illegal.xml")
+                                                                              .build();
+        try (final Connection connection = databaseRule.getConnection()) {
+            liquibaseInitializer.connectionMade("name", connection);
+        }
+    }
+}

embedded-db-junit-liquibase/src/test/java/org/zapodot/junit/db/plugin/LiquibaseInitializerWithDbNameAddedToContextsTest.java → embedded-db-junit-liquibase/src/test/java/org/zapodot/junit/db/plugin/LiquibaseInitializerWithDbNameAddedToContextsH2Test.java

@@ -3,6 +3,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.zapodot.junit.db.EmbeddedDatabaseRule;
+import org.zapodot.junit.db.plugin.dao.RoleDao;
 
 import java.sql.Connection;
 import java.sql.PreparedStatement;
@@ -15,12 +16,15 @@
 /**
  * @author zapodot
  */
-public class LiquibaseInitializerWithDbNameAddedToContextsTest {
+public class LiquibaseInitializerWithDbNameAddedToContextsH2Test {
+
+    private static final String DATABASE_NAME = "myDb";
 
     @Rule
     public final EmbeddedDatabaseRule embeddedDatabaseRule = EmbeddedDatabaseRule
-            .builder()
+            .h2()
             .withMode(EmbeddedDatabaseRule.CompatibilityMode.MSSQLServer)
+            .withName(DATABASE_NAME)
             .initializedByPlugin(LiquibaseInitializer.builder()
                     .withChangelogResource("example-changelog.sql")
                     .addDatabaseNameToContext()
@@ -30,16 +34,8 @@ public class LiquibaseInitializerWithDbNameAddedToContextsTest {
     @Test
     public void testFindRolesInsertedByLiquibase() throws Exception {
         try(final Connection connection = embeddedDatabaseRule.getConnection()) {
-            try(final PreparedStatement statement = connection.prepareStatement("Select * FROM ROLE r INNER JOIN USERROLE ur on r.ID = ur.ROLE_ID INNER JOIN USER u on ur.USER_ID = u.ID where u.NAME = ?")) {
-                statement.setString(1, "Ada");
-                try(final ResultSet resultSet = statement.executeQuery()) {
-                    final List<String> roles = new LinkedList<>();
-                    while(resultSet.next()) {
-                        roles.add(resultSet.getString("name"));
-                    }
-                    assertEquals(2, roles.size());
-                }
-            }
+            final List<String> rolesForUser = new RoleDao(connection).rolesForUser("Ada");
+            assertEquals(0, rolesForUser.size());
         }
 
     }

embedded-db-junit-liquibase/src/test/java/org/zapodot/junit/db/plugin/LiquibaseInitializerWithDbNameAddedToContextsHyperSQLTest.java

@@ -0,0 +1,44 @@
+package org.zapodot.junit.db.plugin;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.zapodot.junit.db.EmbeddedDatabaseRule;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author zapodot
+ */
+public class LiquibaseInitializerWithDbNameAddedToContextsHyperSQLTest {
+
+    private static final String DATABASE_NAME = "myDb";
+
+    @Rule
+    public final EmbeddedDatabaseRule embeddedDatabaseRule = EmbeddedDatabaseRule
+            .hsqldb()
+            .withMode(EmbeddedDatabaseRule.CompatibilityMode.MSSQLServer)
+            .withName(DATABASE_NAME)
+            .initializedByPlugin(LiquibaseInitializer.builder()
+                                                     .withChangelogResource("example-changelog.xml")
+                                                     .addDatabaseNameToContext()
+                                                     .build())
+            .build();
+
+    @Test
+    public void testFindRolesInsertedByLiquibase() throws Exception {
+        try (final Connection connection = embeddedDatabaseRule.getConnection();
+             final PreparedStatement preparedStatement = connection.prepareStatement(
+                     "SELECT r.name from role r inner join userrole ur on r.id = ur.role_id inner join user u on u.id=ur.user_id where u.username = ?")) {
+            preparedStatement.setString(1, "Ada");
+            try (final ResultSet resultSet = preparedStatement.executeQuery()) {
+                assertFalse(resultSet.next());
+            }
+        }
+
+    }
+
+}

embedded-db-junit-liquibase/src/test/resources/example-changelog.xml

@@ -23,5 +23,25 @@
         </addColumn>
     </changeSet>
 
-
+    <changeSet id="createRole" author="zapodot" labels="base">
+        <createTable tableName="role">
+            <column name="id" type="int" autoIncrement="true">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="name" type="varchar(255)">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+    </changeSet>
+    <changeSet id="createUserRole" author="zapodot" labels="base" context="myDb">
+        <createTable tableName="userrole">
+            <column name="user_id" type="int">
+                <constraints referencedTableName="user" referencedColumnNames="id" foreignKeyName="FK_USER_ROLE_USER_ID" nullable="false"/>
+            </column>
+            <column name="role_id" type="int">
+                <constraints referencedTableName="role" referencedColumnNames="id" foreignKeyName="FK_USER_ROLE_ROLE_ID" nullable="false"/>
+            </column>
+        </createTable>
+        <addPrimaryKey tableName="userrole" columnNames="user_id,role_id"/>
+    </changeSet>
 </databaseChangeLog>

embedded-db-junit-liquibase/src/test/resources/example-illegal.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<databaseChangeLog
+        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.3.xsd">
+    <blah></blah>
+</databaseChangeLog>

embedded-db-junit/src/main/java/org/zapodot/junit/db/internal/FilePathInitializationPlugin.java

@@ -20,11 +20,11 @@ public class FilePathInitializationPlugin implements InitializationPlugin {
     private final Charset charset;
 
     public FilePathInitializationPlugin(final String resource, final Charset charset) {
-        if(null == resource) {
+        if (null == resource) {
             throw new IllegalArgumentException("The \"resource\" parameter must be provided");
         }
         this.resource = resource;
-        if(null == charset) {
+        if (null == charset) {
             throw new IllegalArgumentException("The \"charset\" parameter must be provided");
         }
         this.charset = charset;
@@ -41,12 +41,12 @@ public void connectionMade(final String name, final Connection connection) {
             statement.execute(convertToString(out.toByteArray()));
 
         } catch (IOException e) {
-            throw new IllegalStateException(String.format("Could not read SQL from file path \"%s\"",
-                                                          filePath.getName()),
-                                            e);
+            throw new IllegalArgumentException(String.format("Could not read SQL from file path \"%s\"",
+                                                             filePath.getName()),
+                                               e);
         } catch (SQLException e) {
-            throw new IllegalStateException(String.format("Could not run SQL script from file path \"%s\"",
-                                                          filePath.getName()));
+            throw new IllegalArgumentException(String.format("Could not run SQL script from file path \"%s\"",
+                                                             filePath.getName()), e);
         }
 
     }

embedded-db-junit/src/main/java/org/zapodot/junit/db/internal/HyperSqlJdbcUrlFactory.java

@@ -3,6 +3,7 @@
 import org.zapodot.junit.db.EmbeddedDatabaseRule;
 
 import java.util.Collections;
+import java.util.LinkedHashMap;
 import java.util.Map;
 
 public class HyperSqlJdbcUrlFactory implements JdbcUrlFactory {
@@ -21,9 +22,11 @@ public class HyperSqlJdbcUrlFactory implements JdbcUrlFactory {
 
     static final String SQL_SYNTAX_POSTGRESQL = "sql.syntax_pgs";
 
+    private static final String DATABASE_CREATE_SETTING = "create";
+
     @Override
     public String connectionUrlForInitialization(final String name, final Map<String, String> properties) {
-        return connectionUrl(name, properties);
+        return connectionUrl(name, addCreateProperty(properties));
     }
 
     @Override
@@ -33,6 +36,13 @@ public String connectionUrl(final String name, final Map<String, String> propert
                                                 .toString();
     }
 
+    private Map<String, String> addCreateProperty(final Map<String, String> properties) {
+        final Map<String, String> props = new LinkedHashMap<>();
+        props.putAll(properties);
+        props.put(DATABASE_CREATE_SETTING, ENABLED_SETTING);
+        return props;
+    }
+
     @Override
     public Map<String, String> compatibilityModeParam(final EmbeddedDatabaseRule.CompatibilityMode compatibilityMode) {
         if (EmbeddedDatabaseRule.CompatibilityMode.MSSQLServer == compatibilityMode) {

embedded-db-junit/src/test/java/org/zapodot/junit/db/EmbeddedDatabaseRuleInitSqlFailedTest.java

@@ -19,7 +19,7 @@ public class EmbeddedDatabaseRuleInitSqlFailedTest {
     @Rule
     public MockitoRule mockitoRule = MockitoJUnit.rule();
 
-    @Test(expected = IllegalStateException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void illegalSqlFromResource() throws Throwable {
         final EmbeddedDatabaseRule rule = EmbeddedDatabaseRule.builder()
                                                               .withInitialSqlFromResource("classpath:illegal.sql")

embedded-db-junit/src/test/java/org/zapodot/junit/db/internal/FilePathInitializationPluginTest.java

@@ -0,0 +1,85 @@
+package org.zapodot.junit.db.internal;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+public class FilePathInitializationPluginTest {
+
+    @Rule
+    public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private Connection connection;
+
+    @Mock
+    private Statement statement;
+
+    @Test(expected = IllegalArgumentException.class)
+    public void resourceMissing() {
+        new FilePathInitializationPlugin(null, null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void charsetMissing() {
+        new FilePathInitializationPlugin("resource", null);
+    }
+
+    @Test
+    public void connectionMadeDone() throws SQLException {
+        final FilePathInitializationPlugin filePathInitializationPlugin = new FilePathInitializationPlugin(
+                "classpath:initial.sql",
+                StandardCharsets.UTF_8);
+        assertNotNull(filePathInitializationPlugin);
+
+        when(connection.createStatement()).thenReturn(statement);
+        filePathInitializationPlugin.connectionMade("name", connection);
+        verify(connection).createStatement();
+        verify(statement).execute(anyString());
+        verify(statement).close();
+        verifyNoMoreInteractions(connection, statement);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void connectionSQLExecutionFails() throws SQLException {
+        final FilePathInitializationPlugin filePathInitializationPlugin = new FilePathInitializationPlugin(
+                "classpath:initial.sql",
+                StandardCharsets.UTF_8);
+        assertNotNull(filePathInitializationPlugin);
+
+        when(connection.createStatement()).thenReturn(statement);
+        when(statement.execute(anyString())).thenThrow(new SQLException("Error"));
+        try {
+            filePathInitializationPlugin.connectionMade("name", connection);
+        } finally {
+            verify(connection).createStatement();
+            verify(statement).execute(anyString());
+            verify(statement).close();
+            verifyNoMoreInteractions(connection, statement);
+        }
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void connectionMadeIllegalPath() {
+        final FilePathInitializationPlugin filePathInitializationPlugin = new FilePathInitializationPlugin(
+                "classpath:nonexisting.sql",
+                StandardCharsets.UTF_8);
+        assertNotNull(filePathInitializationPlugin);
+        try {
+            filePathInitializationPlugin.connectionMade("name", connection);
+        } finally {
+            verifyNoMoreInteractions(connection, statement);
+        }
+    }
+}