org.flywaydb.test.annotation.FlywayTest Java Examples

@Test
@FlywayTest(flywayName = "flyway1")
@FlywayTest(flywayName = "flyway2")
public void databaseShouldBeOverriddenByFlyway2() {
    assertThat(dataSource).isNotNull();

    List<Map<String, Object>> persons = jdbcTemplate.queryForList("select * from test.person");
    assertThat(persons).isNotNull().hasSize(2);

    assertThat(persons).extracting("id", "first_name", "last_name", "full_name").containsExactlyInAnyOrder(
            tuple(1L, "Dave", "Syer", "Dave Syer"),
            tuple(3L, "Will", "Smith", "Will Smith"));

    List<Map<String, Object>> nextPersons = jdbcTemplate.queryForList("select * from next.person");
    assertThat(nextPersons).isNotNull().hasSize(1);

    assertThat(nextPersons).extracting("id", "first_name", "surname").containsExactlyInAnyOrder(
            tuple(1L, "Dave", "Syer"));
}
 

@Test
@FlywayTest(invokeCleanDB = true)
public void testGetChildNodes() throws Exception {
	Node rootNode = nodeDAO.getRootNode();

	Map<String, String> props = new HashMap<>();
	props.put("a", "b");

	Node folder1 = Node.builder().name("SomeFolder").properties(props).build();

	// Create folder1 in the root folder
	folder1 = nodeDAO.createNode(rootNode.getUniqueId(), folder1);

	List<Node> childNodes = nodeDAO.getChildNodes(rootNode.getUniqueId());

	assertEquals("b", childNodes.get(0).getProperty("a"));
	assertTrue(nodeDAO.getChildNodes(folder1.getUniqueId()).isEmpty());
}
 

protected static DataSource reloadDataSource(FlywayDataSourceContext dataSourceContext, Flyway flywayBean, FlywayTest annotation) throws Exception {
    if (isAppendable(flywayBean, annotation)) {
        return dataSourceContext.reload(flywayBean).get();
    } else {
        String[] oldLocations = getFlywayLocations(flywayBean);
        try {
            if (annotation.overrideLocations()) {
                setFlywayLocations(flywayBean, annotation.locationsForMigrate());
            } else {
                setFlywayLocations(flywayBean, ObjectArrays.concat(oldLocations, annotation.locationsForMigrate(), String.class));
            }
            return dataSourceContext.reload(flywayBean).get();
        } finally {
            setFlywayLocations(flywayBean, oldLocations);
        }
    }
}
 

/**
 * Checks if test migrations are appendable to core migrations.
 */
protected static boolean isAppendable(Flyway flyway, FlywayTest annotation) throws ClassNotFoundException {
    if (annotation.overrideLocations()) {
        return false;
    }

    if (ArrayUtils.isEmpty(annotation.locationsForMigrate())) {
        return true;
    }

    MigrationVersion testVersion = findFirstVersion(flyway, annotation.locationsForMigrate());
    if (testVersion == MigrationVersion.EMPTY) {
        return true;
    }

    MigrationVersion coreVersion = findLastVersion(flyway, getFlywayLocations(flyway));
    return coreVersion.compareTo(testVersion) < 0;
}
 

/**
 * Search the class hierachie if a {@link FlywayTest} or {@link FlywayTests} annotation is used
 * together with a one of the Test annotations.
 *
 * @param testContext  current test spring context
 * @param testClass  current test class
 * @param junit4TestAnnotationClass  junit4 test annotation class
 * @param junit5TestAnnotationClass junit5 test annotation class
 */
private void handleFlywayTestWithTestAnnotation(TestContext testContext, Class testClass, Class junit4TestAnnotationClass, Class junit5TestAnnotationClass, Class testNgAnnotationClass) {
    Class currentTestClass = testClass;

    // search the first class with Before and FlywayTest annotation
    while (currentTestClass != Object.class) {
        final List<Method> allMethods = new ArrayList<Method>(Arrays.asList(currentTestClass.getDeclaredMethods()));
        for (final Method method : allMethods) {
            if (isMethodAnnotatedWithAtLeastOne(method, junit4TestAnnotationClass, junit5TestAnnotationClass, testNgAnnotationClass)
                    && isMethodAnnotatedWithAtLeastOne(method, FlywayTest.class, FlywayTests.class, null)) {
                // we have a method here that have both annotations
                getLogger().debug("Method " + method.getName() + " using flyway annotation.");
                if (handleFlywayTestAnnotationForMethod(testContext, method)) {
                    // finished handling
                    return;
                }
            }
        }

        // move to the upper class in the hierarchy in search for more methods
        currentTestClass = currentTestClass.getSuperclass();
    }
}
 

