From abdb010fc81892fbe442d51c12924104a6b23667 Mon Sep 17 00:00:00 2001 From: Sam Brannen Date: Fri, 20 Jun 2014 14:33:23 +0200 Subject: [PATCH] Rename SQL script annotations in the TCF Prior to this commit, SQL script annotations and related classes in the TestContext framework (TCF) were named DatabaseInitializer*. However, these annotations are not used only for initialization and are therefore misleading when used for cleaning up the database. This commit refines the names of annotations and related classes for configuring SQL scripts to be executed for integration tests in the TCF as follows: - @DatabaseInitializer -> @Sql - @DatabaseInitializers -> @SqlGroup - DatabaseInitializerTestExecutionListener -> SqlScriptsTestExecutionListener A special thanks goes out to the following attendees of the Zurich Hackergarten meeting last night for their collective brainstorming: @aalmiray, @atsticks, @ollin, @simkuenzi, @tangresh, @vyazelenko. Issue: SPR-7655 --- .../{DatabaseInitializer.java => Sql.java} | 29 ++--- ...atabaseInitializers.java => SqlGroup.java} | 18 ++- ...a => SqlScriptsTestExecutionListener.java} | 118 +++++++++--------- ...TransactionalJUnit4SpringContextTests.java | 6 +- .../DefaultTestContextBootstrapper.java | 6 +- ...TransactionalTestNGSpringContextTests.java | 6 +- ...=> CustomScriptSyntaxSqlScriptsTests.java} | 10 +- ...efaultScriptDetectionSqlScriptsTests.java} | 6 +- ...tDetectionSqlScriptsTests.methodLevel.sql} | 0 ...DefaultScriptDetectionSqlScriptsTests.sql} | 0 ...ava => MetaAnnotationSqlScriptsTests.java} | 27 ++-- ...ndTransactionManagersSqlScriptsTests.java} | 12 +- ...ManagersTransactionalSqlScriptsTests.java} | 8 +- ...a => NonTransactionalSqlScriptsTests.java} | 11 +- ...edSchemaTransactionalSqlScriptsTests.java} | 6 +- ...equiresNewTransactionSqlScriptsTests.java} | 6 +- ...SqlScriptsTestExecutionListenerTests.java} | 12 +- ...tionalAfterTestMethodSqlScriptsTests.java} | 17 +-- ...java => TransactionalSqlScriptsTests.java} | 9 +- 19 files changed, 151 insertions(+), 156 deletions(-) rename spring-test/src/main/java/org/springframework/test/context/jdbc/{DatabaseInitializer.java => Sql.java} (90%) rename spring-test/src/main/java/org/springframework/test/context/jdbc/{DatabaseInitializers.java => SqlGroup.java} (68%) rename spring-test/src/main/java/org/springframework/test/context/jdbc/{DatabaseInitializerTestExecutionListener.java => SqlScriptsTestExecutionListener.java} (62%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{CustomScriptSyntaxDatabaseInitializerTests.java => CustomScriptSyntaxSqlScriptsTests.java} (84%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{DefaultScriptDetectionDatabaseInitializerTests.java => DefaultScriptDetectionSqlScriptsTests.java} (89%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{DefaultScriptDetectionDatabaseInitializerTests.methodLevel.sql => DefaultScriptDetectionSqlScriptsTests.methodLevel.sql} (100%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{DefaultScriptDetectionDatabaseInitializerTests.sql => DefaultScriptDetectionSqlScriptsTests.sql} (100%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{MetaAnnotationDatabaseInitializerTests.java => MetaAnnotationSqlScriptsTests.java} (68%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests.java => MultipleDataSourcesAndTransactionManagersSqlScriptsTests.java} (84%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{MultipleDataSourcesAndTransactionManagersTransactionalDatabaseInitializerTests.java => MultipleDataSourcesAndTransactionManagersTransactionalSqlScriptsTests.java} (92%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{NonTransactionalDatabaseInitializerTests.java => NonTransactionalSqlScriptsTests.java} (85%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{PopulatedSchemaTransactionalDatabaseInitializerTests.java => PopulatedSchemaTransactionalSqlScriptsTests.java} (86%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{RequiresNewTransactionDatabaseInitializerTests.java => RequiresNewTransactionSqlScriptsTests.java} (85%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{DatabaseInitializerTestExecutionListenerTests.java => SqlScriptsTestExecutionListenerTests.java} (88%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{TransactionalAfterTestMethodDatabaseInitializerTests.java => TransactionalAfterTestMethodSqlScriptsTests.java} (76%) rename spring-test/src/test/java/org/springframework/test/context/jdbc/{TransactionalDatabaseInitializerTests.java => TransactionalSqlScriptsTests.java} (79%) diff --git a/spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializer.java b/spring-test/src/main/java/org/springframework/test/context/jdbc/Sql.java similarity index 90% rename from spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializer.java rename to spring-test/src/main/java/org/springframework/test/context/jdbc/Sql.java index 5505eed8340..7668048fc4a 100644 --- a/spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializer.java +++ b/spring-test/src/main/java/org/springframework/test/context/jdbc/Sql.java @@ -29,23 +29,24 @@ import static java.lang.annotation.ElementType.*; import static java.lang.annotation.RetentionPolicy.*; /** - * {@code @DatabaseInitializer} is used to annotate a test class or test method - * to configure SQL scripts to be executed against a given database during - * integration tests. + * {@code @Sql} is used to annotate a test class or test method to configure SQL + * scripts to be executed against a given database during integration tests. * *

Method-level declarations override class-level declarations. * - *

Script execution is performed by the {@link DatabaseInitializerTestExecutionListener}, + *

Script execution is performed by the {@link SqlScriptsTestExecutionListener}, * which is enabled by default. * - *

The configuration options provided by this annotation are a superset of - * those provided by the {@code } XML namespace - * element. Consult the Javadoc of individual attributes for details. + *

The configuration options provided by this annotation are equivalent to + * those supported by {@link ScriptUtils} and {@link org.springframework.jdbc.datasource.init.ResourceDatabasePopulator + * ResourceDatabasePopulator} but are a superset of those provided by the + * {@code } XML namespace element. Consult the + * Javadoc of individual attributes in this annotation for details. * - *

Beginning with Java 8, {@code @DatabaseInitializer} can be used as a + *

Beginning with Java 8, {@code @Sql} can be used as a * {@linkplain Repeatable repeatable} annotation. Otherwise, - * {@link DatabaseInitializers @DatabaseInitializers} can be used as an explicit - * container for declaring multiple instances of {@code @DatabaseInitializer}. + * {@link SqlGroup @SqlGroup} can be used as an explicit container for declaring + * multiple instances of {@code @Sql}. * *

This annotation may be used as a meta-annotation to create custom * composed annotations; however, attribute overrides are not currently @@ -55,8 +56,8 @@ import static java.lang.annotation.RetentionPolicy.*; * @author Sam Brannen * @author Tadaya Tsuyukubo * @since 4.1 - * @see DatabaseInitializers - * @see DatabaseInitializerTestExecutionListener + * @see SqlGroup + * @see SqlScriptsTestExecutionListener * @see org.springframework.transaction.annotation.Transactional * @see org.springframework.test.context.transaction.TransactionalTestExecutionListener * @see org.springframework.jdbc.datasource.init.ResourceDatabasePopulator @@ -66,8 +67,8 @@ import static java.lang.annotation.RetentionPolicy.*; @Inherited @Retention(RUNTIME) @Target({ TYPE, METHOD }) -@Repeatable(DatabaseInitializers.class) -public @interface DatabaseInitializer { +@Repeatable(SqlGroup.class) +public @interface Sql { /** * Enumeration of phases that dictate when SQL scripts are executed. diff --git a/spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializers.java b/spring-test/src/main/java/org/springframework/test/context/jdbc/SqlGroup.java similarity index 68% rename from spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializers.java rename to spring-test/src/main/java/org/springframework/test/context/jdbc/SqlGroup.java index accb495bec4..1767543b5d7 100644 --- a/spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializers.java +++ b/spring-test/src/main/java/org/springframework/test/context/jdbc/SqlGroup.java @@ -25,28 +25,26 @@ import static java.lang.annotation.ElementType.*; import static java.lang.annotation.RetentionPolicy.*; /** - * Container annotation that aggregates several {@link DatabaseInitializer} - * annotations. + * Container annotation that aggregates several {@link Sql @Sql} annotations. * - *

Can be used natively, declaring several nested {@link DatabaseInitializer} - * annotations. Can also be used in conjunction with Java 8's support for - * repeatable annotations, where {@code @DatabaseInitializer} can simply be - * declared several times on the same class or method, implicitly generating - * this container annotation. + *

Can be used natively, declaring several nested {@code @Sql} annotations. + * Can also be used in conjunction with Java 8's support for repeatable + * annotations, where {@code @Sql} can simply be declared several times on the + * same class or method, implicitly generating this container annotation. * *

This annotation may be used as a meta-annotation to create custom * composed annotations. * * @author Sam Brannen * @since 4.1 - * @see DatabaseInitializer + * @see Sql */ @Documented @Inherited @Retention(RUNTIME) @Target({ TYPE, METHOD }) -public @interface DatabaseInitializers { +public @interface SqlGroup { - DatabaseInitializer[] value(); + Sql[] value(); } diff --git a/spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializerTestExecutionListener.java b/spring-test/src/main/java/org/springframework/test/context/jdbc/SqlScriptsTestExecutionListener.java similarity index 62% rename from spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializerTestExecutionListener.java rename to spring-test/src/main/java/org/springframework/test/context/jdbc/SqlScriptsTestExecutionListener.java index 49b4922096f..1c8a82b31f2 100644 --- a/spring-test/src/main/java/org/springframework/test/context/jdbc/DatabaseInitializerTestExecutionListener.java +++ b/spring-test/src/main/java/org/springframework/test/context/jdbc/SqlScriptsTestExecutionListener.java @@ -28,7 +28,7 @@ import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.io.ClassPathResource; import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator; import org.springframework.test.context.TestContext; -import org.springframework.test.context.jdbc.DatabaseInitializer.ExecutionPhase; +import org.springframework.test.context.jdbc.Sql.ExecutionPhase; import org.springframework.test.context.support.AbstractTestExecutionListener; import org.springframework.test.context.transaction.TestContextTransactionUtils; import org.springframework.test.context.util.TestContextResourceUtils; @@ -45,17 +45,20 @@ import org.springframework.util.ResourceUtils; /** * {@code TestExecutionListener} that provides support for executing SQL scripts - * configured via the {@link DatabaseInitializer @DatabaseInitializer} annotation. + * configured via the {@link Sql @Sql} annotation. * - *

SQL scripts will be executed {@linkplain #beforeTestMethod(TestContext) before} + *

Scripts will be executed {@linkplain #beforeTestMethod(TestContext) before} * or {@linkplain #afterTestMethod(TestContext) after} execution of the corresponding * {@linkplain java.lang.reflect.Method test method}, depending on the configured - * value of the {@link DatabaseInitializer#requireNewTransaction requireNewTransaction} - * flag. + * value of the {@link Sql#executionPhase executionPhase} flag. + * + *

Scripts will be executed either within an existing Spring-managed transaction + * or within a new, isolated transaction, depending on the configured value of the + * {@link Sql#requireNewTransaction requireNewTransaction} flag. * *

Script Resources

*

For details on default script detection and how explicit script locations - * are interpreted, see {@link DatabaseInitializer#scripts}. + * are interpreted, see {@link Sql#scripts}. * *

Required Spring Beans

*

A {@link DataSource} and {@link PlatformTransactionManager} must be defined @@ -66,106 +69,105 @@ import org.springframework.util.ResourceUtils; * * @author Sam Brannen * @since 4.1 - * @see DatabaseInitializer - * @see DatabaseInitializers + * @see Sql + * @see SqlGroup + * @see org.springframework.test.context.transaction.TestContextTransactionUtils * @see org.springframework.test.context.transaction.TransactionalTestExecutionListener * @see org.springframework.jdbc.datasource.init.ResourceDatabasePopulator * @see org.springframework.jdbc.datasource.init.ScriptUtils */ -public class DatabaseInitializerTestExecutionListener extends AbstractTestExecutionListener { +public class SqlScriptsTestExecutionListener extends AbstractTestExecutionListener { - private static final Log logger = LogFactory.getLog(DatabaseInitializerTestExecutionListener.class); + private static final Log logger = LogFactory.getLog(SqlScriptsTestExecutionListener.class); /** - * Execute SQL scripts configured via {@link DatabaseInitializer @DatabaseInitializer} - * for the supplied {@link TestContext} before the current test method. + * Execute SQL scripts configured via {@link Sql @Sql} for the supplied + * {@link TestContext} before the current test method. */ @Override public void beforeTestMethod(TestContext testContext) throws Exception { - executeDatabaseInitializers(testContext, ExecutionPhase.BEFORE_TEST_METHOD); + executeSqlScripts(testContext, ExecutionPhase.BEFORE_TEST_METHOD); } /** - * Execute SQL scripts configured via {@link DatabaseInitializer @DatabaseInitializer} - * for the supplied {@link TestContext} after the current test method. + * Execute SQL scripts configured via {@link Sql @Sql} for the supplied + * {@link TestContext} after the current test method. */ @Override public void afterTestMethod(TestContext testContext) throws Exception { - executeDatabaseInitializers(testContext, ExecutionPhase.AFTER_TEST_METHOD); + executeSqlScripts(testContext, ExecutionPhase.AFTER_TEST_METHOD); } /** - * Execute SQL scripts configured via {@link DatabaseInitializer @DatabaseInitializer} - * for the supplied {@link TestContext} and {@link ExecutionPhase}. + * Execute SQL scripts configured via {@link Sql @Sql} for the supplied + * {@link TestContext} and {@link ExecutionPhase}. */ - private void executeDatabaseInitializers(TestContext testContext, ExecutionPhase executionPhase) throws Exception { + private void executeSqlScripts(TestContext testContext, ExecutionPhase executionPhase) throws Exception { boolean classLevel = false; - Set databaseInitializers = AnnotationUtils.getRepeatableAnnotation( - testContext.getTestMethod(), DatabaseInitializers.class, DatabaseInitializer.class); - if (databaseInitializers.isEmpty()) { - databaseInitializers = AnnotationUtils.getRepeatableAnnotation(testContext.getTestClass(), - DatabaseInitializers.class, DatabaseInitializer.class); - if (!databaseInitializers.isEmpty()) { + Set sqlAnnotations = AnnotationUtils.getRepeatableAnnotation(testContext.getTestMethod(), SqlGroup.class, + Sql.class); + if (sqlAnnotations.isEmpty()) { + sqlAnnotations = AnnotationUtils.getRepeatableAnnotation(testContext.getTestClass(), SqlGroup.class, + Sql.class); + if (!sqlAnnotations.isEmpty()) { classLevel = true; } } - for (DatabaseInitializer databaseInitializer : databaseInitializers) { - executeDatabaseInitializer(databaseInitializer, executionPhase, testContext, classLevel); + for (Sql sql : sqlAnnotations) { + executeSqlScripts(sql, executionPhase, testContext, classLevel); } } /** - * Execute the SQL scripts configured via the supplied - * {@link DatabaseInitializer @DatabaseInitializer} for the given - * {@link ExecutionPhase} and {@link TestContext}. + * Execute the SQL scripts configured via the supplied {@link Sql @Sql} + * annotation for the given {@link ExecutionPhase} and {@link TestContext}. * *

Special care must be taken in order to properly support the - * {@link DatabaseInitializer#requireNewTransaction requireNewTransaction} + * {@link Sql#requireNewTransaction requireNewTransaction} * flag. * - * @param databaseInitializer the {@code @DatabaseInitializer} to parse + * @param sql the {@code @Sql} annotation to parse * @param executionPhase the current execution phase * @param testContext the current {@code TestContext} - * @param classLevel {@code true} if {@link DatabaseInitializer @DatabaseInitializer} - * was declared at the class level + * @param classLevel {@code true} if {@link Sql @Sql} was declared at the + * class level */ @SuppressWarnings("serial") - private void executeDatabaseInitializer(DatabaseInitializer databaseInitializer, ExecutionPhase executionPhase, - TestContext testContext, boolean classLevel) throws Exception { + private void executeSqlScripts(Sql sql, ExecutionPhase executionPhase, TestContext testContext, boolean classLevel) + throws Exception { if (logger.isDebugEnabled()) { - logger.debug(String.format("Processing %s for execution phase [%s] and test context %s.", - databaseInitializer, executionPhase, testContext)); + logger.debug(String.format("Processing %s for execution phase [%s] and test context %s.", sql, + executionPhase, testContext)); } - if (executionPhase != databaseInitializer.executionPhase()) { + if (executionPhase != sql.executionPhase()) { return; } final ResourceDatabasePopulator populator = new ResourceDatabasePopulator(); - populator.setSqlScriptEncoding(databaseInitializer.encoding()); - populator.setSeparator(databaseInitializer.separator()); - populator.setCommentPrefix(databaseInitializer.commentPrefix()); - populator.setBlockCommentStartDelimiter(databaseInitializer.blockCommentStartDelimiter()); - populator.setBlockCommentEndDelimiter(databaseInitializer.blockCommentEndDelimiter()); - populator.setContinueOnError(databaseInitializer.continueOnError()); - populator.setIgnoreFailedDrops(databaseInitializer.ignoreFailedDrops()); + populator.setSqlScriptEncoding(sql.encoding()); + populator.setSeparator(sql.separator()); + populator.setCommentPrefix(sql.commentPrefix()); + populator.setBlockCommentStartDelimiter(sql.blockCommentStartDelimiter()); + populator.setBlockCommentEndDelimiter(sql.blockCommentEndDelimiter()); + populator.setContinueOnError(sql.continueOnError()); + populator.setIgnoreFailedDrops(sql.ignoreFailedDrops()); - String[] scripts = getScripts(databaseInitializer, testContext, classLevel); + String[] scripts = getScripts(sql, testContext, classLevel); scripts = TestContextResourceUtils.convertToClasspathResourcePaths(testContext.getTestClass(), scripts); populator.setScripts(TestContextResourceUtils.convertToResources(testContext.getApplicationContext(), scripts)); if (logger.isDebugEnabled()) { logger.debug("Executing SQL scripts: " + ObjectUtils.nullSafeToString(scripts)); } - final DataSource dataSource = TestContextTransactionUtils.retrieveDataSource(testContext, - databaseInitializer.dataSource()); + final DataSource dataSource = TestContextTransactionUtils.retrieveDataSource(testContext, sql.dataSource()); final PlatformTransactionManager transactionManager = TestContextTransactionUtils.retrieveTransactionManager( - testContext, databaseInitializer.transactionManager()); + testContext, sql.transactionManager()); - int propagation = databaseInitializer.requireNewTransaction() ? TransactionDefinition.PROPAGATION_REQUIRES_NEW + int propagation = sql.requireNewTransaction() ? TransactionDefinition.PROPAGATION_REQUIRES_NEW : TransactionDefinition.PROPAGATION_REQUIRED; TransactionAttribute transactionAttribute = TestContextTransactionUtils.createDelegatingTransactionAttribute( @@ -180,9 +182,9 @@ public class DatabaseInitializerTestExecutionListener extends AbstractTestExecut }); } - private String[] getScripts(DatabaseInitializer databaseInitializer, TestContext testContext, boolean classLevel) { - String[] scripts = databaseInitializer.scripts(); - String[] value = databaseInitializer.value(); + private String[] getScripts(Sql sql, TestContext testContext, boolean classLevel) { + String[] scripts = sql.scripts(); + String[] value = sql.value(); boolean scriptsDeclared = !ObjectUtils.isEmpty(scripts); boolean valueDeclared = !ObjectUtils.isEmpty(value); @@ -190,9 +192,9 @@ public class DatabaseInitializerTestExecutionListener extends AbstractTestExecut String elementType = (classLevel ? "class" : "method"); String elementName = (classLevel ? testContext.getTestClass().getName() : testContext.getTestMethod().toString()); - String msg = String.format("Test %s [%s] has been configured with @DatabaseInitializer's 'value' [%s] " + String msg = String.format("Test %s [%s] has been configured with @Sql's 'value' [%s] " + "and 'scripts' [%s] attributes. Only one declaration of SQL script " - + "paths is permitted per @DatabaseInitializer annotation.", elementType, elementName, + + "paths is permitted per @Sql annotation.", elementType, elementName, ObjectUtils.nullSafeToString(value), ObjectUtils.nullSafeToString(scripts)); logger.error(msg); throw new IllegalStateException(msg); @@ -208,7 +210,7 @@ public class DatabaseInitializerTestExecutionListener extends AbstractTestExecut /** * Detect a default SQL script by implementing the algorithm defined in - * {@link DatabaseInitializer#scripts}. + * {@link Sql#scripts}. */ private String detectDefaultScript(TestContext testContext, boolean classLevel) { Class clazz = testContext.getTestClass(); @@ -234,7 +236,7 @@ public class DatabaseInitializerTestExecutionListener extends AbstractTestExecut } else { String msg = String.format("Could not detect default SQL script for test %s [%s]: " - + "%s does not exist. Either declare scripts via @DatabaseInitializer or make the " + + "%s does not exist. Either declare scripts via @Sql or make the " + "default SQL script available.", elementType, elementName, classPathResource); logger.error(msg); throw new IllegalStateException(msg); diff --git a/spring-test/src/main/java/org/springframework/test/context/junit4/AbstractTransactionalJUnit4SpringContextTests.java b/spring-test/src/main/java/org/springframework/test/context/junit4/AbstractTransactionalJUnit4SpringContextTests.java index 046a702cdc6..7744284eb31 100644 --- a/spring-test/src/main/java/org/springframework/test/context/junit4/AbstractTransactionalJUnit4SpringContextTests.java +++ b/spring-test/src/main/java/org/springframework/test/context/junit4/AbstractTransactionalJUnit4SpringContextTests.java @@ -26,7 +26,7 @@ import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestExecutionListeners; -import org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener; +import org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener; import org.springframework.test.context.transaction.TransactionalTestExecutionListener; import org.springframework.test.jdbc.JdbcTestUtils; import org.springframework.transaction.PlatformTransactionManager; @@ -64,7 +64,7 @@ import org.springframework.transaction.annotation.Transactional; * @see org.springframework.test.context.ContextConfiguration * @see org.springframework.test.context.TestExecutionListeners * @see org.springframework.test.context.transaction.TransactionalTestExecutionListener - * @see org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener + * @see org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener * @see org.springframework.test.context.transaction.TransactionConfiguration * @see org.springframework.transaction.annotation.Transactional * @see org.springframework.test.annotation.Rollback @@ -73,7 +73,7 @@ import org.springframework.transaction.annotation.Transactional; * @see org.springframework.test.jdbc.JdbcTestUtils * @see org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests */ -@TestExecutionListeners({ TransactionalTestExecutionListener.class, DatabaseInitializerTestExecutionListener.class }) +@TestExecutionListeners({ TransactionalTestExecutionListener.class, SqlScriptsTestExecutionListener.class }) @Transactional public abstract class AbstractTransactionalJUnit4SpringContextTests extends AbstractJUnit4SpringContextTests { diff --git a/spring-test/src/main/java/org/springframework/test/context/support/DefaultTestContextBootstrapper.java b/spring-test/src/main/java/org/springframework/test/context/support/DefaultTestContextBootstrapper.java index 1d3c9226a21..19d89b98717 100644 --- a/spring-test/src/main/java/org/springframework/test/context/support/DefaultTestContextBootstrapper.java +++ b/spring-test/src/main/java/org/springframework/test/context/support/DefaultTestContextBootstrapper.java @@ -38,7 +38,7 @@ import org.springframework.test.context.TestExecutionListener; *

  • {@link org.springframework.test.context.support.DependencyInjectionTestExecutionListener} *
  • {@link org.springframework.test.context.support.DirtiesContextTestExecutionListener} *
  • {@link org.springframework.test.context.transaction.TransactionalTestExecutionListener} - *
  • {@link org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener} + *
  • {@link org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener} * *
  • Uses {@link DelegatingSmartContextLoader} as the default {@link ContextLoader}. *
  • Builds a standard {@link MergedContextConfiguration}. @@ -53,7 +53,7 @@ public class DefaultTestContextBootstrapper extends AbstractTestContextBootstrap "org.springframework.test.context.support.DependencyInjectionTestExecutionListener", "org.springframework.test.context.support.DirtiesContextTestExecutionListener", "org.springframework.test.context.transaction.TransactionalTestExecutionListener", - "org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener")); + "org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener")); /** @@ -63,7 +63,7 @@ public class DefaultTestContextBootstrapper extends AbstractTestContextBootstrap *
  • {@link org.springframework.test.context.support.DependencyInjectionTestExecutionListener} *
  • {@link org.springframework.test.context.support.DirtiesContextTestExecutionListener} *
  • {@link org.springframework.test.context.transaction.TransactionalTestExecutionListener} - *
  • {@link org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener} + *
  • {@link org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener} * */ protected List getDefaultTestExecutionListenerClassNames() { diff --git a/spring-test/src/main/java/org/springframework/test/context/testng/AbstractTransactionalTestNGSpringContextTests.java b/spring-test/src/main/java/org/springframework/test/context/testng/AbstractTransactionalTestNGSpringContextTests.java index 56ed682718e..80bfd66e4af 100644 --- a/spring-test/src/main/java/org/springframework/test/context/testng/AbstractTransactionalTestNGSpringContextTests.java +++ b/spring-test/src/main/java/org/springframework/test/context/testng/AbstractTransactionalTestNGSpringContextTests.java @@ -25,7 +25,7 @@ import org.springframework.dao.DataAccessException; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator; import org.springframework.test.context.TestExecutionListeners; -import org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener; +import org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener; import org.springframework.test.context.transaction.TransactionalTestExecutionListener; import org.springframework.test.jdbc.JdbcTestUtils; import org.springframework.transaction.PlatformTransactionManager; @@ -55,7 +55,7 @@ import org.springframework.transaction.annotation.Transactional; * @see org.springframework.test.context.ContextConfiguration * @see org.springframework.test.context.TestExecutionListeners * @see org.springframework.test.context.transaction.TransactionalTestExecutionListener - * @see org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener + * @see org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener * @see org.springframework.test.context.transaction.TransactionConfiguration * @see org.springframework.transaction.annotation.Transactional * @see org.springframework.test.annotation.Rollback @@ -64,7 +64,7 @@ import org.springframework.transaction.annotation.Transactional; * @see org.springframework.test.jdbc.JdbcTestUtils * @see org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests */ -@TestExecutionListeners({ TransactionalTestExecutionListener.class, DatabaseInitializerTestExecutionListener.class }) +@TestExecutionListeners({ TransactionalTestExecutionListener.class, SqlScriptsTestExecutionListener.class }) @Transactional public abstract class AbstractTransactionalTestNGSpringContextTests extends AbstractTestNGSpringContextTests { diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/CustomScriptSyntaxDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/CustomScriptSyntaxSqlScriptsTests.java similarity index 84% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/CustomScriptSyntaxDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/CustomScriptSyntaxSqlScriptsTests.java index 3d4b7b0b612..ac46634df59 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/CustomScriptSyntaxDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/CustomScriptSyntaxSqlScriptsTests.java @@ -25,19 +25,19 @@ import static org.junit.Assert.*; /** * Integration tests that verify support for custom SQL script syntax - * configured via {@link DatabaseInitializer @DatabaseInitializer}. + * configured via {@link Sql @Sql}. * * @author Sam Brannen * @since 4.1 */ @ContextConfiguration(classes = EmptyDatabaseConfig.class) @DirtiesContext -public class CustomScriptSyntaxDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class CustomScriptSyntaxSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @Test - @DatabaseInitializers({// - @DatabaseInitializer("schema.sql"),// - @DatabaseInitializer(// + @SqlGroup({// + @Sql("schema.sql"),// + @Sql(// scripts = "data-add-users-with-custom-script-syntax.sql",// commentPrefix = "`",// blockCommentStartDelimiter = "#$",// diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.java similarity index 89% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.java index 86d4fc80e66..31f466a56b1 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.java @@ -30,9 +30,9 @@ import static org.junit.Assert.*; * @since 4.1 */ @ContextConfiguration(classes = EmptyDatabaseConfig.class) -@DatabaseInitializer +@Sql @DirtiesContext -public class DefaultScriptDetectionDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class DefaultScriptDetectionSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @Test public void classLevel() { @@ -40,7 +40,7 @@ public class DefaultScriptDetectionDatabaseInitializerTests extends AbstractTran } @Test - @DatabaseInitializer + @Sql public void methodLevel() { assertNumUsers(3); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.methodLevel.sql b/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.methodLevel.sql similarity index 100% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.methodLevel.sql rename to spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.methodLevel.sql diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.sql b/spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.sql similarity index 100% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionDatabaseInitializerTests.sql rename to spring-test/src/test/java/org/springframework/test/context/jdbc/DefaultScriptDetectionSqlScriptsTests.sql diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/MetaAnnotationDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/MetaAnnotationSqlScriptsTests.java similarity index 68% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/MetaAnnotationDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/MetaAnnotationSqlScriptsTests.java index b309569c34f..50672657a9f 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/MetaAnnotationDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/MetaAnnotationSqlScriptsTests.java @@ -29,26 +29,25 @@ import static java.lang.annotation.RetentionPolicy.*; import static org.junit.Assert.*; /** - * Integration tests that verify support for using - * {@link DatabaseInitializer @DatabaseInitializer} and - * {@link DatabaseInitializers @DatabaseInitializers} as a meta-annotations. + * Integration tests that verify support for using {@link Sql @Sql} and + * {@link SqlGroup @SqlGroup} as a meta-annotations. * * @author Sam Brannen * @since 4.1 */ @ContextConfiguration(classes = EmptyDatabaseConfig.class) @DirtiesContext -public class MetaAnnotationDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class MetaAnnotationSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @Test - @MetaDbInitializer - public void metaDatabaseInitializer() { + @MetaSql + public void metaSqlAnnotation() { assertNumUsers(1); } @Test - @MetaDbInitializers - public void metaDatabaseInitializers() { + @MetaSqlGroup + public void metaSqlGroupAnnotation() { assertNumUsers(1); } @@ -57,20 +56,16 @@ public class MetaAnnotationDatabaseInitializerTests extends AbstractTransactiona } - @DatabaseInitializer({ "drop-schema.sql", "schema.sql", "data.sql" }) + @Sql({ "drop-schema.sql", "schema.sql", "data.sql" }) @Retention(RUNTIME) @Target(METHOD) - static @interface MetaDbInitializer { + static @interface MetaSql { } - @DatabaseInitializers({// - @DatabaseInitializer("drop-schema.sql"),// - @DatabaseInitializer("schema.sql"),// - @DatabaseInitializer("data.sql") // - }) + @SqlGroup({ @Sql("drop-schema.sql"), @Sql("schema.sql"), @Sql("data.sql") }) @Retention(RUNTIME) @Target(METHOD) - static @interface MetaDbInitializers { + static @interface MetaSqlGroup { } } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersSqlScriptsTests.java similarity index 84% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersSqlScriptsTests.java index 138a81be322..f1bf333e7de 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersSqlScriptsTests.java @@ -34,17 +34,17 @@ import org.springframework.transaction.PlatformTransactionManager; import static org.junit.Assert.*; /** - * Integration tests for {@link DatabaseInitializer @DatabaseInitializer} that - * verify support for multiple {@link DataSource}s and {@link PlatformTransactionManager}s. + * Integration tests for {@link Sql @Sql} that verify support for multiple + * {@link DataSource}s and {@link PlatformTransactionManager}s. * * @author Sam Brannen * @since 4.1 - * @see MultipleDataSourcesAndTransactionManagersTransactionalDatabaseInitializerTests + * @see MultipleDataSourcesAndTransactionManagersTransactionalSqlScriptsTests */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration @DirtiesContext -public class MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests { +public class MultipleDataSourcesAndTransactionManagersSqlScriptsTests { @Autowired private DataSource dataSource1; @@ -54,13 +54,13 @@ public class MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests { @Test - @DatabaseInitializer(scripts = "data-add-dogbert.sql", dataSource = "dataSource1", transactionManager = "txMgr1") + @Sql(scripts = "data-add-dogbert.sql", dataSource = "dataSource1", transactionManager = "txMgr1") public void database1() { assertUsersExist(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert"); } @Test - @DatabaseInitializer(scripts = "data-add-catbert.sql", dataSource = "dataSource2", transactionManager = "txMgr2") + @Sql(scripts = "data-add-catbert.sql", dataSource = "dataSource2", transactionManager = "txMgr2") public void database2() { assertUsersExist(new JdbcTemplate(dataSource2), "Dilbert", "Catbert"); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersTransactionalDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersTransactionalSqlScriptsTests.java similarity index 92% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersTransactionalDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersTransactionalSqlScriptsTests.java index a76af542472..1b04a31a07b 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersTransactionalDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/MultipleDataSourcesAndTransactionManagersTransactionalSqlScriptsTests.java @@ -35,7 +35,7 @@ import org.springframework.transaction.annotation.Transactional; import static org.junit.Assert.*; /** - * Exact copy of {@link MultipleDataSourcesAndTransactionManagersDatabaseInitializerTests}, + * Exact copy of {@link MultipleDataSourcesAndTransactionManagersSqlScriptsTests}, * except that the test methods are transactional. * * @author Sam Brannen @@ -44,7 +44,7 @@ import static org.junit.Assert.*; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration @DirtiesContext -public class MultipleDataSourcesAndTransactionManagersTransactionalDatabaseInitializerTests { +public class MultipleDataSourcesAndTransactionManagersTransactionalSqlScriptsTests { @Autowired private DataSource dataSource1; @@ -55,14 +55,14 @@ public class MultipleDataSourcesAndTransactionManagersTransactionalDatabaseIniti @Test @Transactional("txMgr1") - @DatabaseInitializer(scripts = "data-add-dogbert.sql", dataSource = "dataSource1", transactionManager = "txMgr1") + @Sql(scripts = "data-add-dogbert.sql", dataSource = "dataSource1", transactionManager = "txMgr1") public void database1() { assertUsersExist(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert"); } @Test @Transactional("txMgr2") - @DatabaseInitializer(scripts = "data-add-catbert.sql", dataSource = "dataSource2", transactionManager = "txMgr2") + @Sql(scripts = "data-add-catbert.sql", dataSource = "dataSource2", transactionManager = "txMgr2") public void database2() { assertUsersExist(new JdbcTemplate(dataSource2), "Dilbert", "Catbert"); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/NonTransactionalDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/NonTransactionalSqlScriptsTests.java similarity index 85% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/NonTransactionalDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/NonTransactionalSqlScriptsTests.java index 4ebd8777462..51740e08974 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/NonTransactionalDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/NonTransactionalSqlScriptsTests.java @@ -32,9 +32,8 @@ import org.springframework.test.jdbc.JdbcTestUtils; import static org.junit.Assert.*; /** - * Integration tests which verify that scripts executed via - * {@link DatabaseInitializer @DatabaseInitializer} will persist between - * non-transactional test methods. + * Integration tests which verify that scripts executed via {@link Sql @Sql} + * will persist between non-transactional test methods. * * @author Sam Brannen * @since 4.1 @@ -42,9 +41,9 @@ import static org.junit.Assert.*; @RunWith(SpringJUnit4ClassRunner.class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) @ContextConfiguration(classes = EmptyDatabaseConfig.class) -@DatabaseInitializer({ "schema.sql", "data.sql" }) +@Sql({ "schema.sql", "data.sql" }) @DirtiesContext -public class NonTransactionalDatabaseInitializerTests { +public class NonTransactionalSqlScriptsTests { protected JdbcTemplate jdbcTemplate; @@ -61,7 +60,7 @@ public class NonTransactionalDatabaseInitializerTests { } @Test - @DatabaseInitializers(@DatabaseInitializer("data-add-dogbert.sql")) + @Sql("data-add-dogbert.sql") // test##_ prefix is required for @FixMethodOrder. public void test02_methodLevelScripts() { assertNumUsers(2); diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/PopulatedSchemaTransactionalDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/PopulatedSchemaTransactionalSqlScriptsTests.java similarity index 86% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/PopulatedSchemaTransactionalDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/PopulatedSchemaTransactionalSqlScriptsTests.java index b615f6cf4f3..9d6ca3dd86a 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/PopulatedSchemaTransactionalDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/PopulatedSchemaTransactionalSqlScriptsTests.java @@ -27,14 +27,14 @@ import static org.junit.Assert.*; /** * Transactional integration tests that verify rollback semantics for - * {@link DatabaseInitializer @DatabaseInitializer} support. + * {@link Sql @Sql} support. * * @author Sam Brannen * @since 4.1 */ @ContextConfiguration(classes = PopulatedSchemaDatabaseConfig.class) @DirtiesContext -public class PopulatedSchemaTransactionalDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class PopulatedSchemaTransactionalSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @BeforeTransaction @AfterTransaction @@ -43,7 +43,7 @@ public class PopulatedSchemaTransactionalDatabaseInitializerTests extends Abstra } @Test - @DatabaseInitializers(@DatabaseInitializer("data-add-dogbert.sql")) + @SqlGroup(@Sql("data-add-dogbert.sql")) public void methodLevelScripts() { assertNumUsers(1); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/RequiresNewTransactionDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/RequiresNewTransactionSqlScriptsTests.java similarity index 85% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/RequiresNewTransactionDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/RequiresNewTransactionSqlScriptsTests.java index 31e5d353535..c15a2e72f58 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/RequiresNewTransactionDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/RequiresNewTransactionSqlScriptsTests.java @@ -27,14 +27,14 @@ import static org.junit.Assert.*; /** * Transactional integration tests that verify commit semantics for - * {@link DatabaseInitializer#requireNewTransaction}. + * {@link Sql#requireNewTransaction}. * * @author Sam Brannen * @since 4.1 */ @ContextConfiguration(classes = PopulatedSchemaDatabaseConfig.class) @DirtiesContext -public class RequiresNewTransactionDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class RequiresNewTransactionSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @BeforeTransaction public void beforeTransaction() { @@ -42,7 +42,7 @@ public class RequiresNewTransactionDatabaseInitializerTests extends AbstractTran } @Test - @DatabaseInitializers(@DatabaseInitializer(scripts = "data-add-dogbert.sql", requireNewTransaction = true)) + @SqlGroup(@Sql(scripts = "data-add-dogbert.sql", requireNewTransaction = true)) public void methodLevelScripts() { assertNumUsers(1); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/DatabaseInitializerTestExecutionListenerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/SqlScriptsTestExecutionListenerTests.java similarity index 88% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/DatabaseInitializerTestExecutionListenerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/SqlScriptsTestExecutionListenerTests.java index 16c2e923a5c..58d2a6d60d8 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/DatabaseInitializerTestExecutionListenerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/SqlScriptsTestExecutionListenerTests.java @@ -24,14 +24,14 @@ import static org.junit.Assert.*; import static org.mockito.Mockito.*; /** - * Unit tests for {@link DatabaseInitializerTestExecutionListener}. + * Unit tests for {@link SqlScriptsTestExecutionListener}. * * @author Sam Brannen * @since 4.1 */ -public class DatabaseInitializerTestExecutionListenerTests { +public class SqlScriptsTestExecutionListenerTests { - private final DatabaseInitializerTestExecutionListener listener = new DatabaseInitializerTestExecutionListener(); + private final SqlScriptsTestExecutionListener listener = new SqlScriptsTestExecutionListener(); private final TestContext testContext = mock(TestContext.class); @@ -76,7 +76,7 @@ public class DatabaseInitializerTestExecutionListenerTests { // ------------------------------------------------------------------------- - @DatabaseInitializer + @Sql static class MissingValueAndScriptsAtClassLevel { public void foo() { @@ -85,14 +85,14 @@ public class DatabaseInitializerTestExecutionListenerTests { static class MissingValueAndScriptsAtMethodLevel { - @DatabaseInitializer + @Sql public void foo() { } } static class ValueAndScriptsDeclared { - @DatabaseInitializer(value = "foo", scripts = "bar") + @Sql(value = "foo", scripts = "bar") public void valueAndScriptsDeclared() { } } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalAfterTestMethodDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalAfterTestMethodSqlScriptsTests.java similarity index 76% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalAfterTestMethodDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalAfterTestMethodSqlScriptsTests.java index 632864da18a..6f6f58cd5fb 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalAfterTestMethodDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalAfterTestMethodSqlScriptsTests.java @@ -24,15 +24,16 @@ import org.junit.runners.MethodSorters; import org.springframework.jdbc.BadSqlGrammarException; import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.jdbc.DatabaseInitializer.ExecutionPhase; +import org.springframework.test.context.jdbc.Sql.ExecutionPhase; import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests; import org.springframework.test.context.transaction.AfterTransaction; import static org.junit.Assert.*; +import static org.springframework.test.context.jdbc.Sql.ExecutionPhase.*; /** - * Transactional integration tests for {@link DatabaseInitializer @DatabaseInitializer} - * that verify proper support for {@link ExecutionPhase#AFTER_TEST_METHOD}. + * Transactional integration tests for {@link Sql @Sql} that verify proper + * support for {@link ExecutionPhase#AFTER_TEST_METHOD}. * * @author Sam Brannen * @since 4.1 @@ -40,7 +41,7 @@ import static org.junit.Assert.*; @FixMethodOrder(MethodSorters.NAME_ASCENDING) @ContextConfiguration(classes = EmptyDatabaseConfig.class) @DirtiesContext -public class TransactionalAfterTestMethodDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class TransactionalAfterTestMethodSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @Rule public TestName testName = new TestName(); @@ -60,9 +61,9 @@ public class TransactionalAfterTestMethodDatabaseInitializerTests extends Abstra } @Test - @DatabaseInitializers({// - @DatabaseInitializer({ "schema.sql", "data.sql" }),// - @DatabaseInitializer(scripts = "drop-schema.sql", executionPhase = ExecutionPhase.AFTER_TEST_METHOD) // + @SqlGroup({// + @Sql({ "schema.sql", "data.sql" }),// + @Sql(scripts = "drop-schema.sql", executionPhase = AFTER_TEST_METHOD) // }) // test## is required for @FixMethodOrder. public void test01() { @@ -70,7 +71,7 @@ public class TransactionalAfterTestMethodDatabaseInitializerTests extends Abstra } @Test - @DatabaseInitializers(@DatabaseInitializer({ "schema.sql", "data.sql", "data-add-dogbert.sql" })) + @Sql({ "schema.sql", "data.sql", "data-add-dogbert.sql" }) // test## is required for @FixMethodOrder. public void test02() { assertNumUsers(2); diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalDatabaseInitializerTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalSqlScriptsTests.java similarity index 79% rename from spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalDatabaseInitializerTests.java rename to spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalSqlScriptsTests.java index 96c313fbfd9..6fd838e5758 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalDatabaseInitializerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/TransactionalSqlScriptsTests.java @@ -26,17 +26,16 @@ import org.springframework.test.context.junit4.AbstractTransactionalJUnit4Spring import static org.junit.Assert.*; /** - * Transactional integration tests for {@link DatabaseInitializer @DatabaseInitializer} - * support. + * Transactional integration tests for {@link Sql @Sql} support. * * @author Sam Brannen * @since 4.1 */ @FixMethodOrder(MethodSorters.NAME_ASCENDING) @ContextConfiguration(classes = EmptyDatabaseConfig.class) -@DatabaseInitializers(@DatabaseInitializer({ "schema.sql", "data.sql" })) +@Sql({ "schema.sql", "data.sql" }) @DirtiesContext -public class TransactionalDatabaseInitializerTests extends AbstractTransactionalJUnit4SpringContextTests { +public class TransactionalSqlScriptsTests extends AbstractTransactionalJUnit4SpringContextTests { @Test // test##_ prefix is required for @FixMethodOrder. @@ -45,7 +44,7 @@ public class TransactionalDatabaseInitializerTests extends AbstractTransactional } @Test - @DatabaseInitializers(@DatabaseInitializer({ "drop-schema.sql", "schema.sql", "data.sql", "data-add-dogbert.sql" })) + @Sql({ "drop-schema.sql", "schema.sql", "data.sql", "data-add-dogbert.sql" }) // test##_ prefix is required for @FixMethodOrder. public void test02_methodLevelScripts() { assertNumUsers(2);