/**
 * Made a clean init migrate usage before execution of test methodes
 */
@Test
@FlywayTest
public void dummyTestMethodLoad() throws Exception {
	int res = countCustomer();

	Assert.assertEquals("Count of customer", 0, res);
}
 

@Test
@FlywayTest(invokeCleanDB = true)
public void testNoNameClash() {

	Node rootNode = nodeDAO.getRootNode();

	Node n1 = Node.builder().id(1).name("n1").build();
	n1 = nodeDAO.createNode(rootNode.getUniqueId(), n1);
	Node n2 = Node.builder().id(2).name("n2").build();
	n2 = nodeDAO.createNode(rootNode.getUniqueId(), n2);
}
 

/**
 * Made a clean init migrate and insert sql with dbunit
 */
@Test
@FlywayTest
@DBUnitSupport(loadFilesForRun = { "INSERT", "/dbunit/dbunit.cus1.xml" })
public void loadDBUnitSQLs() throws Exception {
	int res = countCustomer();

	Assert.assertEquals("Count of customer", 2, res);
}
 

@FlywayTest(invokeCleanDB = true)
@Test
public void singleLocation() throws Exception {
    assertThat(template.queryForObject(
            "SELECT COUNT(*) from PERSON", Integer.class),
            is(3));
}
 

/**
 * Made a clean init migrate with inserts from flyway and store it
 * afterwards
 */
@Test
@FlywayTest(locationsForMigrate = { "loadMultibleSQLs" })
@DBUnitSupport(saveTableAfterRun = { "CUSTOMER", "select * from CUSTOMER" }, saveFileAfterRun = "target/dbunitresult/customer1.xml")
public void storeDBUnitSQLs() throws Exception {
	int res = countCustomer();

	Assert.assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate and insert sql with dbunit
 */
@Test
@FlywayTest
@DBUnitSupport(loadFilesForRun = { "INSERT", "/dbunit/dbunit.cus1.xml" })
public void loadDBUnitSQLs() throws Exception {
	int res = countCustomer();

	Assert.assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate usage before execution of test methods
 */
@Test
@FlywayTest
public void dummyTestMethodLoad() throws Exception {
	int res = countCustomer();

	assertEquals("Count of customer", 0, res);
}
 

@FlywayTest(locationsForMigrate = "loadmsql")
@Test
public void laodFlywayTestInsertWithoutSqlScriptExecutionTest() throws Exception {
    int countCustomer = countCustomer();

    assertThat("Only Flyway customer should be loaded.", countCustomer, is(2));
}
 

/**
 * Made a clean init migrate usage before execution of test methods
 */
@Test
@FlywayTest(locationsForMigrate = {"loadMultibleSQLs"})
public void loadMultibleSQLsLocations() throws Exception {
    int res = countCustomer();

    assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate with inserts from flyway and store it
 * afterwards
 */
@Test
@FlywayTest(locationsForMigrate = { "loadMultibleSQLs" })
@DBUnitSupport(saveTableAfterRun = { "CUSTOMER", "select * from CUSTOMER" }, saveFileAfterRun = "target/dbunitresult/customer1.xml")
public void storeDBUnitSQLs() throws Exception {
	int res = countCustomer();

	Assert.assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate usage before execution of test method and
 * load SQL statements from two directories.
 */
@Test
@FlywayTest(locationsForMigrate = {"loadmsql"})
public void loadMultibleSQLs() throws Exception {
	int res = countCustomer();

	assertThat("Count of customer", res, is(2));
}
 

@FlywayTest(locationsForMigrate = "loadmsql")
@Test
public void laodFlywayTestInsertWithoutSqlScriptExecutionTest() throws Exception {
    int countCustomer = countCustomer();

    assertEquals("Only Flyway customer should be loaded.", 2, countCustomer);
}
 

/**
 * Made a clean init migrate usage before execution of test methods
 */
@Test
@FlywayTest(locationsForMigrate = {"loadMultibleSQLs"}, flywayName = "flyway")
public void loadMultipleSQLsLocations() throws Exception {
    int res = countCustomer();
    int res2 = countCustomer2();

    assertEquals("Count of customer", 2, res);
    assertEquals("Count of customer2", 2, res2);
}
 

/**
 * Made a clean init migrate usage before execution of test methods
 */
@Test
@FlywayTest(locationsForMigrate = { "basetest", "loadMultibleSQLs" }, overrideLocations = true)
public void loadMultibleSQLsOverrideLocations() throws Exception {
    int res = countCustomer();

    assertEquals("Count of customer", 2, res);
}
 

@Before
@FlywayTests(value = {
        @FlywayTest(flywayName = "flyway"),
        @FlywayTest(locationsForMigrate = {"basetest2", "loadMultipleSQLs2"}, overrideLocations = true, flywayName = "flyway2")
})
public void before() {
}
 

/**
 * Made a clean init migrate usage before execution of test methods
 */
@Test
@FlywayTest
void dummyTestMethodLoad() throws Exception {
    int res = countCustomer();

    assertThat("Count of customer", res, is(0));
}
 

/**
 * Made a clean init migrate usage before execution of test methods
 */
@Test
@FlywayTest(locationsForMigrate = { "sampletest5", "loadmsqlbefore" }, overrideLocations = true)
public void loadMultibleSQLsOverrideLocations() throws Exception {
    int res = countCustomer();

    assertThat("Count of customer", res, is(3));
}
 

@Test
@FlywayTest(invokeCleanDB = true)
public void testGetRootsParent() {
	Node rootNode = nodeDAO.getRootNode();
	Node parent = nodeDAO.getParentNode(rootNode.getUniqueId());

	assertEquals(rootNode.getUniqueId(), parent.getUniqueId());
}
 

/**
 * Made a clean init migrate with inserts from flyway and store it
 * afterwards
 */
@Test
@FlywayTest(locationsForMigrate = {"loadmsql"})
@DBUnitSupport(saveTableAfterRun = { "CUSTOMER", "select * from CUSTOMER" }, saveFileAfterRun = "target/dbunitresult/customer1.xml")
public void storeDBUnitSQLs() throws Exception {
	int res = countCustomer();

	assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate and insert sql with dbunit
 */
@Test
@FlywayTest
@DBUnitSupport(loadFilesForRun = { "INSERT", "/dbunit3/dbunit.cus1.xml"})
public void loadDBUnitSQLs() throws Exception {
	int res = countCustomer();

	assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate usage before execution of test method.
 * SQL statements will be loaded from the default location.
 */
@Test
@FlywayTest(invokeBaselineDB = true)
public void testMethodLoadWithBaseline() throws Exception {
    int res = countCustomer();

    assertThat("Count of customer", res, is(0));
}
 

/**
 * Made a clean init migrate with inserts from flyway and store it
 * afterwards
 */
@Test
@FlywayTest(locationsForMigrate = {"loadmsql"})
@DBUnitSupport(saveTableAfterRun = { "CUSTOMER", "select * from CUSTOMER" }, saveFileAfterRun = "target/dbunitresult/customer1.xml")
public void storeDBUnitSQLs() throws Exception {
	int res = countCustomer();

	assertEquals("Count of customer", 2, res);
}
 

/**
 * Made a clean init migrate usage before execution of test method and
 * load SQL statements from two directories.
 */
@Test
@FlywayTest(locationsForMigrate = {"loadmsql"}, flywayName = "flywaySecond")
public void useFlywaySecond_loadMultibleSQLs() throws Exception {
    int res = countCustomer();

    assertThat("Count of customer", res, is(6));
}
 

/**
 * Made a clean init migrate usage before execution of test method.
 * SQL statements will be loaded from the default location.
 */
@Test
@FlywayTest(invokeBaselineDB=true)
public void testMethodLoadWithBaseline() throws Exception {
    int res = countCustomer();

    assertEquals("Count of customer", 0, res);
}
 

/**
 * Made a clean init migrate usage before execution of test method and
 * load SQL statements from two directories.
 */
@Test
@FlywayTest(locationsForMigrate = {"loadmsql"}, flywayName = "flywayOne")
public void useFlywayOne_loadMultibleSQLs() throws Exception {
    int res = countCustomer();

    assertEquals("Count of customer", 2, res);
}