From 7af134dfd058a78cde81666a9f68706b211240db Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sat, 17 May 2025 09:18:11 +0000 Subject: [PATCH 1/4] Modernize auto-configuration testing for issue #289 Co-Authored-By: backpaper0@gmail.com --- .../DomaAutoConfigurationTest.java | 659 +++++++++--------- 1 file changed, 336 insertions(+), 323 deletions(-) diff --git a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java index c638e1b..c1951d8 100644 --- a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java +++ b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java @@ -20,16 +20,13 @@ import java.sql.SQLException; import java.sql.SQLTimeoutException; -import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.function.Predicate; import javax.sql.DataSource; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.seasar.doma.boot.DomaPersistenceExceptionTranslator; import org.seasar.doma.boot.DomaSpringBootSqlBuilderSettings; import org.seasar.doma.boot.ResourceLoaderScriptFileLoader; @@ -62,8 +59,8 @@ import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.JdbcConnectionDetails; -import org.springframework.context.ConfigurableApplicationContext; -import org.springframework.context.annotation.AnnotationConfigApplicationContext; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.env.MapPropertySource; @@ -77,318 +74,334 @@ import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy; public class DomaAutoConfigurationTest { - AnnotationConfigApplicationContext context; - - @Before - public void setUp() { - this.context = new AnnotationConfigApplicationContext(); - } + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner(); @Test public void testAutoRegisteredConfig() { - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertThat(config, is(notNullValue())); - assertThat(config.getDataSource(), - is(instanceOf(TransactionAwareDataSourceProxy.class))); - assertThat(config.getDialect(), is(instanceOf(StandardDialect.class))); - assertThat(config.getSqlFileRepository(), - is(instanceOf(GreedyCacheSqlFileRepository.class))); - assertThat(config.getNaming(), is(Naming.DEFAULT)); - assertThat(config.getJdbcLogger(), is(instanceOf(Slf4jJdbcLogger.class))); - assertThat(config.getEntityListenerProvider(), is(notNullValue())); - assertThat(config.getDuplicateColumnHandler(), - is(ConfigSupport.defaultDuplicateColumnHandler)); - assertThat(config.getScriptFileLoader(), - is(instanceOf(ResourceLoaderScriptFileLoader.class))); - assertThat(config.getSqlBuilderSettings(), - is(instanceOf(DomaSpringBootSqlBuilderSettings.class))); - assertThat(config.getStatisticManager(), is(instanceOf(DefaultStatisticManager.class))); - PersistenceExceptionTranslator translator = this.context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config, is(notNullValue())); + assertThat(config.getDataSource(), + is(instanceOf(TransactionAwareDataSourceProxy.class))); + assertThat(config.getDialect(), is(instanceOf(StandardDialect.class))); + assertThat(config.getSqlFileRepository(), + is(instanceOf(GreedyCacheSqlFileRepository.class))); + assertThat(config.getNaming(), is(Naming.DEFAULT)); + assertThat(config.getJdbcLogger(), is(instanceOf(Slf4jJdbcLogger.class))); + assertThat(config.getEntityListenerProvider(), is(notNullValue())); + assertThat(config.getDuplicateColumnHandler(), + is(ConfigSupport.defaultDuplicateColumnHandler)); + assertThat(config.getScriptFileLoader(), + is(instanceOf(ResourceLoaderScriptFileLoader.class))); + assertThat(config.getSqlBuilderSettings(), + is(instanceOf(DomaSpringBootSqlBuilderSettings.class))); + assertThat(config.getStatisticManager(), is(instanceOf(DefaultStatisticManager.class))); + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testConfigWithDomaConfigBuilder() { - this.context.register(ConfigBuilderConfigure.class, DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertThat(config, is(notNullValue())); - assertThat(config.getDataSource(), - is(instanceOf(TransactionAwareDataSourceProxy.class))); - assertThat(config.getDialect(), is(instanceOf(MysqlDialect.class))); - assertThat(config.getSqlFileRepository(), - is(instanceOf(NoCacheSqlFileRepository.class))); - assertThat(config.getNaming(), is(Naming.SNAKE_UPPER_CASE)); - assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); - assertThat(config.getEntityListenerProvider(), - is(instanceOf(TestEntityListenerProvider.class))); - assertThat(config.getDuplicateColumnHandler(), - is(ConfigBuilderConfigure.testDuplicateColumnHandler)); - assertThat(config.getScriptFileLoader(), is(ConfigBuilderConfigure.testScriptFileLoader)); - assertThat(config.getSqlBuilderSettings(), - is(ConfigBuilderConfigure.testSqlBuilderSettings)); - assertThat(config.getStatisticManager(), is(ConfigBuilderConfigure.testStatisticManager)); - PersistenceExceptionTranslator translator = this.context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + this.contextRunner + .withUserConfiguration(ConfigBuilderConfigure.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config, is(notNullValue())); + assertThat(config.getDataSource(), + is(instanceOf(TransactionAwareDataSourceProxy.class))); + assertThat(config.getDialect(), is(instanceOf(MysqlDialect.class))); + assertThat(config.getSqlFileRepository(), + is(instanceOf(NoCacheSqlFileRepository.class))); + assertThat(config.getNaming(), is(Naming.SNAKE_UPPER_CASE)); + assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); + assertThat(config.getEntityListenerProvider(), + is(instanceOf(TestEntityListenerProvider.class))); + assertThat(config.getDuplicateColumnHandler(), + is(ConfigBuilderConfigure.testDuplicateColumnHandler)); + assertThat(config.getScriptFileLoader(), is(ConfigBuilderConfigure.testScriptFileLoader)); + assertThat(config.getSqlBuilderSettings(), + is(ConfigBuilderConfigure.testSqlBuilderSettings)); + assertThat(config.getStatisticManager(), is(ConfigBuilderConfigure.testStatisticManager)); + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testConfigWithConfig() { - this.context.register(ConfigConfigure.class, DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertThat(config, is(notNullValue())); - assertThat(config.getDataSource(), - is(instanceOf(TransactionAwareDataSourceProxy.class))); - assertThat(config.getDialect(), is(instanceOf(PostgresDialect.class))); - assertThat(config.getSqlFileRepository(), - is(instanceOf(NoCacheSqlFileRepository.class))); - assertThat(config.getNaming(), is(Naming.SNAKE_LOWER_CASE)); - assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); - assertThat(config.getEntityListenerProvider(), - is(instanceOf(TestEntityListenerProvider.class))); - assertThat(config.getDuplicateColumnHandler(), - is(ConfigConfigure.testDuplicateColumnHandler)); - assertThat(config.getScriptFileLoader(), is(ConfigConfigure.testScriptFileLoader)); - assertThat(config.getSqlBuilderSettings(), - is(ConfigConfigure.testSqlBuilderSettings)); - assertThat(config.getStatisticManager(), is(ConfigConfigure.testStatisticManager)); - PersistenceExceptionTranslator translator = this.context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); - } - - @Test(expected = NoSuchBeanDefinitionException.class) + this.contextRunner + .withUserConfiguration(ConfigConfigure.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config, is(notNullValue())); + assertThat(config.getDataSource(), + is(instanceOf(TransactionAwareDataSourceProxy.class))); + assertThat(config.getDialect(), is(instanceOf(PostgresDialect.class))); + assertThat(config.getSqlFileRepository(), + is(instanceOf(NoCacheSqlFileRepository.class))); + assertThat(config.getNaming(), is(Naming.SNAKE_LOWER_CASE)); + assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); + assertThat(config.getEntityListenerProvider(), + is(instanceOf(TestEntityListenerProvider.class))); + assertThat(config.getDuplicateColumnHandler(), + is(ConfigConfigure.testDuplicateColumnHandler)); + assertThat(config.getScriptFileLoader(), is(ConfigConfigure.testScriptFileLoader)); + assertThat(config.getSqlBuilderSettings(), + is(ConfigConfigure.testSqlBuilderSettings)); + assertThat(config.getStatisticManager(), is(ConfigConfigure.testStatisticManager)); + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); + } + + @Test public void testExceptionTranslationEnabledSpecifyFalse() { - EnvironmentTestUtils.addEnvironment(this.context, - "doma.exception-translation-enabled:false"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - this.context.getBean(PersistenceExceptionTranslator.class); + this.contextRunner + .withPropertyValues("doma.exception-translation-enabled=false") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + assertThrows(NoSuchBeanDefinitionException.class, () -> + context.getBean(PersistenceExceptionTranslator.class)); + }); } @Test public void testExceptionTranslationEnabledSpecifyTrue() { - EnvironmentTestUtils.addEnvironment(this.context, - "doma.exception-translation-enabled:true"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - PersistenceExceptionTranslator translator = this.context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + this.contextRunner + .withPropertyValues("doma.exception-translation-enabled=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testChangeDialect() { - EnvironmentTestUtils.addEnvironment(this.context, "doma.dialect:MYSQL"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Dialect dialect = this.context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(MysqlDialect.class))); + this.contextRunner + .withPropertyValues("doma.dialect=MYSQL") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(MysqlDialect.class))); + }); } @Test public void testChangeMaxRows() { - EnvironmentTestUtils.addEnvironment(this.context, "doma.max-rows:100"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertThat(config.getMaxRows(), is(100)); + this.contextRunner + .withPropertyValues("doma.max-rows=100") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config.getMaxRows(), is(100)); + }); } @Test public void testSQLExceptionTranslator() { - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - PersistenceExceptionTranslator translator = this.context - .getBean(PersistenceExceptionTranslator.class); - { - // Translated by SQLErrorCodeSQLExceptionTranslator - DataAccessException dataAccessException = translator - .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, - new SQLException("Acquire Lock on H2", "SqlState", 50200, - null))); - assertThat(dataAccessException, - is(instanceOf(CannotAcquireLockException.class))); - } - { - // Translated by SQLExceptionSubclassTranslator(fallback) - DataAccessException dataAccessException = translator - .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, - new SQLTimeoutException("Timeout", "SqlState", -1, null))); - assertThat(dataAccessException, is(instanceOf(QueryTimeoutException.class))); - } - { - // Translated by SQLStateSQLExceptionTranslator (fallback) - DataAccessException dataAccessException = translator - .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, - new SQLException("With check violation", "44", -1, null))); - assertThat(dataAccessException, - is(instanceOf(DataIntegrityViolationException.class))); - } + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + { + // Translated by SQLErrorCodeSQLExceptionTranslator + DataAccessException dataAccessException = translator + .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, + new SQLException("Acquire Lock on H2", "SqlState", 50200, + null))); + assertThat(dataAccessException, + is(instanceOf(CannotAcquireLockException.class))); + } + { + // Translated by SQLExceptionSubclassTranslator(fallback) + DataAccessException dataAccessException = translator + .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, + new SQLTimeoutException("Timeout", "SqlState", -1, null))); + assertThat(dataAccessException, is(instanceOf(QueryTimeoutException.class))); + } + { + // Translated by SQLStateSQLExceptionTranslator (fallback) + DataAccessException dataAccessException = translator + .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, + new SQLException("With check violation", "44", -1, null))); + assertThat(dataAccessException, + is(instanceOf(DataIntegrityViolationException.class))); + } + }); } @Test public void testAutoRegisteredCriteriaAPI() { - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.refresh(); - Entityql entityql = this.context.getBean(Entityql.class); - assertNotNull(entityql); - NativeSql nativeSql = this.context.getBean(NativeSql.class); - assertNotNull(nativeSql); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Entityql entityql = context.getBean(Entityql.class); + assertNotNull(entityql); + NativeSql nativeSql = context.getBean(NativeSql.class); + assertNotNull(nativeSql); + }); } @Test public void testCriteriaAPIWithConfig() { - this.context.register(MyCriteriaAPIConfig.class, DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Map entityqlBeans = this.context.getBeansOfType(Entityql.class); - assertEquals(1, entityqlBeans.size()); - assertNotNull(entityqlBeans.get("myEntityql")); - Map nativeSqlBeans = this.context.getBeansOfType(NativeSql.class); - assertEquals(1, nativeSqlBeans.size()); - assertNotNull(nativeSqlBeans.get("myNativeSql")); + this.contextRunner + .withUserConfiguration(MyCriteriaAPIConfig.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Map entityqlBeans = context.getBeansOfType(Entityql.class); + assertEquals(1, entityqlBeans.size()); + assertNotNull(entityqlBeans.get("myEntityql")); + Map nativeSqlBeans = context.getBeansOfType(NativeSql.class); + assertEquals(1, nativeSqlBeans.size()); + assertNotNull(nativeSqlBeans.get("myNativeSql")); + }); } @Test public void testDialectByDataSourceUrl() { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - sources.addFirst(new MapPropertySource("test", - Map.of("spring.datasource.url", "jdbc:postgresql://localhost:1234/example", - "doma.exception-translation-enabled", - "false" /* prevent database connections */))); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.refresh(); - Dialect dialect = this.context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); + this.contextRunner + .withPropertyValues( + "spring.datasource.url=jdbc:postgresql://localhost:1234/example", + "doma.exception-translation-enabled=false" /* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testDialectByJdbConnectionDetails() { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - sources.addFirst(new MapPropertySource("test", - Map.of("doma.exception-translation-enabled", - "false"/* prevent database connections */))); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.registerBean(JdbcConnectionDetails.class, () -> new JdbcConnectionDetails() { - @Override - public String getUsername() { - return "dummy"; - } - - @Override - public String getPassword() { - return "dummy"; - } - - @Override - public String getJdbcUrl() { - return "jdbc:postgresql://localhost:1234/example"; - } - }); - this.context.refresh(); - Dialect dialect = this.context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); + this.contextRunner + .withPropertyValues("doma.exception-translation-enabled=false"/* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .withBean(JdbcConnectionDetails.class, () -> new JdbcConnectionDetails() { + @Override + public String getUsername() { + return "dummy"; + } + + @Override + public String getPassword() { + return "dummy"; + } + + @Override + public String getJdbcUrl() { + return "jdbc:postgresql://localhost:1234/example"; + } + }) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testDialectMissingJdbConnectionDetails() { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - sources.addFirst(new MapPropertySource("test", - Map.of("doma.exception-translation-enabled", - "false"/* prevent database connections */))); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.registerBean(DataSource.class, SimpleDriverDataSource::new); - BeanCreationException exception = assertThrows(BeanCreationException.class, - () -> this.context.refresh()); - assertThat(exception.getMessage(), containsString( - "No connection details available. You will probably have to set 'doma.dialect' explicitly.")); + this.contextRunner + .withPropertyValues("doma.exception-translation-enabled=false"/* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .withBean(DataSource.class, SimpleDriverDataSource::new) + .run(context -> { + assertThat(context.getStartupFailure().getMessage(), containsString( + "No connection details available. You will probably have to set 'doma.dialect' explicitly.")); + }); } @Test public void testDialectMissingJdbConnectionDetailsExplicitDialect() { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - sources.addFirst(new MapPropertySource("test", - Map.of("doma.dialect", "POSTGRES", "doma.exception-translation-enabled", - "false"/* prevent database connections */))); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.registerBean(DataSource.class, SimpleDriverDataSource::new); - this.context.refresh(); - Dialect dialect = this.context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); + this.contextRunner + .withPropertyValues( + "doma.dialect=POSTGRES", + "doma.exception-translation-enabled=false"/* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .withBean(DataSource.class, SimpleDriverDataSource::new) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testDialectByDomaPropertiesIgnoreDataSourceUrl() { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - Map source = new HashMap<>(); - source.put("spring.datasource.url", "jdbc:h2:mem:example"); - source.put("doma.dialect", "POSTGRES"); - sources.addFirst(new MapPropertySource("test", source)); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.refresh(); - Dialect dialect = this.context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); + this.contextRunner + .withPropertyValues( + "spring.datasource.url=jdbc:h2:mem:example", + "doma.dialect=POSTGRES") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testJdbcLoggerSlf4J() { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - Map source = new HashMap<>(); - source.put("doma.jdbcLogger", "SLF4J"); - sources.addFirst(new MapPropertySource("test", source)); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.refresh(); - JdbcLogger jdbcLogger = this.context.getBean(JdbcLogger.class); - assertThat(jdbcLogger.getClass().getSimpleName(), is("Slf4jJdbcLogger")); + this.contextRunner + .withPropertyValues("doma.jdbcLogger=SLF4J") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .run(context -> { + JdbcLogger jdbcLogger = context.getBean(JdbcLogger.class); + assertThat(jdbcLogger.getClass().getSimpleName(), is("Slf4jJdbcLogger")); + }); } @Test public void testAutoRegisteredQueryDsl() { - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.refresh(); - QueryDsl queryDsl = this.context.getBean(QueryDsl.class); - assertNotNull(queryDsl); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .run(context -> { + QueryDsl queryDsl = context.getBean(QueryDsl.class); + assertNotNull(queryDsl); + }); } @Test public void testQueryDslWithConfig() { - this.context.register(MyQueryDslConfig.class, DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Map queryDslBeans = this.context.getBeansOfType(QueryDsl.class); - assertEquals(1, queryDslBeans.size()); - assertNotNull(queryDslBeans.get("myQueryDsl")); + this.contextRunner + .withUserConfiguration(MyQueryDslConfig.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Map queryDslBeans = context.getBeansOfType(QueryDsl.class); + assertEquals(1, queryDslBeans.size()); + assertNotNull(queryDslBeans.get("myQueryDsl")); + }); } @Test public void testThrowExceptionIfDuplicateColumn() { - EnvironmentTestUtils.addEnvironment(this.context, - "doma.throw-exception-if-duplicate-column:true"); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertThat(config.getDuplicateColumnHandler(), - is(instanceOf(ThrowingDuplicateColumnHandler.class))); + this.contextRunner + .withPropertyValues("doma.throw-exception-if-duplicate-column=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config.getDuplicateColumnHandler(), + is(instanceOf(ThrowingDuplicateColumnHandler.class))); + }); } @Test @@ -396,15 +409,17 @@ public void testCustomizeShouldRemoveBlockComment() { Predicate predicate = mock(Predicate.class); when(predicate.test(anyString())).thenReturn(true); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.registerBean("shouldRemoveBlockComment", Predicate.class, () -> predicate); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); - config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .withBean("shouldRemoveBlockComment", Predicate.class, () -> predicate) + .run(context -> { + Config config = context.getBean(Config.class); + config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); + config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); - verify(predicate, times(1)).test("shouldRemoveBlockComment"); - verifyNoMoreInteractions(predicate); + verify(predicate, times(1)).test("shouldRemoveBlockComment"); + verifyNoMoreInteractions(predicate); + }); } @Test @@ -412,15 +427,17 @@ public void testCustomizeShouldRemoveLineComment() { Predicate predicate = mock(Predicate.class); when(predicate.test(anyString())).thenReturn(true); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.registerBean("shouldRemoveLineComment", Predicate.class, () -> predicate); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); - config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .withBean("shouldRemoveLineComment", Predicate.class, () -> predicate) + .run(context -> { + Config config = context.getBean(Config.class); + config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); + config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); - verify(predicate, times(1)).test("shouldRemoveLineComment"); - verifyNoMoreInteractions(predicate); + verify(predicate, times(1)).test("shouldRemoveLineComment"); + verifyNoMoreInteractions(predicate); + }); } @Test @@ -428,82 +445,89 @@ public void testAnonymousPredicateAreNotAffected() { Predicate predicate = mock(Predicate.class); when(predicate.test(anyString())).thenReturn(true); - this.context.register(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class); - this.context.registerBean(Predicate.class, () -> predicate); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); - config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) + .withBean(Predicate.class, () -> predicate) + .run(context -> { + Config config = context.getBean(Config.class); + config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); + config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); - verifyNoInteractions(predicate); + verifyNoInteractions(predicate); + }); } @Test public void testShouldRemoveBlankLinesDefaultValue() { - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertFalse(config.getSqlBuilderSettings().shouldRemoveBlankLines()); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertFalse(config.getSqlBuilderSettings().shouldRemoveBlankLines()); + }); } @Test public void testShouldRemoveBlankLinesChangedValue() { - EnvironmentTestUtils.addEnvironment(this.context, - "doma.sql-builder-settings.should-remove-blank-lines:true"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertTrue(config.getSqlBuilderSettings().shouldRemoveBlankLines()); + this.contextRunner + .withPropertyValues("doma.sql-builder-settings.should-remove-blank-lines=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertTrue(config.getSqlBuilderSettings().shouldRemoveBlankLines()); + }); } @Test public void testShouldRequireInListPaddingDefaultValue() { - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertFalse(config.getSqlBuilderSettings().shouldRequireInListPadding()); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertFalse(config.getSqlBuilderSettings().shouldRequireInListPadding()); + }); } @Test public void testShouldRequireInListPaddingChangedValue() { - EnvironmentTestUtils.addEnvironment(this.context, - "doma.sql-builder-settings.should-require-in-list-padding:true"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertTrue(config.getSqlBuilderSettings().shouldRequireInListPadding()); + this.contextRunner + .withPropertyValues("doma.sql-builder-settings.should-require-in-list-padding=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertTrue(config.getSqlBuilderSettings().shouldRequireInListPadding()); + }); } @Test public void testStatisticManagerDefaultValue() { - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertFalse(config.getStatisticManager().isEnabled()); + this.contextRunner + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertFalse(config.getStatisticManager().isEnabled()); + }); } @Test public void testStatisticManagerChangedValue() { - EnvironmentTestUtils.addEnvironment(this.context, "doma.statistic-manager.enabled:true"); - this.context.register(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class); - this.context.refresh(); - Config config = this.context.getBean(Config.class); - assertTrue(config.getStatisticManager().isEnabled()); - } - - @After - public void tearDown() { - if (this.context != null) { - this.context.close(); - } + this.contextRunner + .withPropertyValues("doma.statistic-manager.enabled=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertTrue(config.getStatisticManager().isEnabled()); + }); } + // tearDown method removed - no longer needed with ApplicationContextRunner + @Configuration public static class ConfigBuilderConfigure { static DuplicateColumnHandler testDuplicateColumnHandler = new DuplicateColumnHandler() { @@ -597,18 +621,7 @@ public StatisticManager getStatisticManager() { static class TestEntityListenerProvider implements EntityListenerProvider { } - private static class EnvironmentTestUtils { - public static void addEnvironment(ConfigurableApplicationContext context, - String pair) { - MutablePropertySources sources = context.getEnvironment() - .getPropertySources(); - String[] split = pair.split(":"); - String key = split[0]; - String value = split[1]; - sources.addFirst(new MapPropertySource("test", Collections.singletonMap(key, - value))); - } - } + // EnvironmentTestUtils inner class removed - no longer needed with ApplicationContextRunner @Configuration public static class MyCriteriaAPIConfig { From 037728cff7ece87f2f444e94b089784025eeec2e Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sat, 17 May 2025 09:21:48 +0000 Subject: [PATCH 2/4] Apply formatter to DomaAutoConfigurationTest.java Co-Authored-By: backpaper0@gmail.com --- .../DomaAutoConfigurationTest.java | 624 +++++++++--------- 1 file changed, 326 insertions(+), 298 deletions(-) diff --git a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java index c1951d8..dd22ba4 100644 --- a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java +++ b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java @@ -79,329 +79,348 @@ public class DomaAutoConfigurationTest { @Test public void testAutoRegisteredConfig() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertThat(config, is(notNullValue())); - assertThat(config.getDataSource(), - is(instanceOf(TransactionAwareDataSourceProxy.class))); - assertThat(config.getDialect(), is(instanceOf(StandardDialect.class))); - assertThat(config.getSqlFileRepository(), - is(instanceOf(GreedyCacheSqlFileRepository.class))); - assertThat(config.getNaming(), is(Naming.DEFAULT)); - assertThat(config.getJdbcLogger(), is(instanceOf(Slf4jJdbcLogger.class))); - assertThat(config.getEntityListenerProvider(), is(notNullValue())); - assertThat(config.getDuplicateColumnHandler(), - is(ConfigSupport.defaultDuplicateColumnHandler)); - assertThat(config.getScriptFileLoader(), - is(instanceOf(ResourceLoaderScriptFileLoader.class))); - assertThat(config.getSqlBuilderSettings(), - is(instanceOf(DomaSpringBootSqlBuilderSettings.class))); - assertThat(config.getStatisticManager(), is(instanceOf(DefaultStatisticManager.class))); - PersistenceExceptionTranslator translator = context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config, is(notNullValue())); + assertThat(config.getDataSource(), + is(instanceOf(TransactionAwareDataSourceProxy.class))); + assertThat(config.getDialect(), is(instanceOf(StandardDialect.class))); + assertThat(config.getSqlFileRepository(), + is(instanceOf(GreedyCacheSqlFileRepository.class))); + assertThat(config.getNaming(), is(Naming.DEFAULT)); + assertThat(config.getJdbcLogger(), is(instanceOf(Slf4jJdbcLogger.class))); + assertThat(config.getEntityListenerProvider(), is(notNullValue())); + assertThat(config.getDuplicateColumnHandler(), + is(ConfigSupport.defaultDuplicateColumnHandler)); + assertThat(config.getScriptFileLoader(), + is(instanceOf(ResourceLoaderScriptFileLoader.class))); + assertThat(config.getSqlBuilderSettings(), + is(instanceOf(DomaSpringBootSqlBuilderSettings.class))); + assertThat(config.getStatisticManager(), + is(instanceOf(DefaultStatisticManager.class))); + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, + is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testConfigWithDomaConfigBuilder() { this.contextRunner - .withUserConfiguration(ConfigBuilderConfigure.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertThat(config, is(notNullValue())); - assertThat(config.getDataSource(), - is(instanceOf(TransactionAwareDataSourceProxy.class))); - assertThat(config.getDialect(), is(instanceOf(MysqlDialect.class))); - assertThat(config.getSqlFileRepository(), - is(instanceOf(NoCacheSqlFileRepository.class))); - assertThat(config.getNaming(), is(Naming.SNAKE_UPPER_CASE)); - assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); - assertThat(config.getEntityListenerProvider(), - is(instanceOf(TestEntityListenerProvider.class))); - assertThat(config.getDuplicateColumnHandler(), - is(ConfigBuilderConfigure.testDuplicateColumnHandler)); - assertThat(config.getScriptFileLoader(), is(ConfigBuilderConfigure.testScriptFileLoader)); - assertThat(config.getSqlBuilderSettings(), - is(ConfigBuilderConfigure.testSqlBuilderSettings)); - assertThat(config.getStatisticManager(), is(ConfigBuilderConfigure.testStatisticManager)); - PersistenceExceptionTranslator translator = context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); - }); + .withUserConfiguration(ConfigBuilderConfigure.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config, is(notNullValue())); + assertThat(config.getDataSource(), + is(instanceOf(TransactionAwareDataSourceProxy.class))); + assertThat(config.getDialect(), is(instanceOf(MysqlDialect.class))); + assertThat(config.getSqlFileRepository(), + is(instanceOf(NoCacheSqlFileRepository.class))); + assertThat(config.getNaming(), is(Naming.SNAKE_UPPER_CASE)); + assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); + assertThat(config.getEntityListenerProvider(), + is(instanceOf(TestEntityListenerProvider.class))); + assertThat(config.getDuplicateColumnHandler(), + is(ConfigBuilderConfigure.testDuplicateColumnHandler)); + assertThat(config.getScriptFileLoader(), + is(ConfigBuilderConfigure.testScriptFileLoader)); + assertThat(config.getSqlBuilderSettings(), + is(ConfigBuilderConfigure.testSqlBuilderSettings)); + assertThat(config.getStatisticManager(), + is(ConfigBuilderConfigure.testStatisticManager)); + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, + is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testConfigWithConfig() { this.contextRunner - .withUserConfiguration(ConfigConfigure.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertThat(config, is(notNullValue())); - assertThat(config.getDataSource(), - is(instanceOf(TransactionAwareDataSourceProxy.class))); - assertThat(config.getDialect(), is(instanceOf(PostgresDialect.class))); - assertThat(config.getSqlFileRepository(), - is(instanceOf(NoCacheSqlFileRepository.class))); - assertThat(config.getNaming(), is(Naming.SNAKE_LOWER_CASE)); - assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); - assertThat(config.getEntityListenerProvider(), - is(instanceOf(TestEntityListenerProvider.class))); - assertThat(config.getDuplicateColumnHandler(), - is(ConfigConfigure.testDuplicateColumnHandler)); - assertThat(config.getScriptFileLoader(), is(ConfigConfigure.testScriptFileLoader)); - assertThat(config.getSqlBuilderSettings(), - is(ConfigConfigure.testSqlBuilderSettings)); - assertThat(config.getStatisticManager(), is(ConfigConfigure.testStatisticManager)); - PersistenceExceptionTranslator translator = context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); - }); + .withUserConfiguration(ConfigConfigure.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config, is(notNullValue())); + assertThat(config.getDataSource(), + is(instanceOf(TransactionAwareDataSourceProxy.class))); + assertThat(config.getDialect(), is(instanceOf(PostgresDialect.class))); + assertThat(config.getSqlFileRepository(), + is(instanceOf(NoCacheSqlFileRepository.class))); + assertThat(config.getNaming(), is(Naming.SNAKE_LOWER_CASE)); + assertThat(config.getJdbcLogger(), is(instanceOf(UtilLoggingJdbcLogger.class))); + assertThat(config.getEntityListenerProvider(), + is(instanceOf(TestEntityListenerProvider.class))); + assertThat(config.getDuplicateColumnHandler(), + is(ConfigConfigure.testDuplicateColumnHandler)); + assertThat(config.getScriptFileLoader(), + is(ConfigConfigure.testScriptFileLoader)); + assertThat(config.getSqlBuilderSettings(), + is(ConfigConfigure.testSqlBuilderSettings)); + assertThat(config.getStatisticManager(), + is(ConfigConfigure.testStatisticManager)); + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, + is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testExceptionTranslationEnabledSpecifyFalse() { this.contextRunner - .withPropertyValues("doma.exception-translation-enabled=false") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - assertThrows(NoSuchBeanDefinitionException.class, () -> - context.getBean(PersistenceExceptionTranslator.class)); - }); + .withPropertyValues("doma.exception-translation-enabled=false") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + assertThrows(NoSuchBeanDefinitionException.class, + () -> context.getBean(PersistenceExceptionTranslator.class)); + }); } @Test public void testExceptionTranslationEnabledSpecifyTrue() { this.contextRunner - .withPropertyValues("doma.exception-translation-enabled=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - PersistenceExceptionTranslator translator = context - .getBean(PersistenceExceptionTranslator.class); - assertThat(translator, is(instanceOf(DomaPersistenceExceptionTranslator.class))); - }); + .withPropertyValues("doma.exception-translation-enabled=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + assertThat(translator, + is(instanceOf(DomaPersistenceExceptionTranslator.class))); + }); } @Test public void testChangeDialect() { this.contextRunner - .withPropertyValues("doma.dialect=MYSQL") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Dialect dialect = context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(MysqlDialect.class))); - }); + .withPropertyValues("doma.dialect=MYSQL") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(MysqlDialect.class))); + }); } @Test public void testChangeMaxRows() { this.contextRunner - .withPropertyValues("doma.max-rows=100") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertThat(config.getMaxRows(), is(100)); - }); + .withPropertyValues("doma.max-rows=100") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config.getMaxRows(), is(100)); + }); } @Test public void testSQLExceptionTranslator() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - PersistenceExceptionTranslator translator = context - .getBean(PersistenceExceptionTranslator.class); - { - // Translated by SQLErrorCodeSQLExceptionTranslator - DataAccessException dataAccessException = translator - .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, - new SQLException("Acquire Lock on H2", "SqlState", 50200, - null))); - assertThat(dataAccessException, - is(instanceOf(CannotAcquireLockException.class))); - } - { - // Translated by SQLExceptionSubclassTranslator(fallback) - DataAccessException dataAccessException = translator - .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, - new SQLTimeoutException("Timeout", "SqlState", -1, null))); - assertThat(dataAccessException, is(instanceOf(QueryTimeoutException.class))); - } - { - // Translated by SQLStateSQLExceptionTranslator (fallback) - DataAccessException dataAccessException = translator - .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, - new SQLException("With check violation", "44", -1, null))); - assertThat(dataAccessException, - is(instanceOf(DataIntegrityViolationException.class))); - } - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + PersistenceExceptionTranslator translator = context + .getBean(PersistenceExceptionTranslator.class); + { + // Translated by SQLErrorCodeSQLExceptionTranslator + DataAccessException dataAccessException = translator + .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, + new SQLException("Acquire Lock on H2", "SqlState", 50200, + null))); + assertThat(dataAccessException, + is(instanceOf(CannotAcquireLockException.class))); + } + { + // Translated by SQLExceptionSubclassTranslator(fallback) + DataAccessException dataAccessException = translator + .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, + new SQLTimeoutException("Timeout", "SqlState", -1, null))); + assertThat(dataAccessException, + is(instanceOf(QueryTimeoutException.class))); + } + { + // Translated by SQLStateSQLExceptionTranslator (fallback) + DataAccessException dataAccessException = translator + .translateExceptionIfPossible(new JdbcException(Message.DOMA2008, + new SQLException("With check violation", "44", -1, null))); + assertThat(dataAccessException, + is(instanceOf(DataIntegrityViolationException.class))); + } + }); } @Test public void testAutoRegisteredCriteriaAPI() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Entityql entityql = context.getBean(Entityql.class); - assertNotNull(entityql); - NativeSql nativeSql = context.getBean(NativeSql.class); - assertNotNull(nativeSql); - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Entityql entityql = context.getBean(Entityql.class); + assertNotNull(entityql); + NativeSql nativeSql = context.getBean(NativeSql.class); + assertNotNull(nativeSql); + }); } @Test public void testCriteriaAPIWithConfig() { this.contextRunner - .withUserConfiguration(MyCriteriaAPIConfig.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Map entityqlBeans = context.getBeansOfType(Entityql.class); - assertEquals(1, entityqlBeans.size()); - assertNotNull(entityqlBeans.get("myEntityql")); - Map nativeSqlBeans = context.getBeansOfType(NativeSql.class); - assertEquals(1, nativeSqlBeans.size()); - assertNotNull(nativeSqlBeans.get("myNativeSql")); - }); + .withUserConfiguration(MyCriteriaAPIConfig.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Map entityqlBeans = context.getBeansOfType(Entityql.class); + assertEquals(1, entityqlBeans.size()); + assertNotNull(entityqlBeans.get("myEntityql")); + Map nativeSqlBeans = context.getBeansOfType(NativeSql.class); + assertEquals(1, nativeSqlBeans.size()); + assertNotNull(nativeSqlBeans.get("myNativeSql")); + }); } @Test public void testDialectByDataSourceUrl() { this.contextRunner - .withPropertyValues( - "spring.datasource.url=jdbc:postgresql://localhost:1234/example", - "doma.exception-translation-enabled=false" /* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Dialect dialect = context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); - }); + .withPropertyValues( + "spring.datasource.url=jdbc:postgresql://localhost:1234/example", + "doma.exception-translation-enabled=false" /* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testDialectByJdbConnectionDetails() { this.contextRunner - .withPropertyValues("doma.exception-translation-enabled=false"/* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .withBean(JdbcConnectionDetails.class, () -> new JdbcConnectionDetails() { - @Override - public String getUsername() { - return "dummy"; - } - - @Override - public String getPassword() { - return "dummy"; - } - - @Override - public String getJdbcUrl() { - return "jdbc:postgresql://localhost:1234/example"; - } - }) - .run(context -> { - Dialect dialect = context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); - }); + .withPropertyValues( + "doma.exception-translation-enabled=false"/* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .withBean(JdbcConnectionDetails.class, () -> new JdbcConnectionDetails() { + @Override + public String getUsername() { + return "dummy"; + } + + @Override + public String getPassword() { + return "dummy"; + } + + @Override + public String getJdbcUrl() { + return "jdbc:postgresql://localhost:1234/example"; + } + }) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testDialectMissingJdbConnectionDetails() { this.contextRunner - .withPropertyValues("doma.exception-translation-enabled=false"/* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .withBean(DataSource.class, SimpleDriverDataSource::new) - .run(context -> { - assertThat(context.getStartupFailure().getMessage(), containsString( - "No connection details available. You will probably have to set 'doma.dialect' explicitly.")); - }); + .withPropertyValues( + "doma.exception-translation-enabled=false"/* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .withBean(DataSource.class, SimpleDriverDataSource::new) + .run(context -> { + assertThat(context.getStartupFailure().getMessage(), containsString( + "No connection details available. You will probably have to set 'doma.dialect' explicitly.")); + }); } @Test public void testDialectMissingJdbConnectionDetailsExplicitDialect() { this.contextRunner - .withPropertyValues( - "doma.dialect=POSTGRES", - "doma.exception-translation-enabled=false"/* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .withBean(DataSource.class, SimpleDriverDataSource::new) - .run(context -> { - Dialect dialect = context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); - }); + .withPropertyValues( + "doma.dialect=POSTGRES", + "doma.exception-translation-enabled=false"/* prevent database connections */) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .withBean(DataSource.class, SimpleDriverDataSource::new) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testDialectByDomaPropertiesIgnoreDataSourceUrl() { this.contextRunner - .withPropertyValues( - "spring.datasource.url=jdbc:h2:mem:example", - "doma.dialect=POSTGRES") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .run(context -> { - Dialect dialect = context.getBean(Dialect.class); - assertThat(dialect, is(instanceOf(PostgresDialect.class))); - }); + .withPropertyValues( + "spring.datasource.url=jdbc:h2:mem:example", + "doma.dialect=POSTGRES") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Dialect dialect = context.getBean(Dialect.class); + assertThat(dialect, is(instanceOf(PostgresDialect.class))); + }); } @Test public void testJdbcLoggerSlf4J() { this.contextRunner - .withPropertyValues("doma.jdbcLogger=SLF4J") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .run(context -> { - JdbcLogger jdbcLogger = context.getBean(JdbcLogger.class); - assertThat(jdbcLogger.getClass().getSimpleName(), is("Slf4jJdbcLogger")); - }); + .withPropertyValues("doma.jdbcLogger=SLF4J") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + JdbcLogger jdbcLogger = context.getBean(JdbcLogger.class); + assertThat(jdbcLogger.getClass().getSimpleName(), is("Slf4jJdbcLogger")); + }); } @Test public void testAutoRegisteredQueryDsl() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .run(context -> { - QueryDsl queryDsl = context.getBean(QueryDsl.class); - assertNotNull(queryDsl); - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + QueryDsl queryDsl = context.getBean(QueryDsl.class); + assertNotNull(queryDsl); + }); } @Test public void testQueryDslWithConfig() { this.contextRunner - .withUserConfiguration(MyQueryDslConfig.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Map queryDslBeans = context.getBeansOfType(QueryDsl.class); - assertEquals(1, queryDslBeans.size()); - assertNotNull(queryDslBeans.get("myQueryDsl")); - }); + .withUserConfiguration(MyQueryDslConfig.class) + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Map queryDslBeans = context.getBeansOfType(QueryDsl.class); + assertEquals(1, queryDslBeans.size()); + assertNotNull(queryDslBeans.get("myQueryDsl")); + }); } @Test public void testThrowExceptionIfDuplicateColumn() { this.contextRunner - .withPropertyValues("doma.throw-exception-if-duplicate-column=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertThat(config.getDuplicateColumnHandler(), - is(instanceOf(ThrowingDuplicateColumnHandler.class))); - }); + .withPropertyValues("doma.throw-exception-if-duplicate-column=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertThat(config.getDuplicateColumnHandler(), + is(instanceOf(ThrowingDuplicateColumnHandler.class))); + }); } @Test @@ -410,16 +429,19 @@ public void testCustomizeShouldRemoveBlockComment() { when(predicate.test(anyString())).thenReturn(true); this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .withBean("shouldRemoveBlockComment", Predicate.class, () -> predicate) - .run(context -> { - Config config = context.getBean(Config.class); - config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); - config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .withBean("shouldRemoveBlockComment", Predicate.class, () -> predicate) + .run(context -> { + Config config = context.getBean(Config.class); + config.getSqlBuilderSettings() + .shouldRemoveBlockComment("shouldRemoveBlockComment"); + config.getSqlBuilderSettings() + .shouldRemoveLineComment("shouldRemoveLineComment"); - verify(predicate, times(1)).test("shouldRemoveBlockComment"); - verifyNoMoreInteractions(predicate); - }); + verify(predicate, times(1)).test("shouldRemoveBlockComment"); + verifyNoMoreInteractions(predicate); + }); } @Test @@ -428,16 +450,19 @@ public void testCustomizeShouldRemoveLineComment() { when(predicate.test(anyString())).thenReturn(true); this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .withBean("shouldRemoveLineComment", Predicate.class, () -> predicate) - .run(context -> { - Config config = context.getBean(Config.class); - config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); - config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .withBean("shouldRemoveLineComment", Predicate.class, () -> predicate) + .run(context -> { + Config config = context.getBean(Config.class); + config.getSqlBuilderSettings() + .shouldRemoveBlockComment("shouldRemoveBlockComment"); + config.getSqlBuilderSettings() + .shouldRemoveLineComment("shouldRemoveLineComment"); - verify(predicate, times(1)).test("shouldRemoveLineComment"); - verifyNoMoreInteractions(predicate); - }); + verify(predicate, times(1)).test("shouldRemoveLineComment"); + verifyNoMoreInteractions(predicate); + }); } @Test @@ -446,84 +471,87 @@ public void testAnonymousPredicateAreNotAffected() { when(predicate.test(anyString())).thenReturn(true); this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, DataSourceAutoConfiguration.class)) - .withBean(Predicate.class, () -> predicate) - .run(context -> { - Config config = context.getBean(Config.class); - config.getSqlBuilderSettings().shouldRemoveBlockComment("shouldRemoveBlockComment"); - config.getSqlBuilderSettings().shouldRemoveLineComment("shouldRemoveLineComment"); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .withBean(Predicate.class, () -> predicate) + .run(context -> { + Config config = context.getBean(Config.class); + config.getSqlBuilderSettings() + .shouldRemoveBlockComment("shouldRemoveBlockComment"); + config.getSqlBuilderSettings() + .shouldRemoveLineComment("shouldRemoveLineComment"); - verifyNoInteractions(predicate); - }); + verifyNoInteractions(predicate); + }); } @Test public void testShouldRemoveBlankLinesDefaultValue() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertFalse(config.getSqlBuilderSettings().shouldRemoveBlankLines()); - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertFalse(config.getSqlBuilderSettings().shouldRemoveBlankLines()); + }); } @Test public void testShouldRemoveBlankLinesChangedValue() { this.contextRunner - .withPropertyValues("doma.sql-builder-settings.should-remove-blank-lines=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertTrue(config.getSqlBuilderSettings().shouldRemoveBlankLines()); - }); + .withPropertyValues("doma.sql-builder-settings.should-remove-blank-lines=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertTrue(config.getSqlBuilderSettings().shouldRemoveBlankLines()); + }); } @Test public void testShouldRequireInListPaddingDefaultValue() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertFalse(config.getSqlBuilderSettings().shouldRequireInListPadding()); - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertFalse(config.getSqlBuilderSettings().shouldRequireInListPadding()); + }); } @Test public void testShouldRequireInListPaddingChangedValue() { this.contextRunner - .withPropertyValues("doma.sql-builder-settings.should-require-in-list-padding=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertTrue(config.getSqlBuilderSettings().shouldRequireInListPadding()); - }); + .withPropertyValues("doma.sql-builder-settings.should-require-in-list-padding=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertTrue(config.getSqlBuilderSettings().shouldRequireInListPadding()); + }); } @Test public void testStatisticManagerDefaultValue() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertFalse(config.getStatisticManager().isEnabled()); - }); + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertFalse(config.getStatisticManager().isEnabled()); + }); } @Test public void testStatisticManagerChangedValue() { this.contextRunner - .withPropertyValues("doma.statistic-manager.enabled=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) - .run(context -> { - Config config = context.getBean(Config.class); - assertTrue(config.getStatisticManager().isEnabled()); - }); + .withPropertyValues("doma.statistic-manager.enabled=true") + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)) + .run(context -> { + Config config = context.getBean(Config.class); + assertTrue(config.getStatisticManager().isEnabled()); + }); } // tearDown method removed - no longer needed with ApplicationContextRunner From d7b9fb3735d0f6f03177ee3d4455138387a25675 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sat, 17 May 2025 21:45:06 +0000 Subject: [PATCH 3/4] Address PR feedback: remove unnecessary comments and consolidate auto-configurations Co-Authored-By: backpaper0@gmail.com --- .../DomaAutoConfigurationTest.java | 80 +++++-------------- 1 file changed, 19 insertions(+), 61 deletions(-) diff --git a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java index dd22ba4..a9183f8 100644 --- a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java +++ b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java @@ -74,13 +74,13 @@ import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy; public class DomaAutoConfigurationTest { - private final ApplicationContextRunner contextRunner = new ApplicationContextRunner(); + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, + DataSourceAutoConfiguration.class)); @Test public void testAutoRegisteredConfig() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Config config = context.getBean(Config.class); assertThat(config, is(notNullValue())); @@ -111,8 +111,6 @@ public void testAutoRegisteredConfig() { public void testConfigWithDomaConfigBuilder() { this.contextRunner .withUserConfiguration(ConfigBuilderConfigure.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Config config = context.getBean(Config.class); assertThat(config, is(notNullValue())); @@ -144,8 +142,6 @@ public void testConfigWithDomaConfigBuilder() { public void testConfigWithConfig() { this.contextRunner .withUserConfiguration(ConfigConfigure.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Config config = context.getBean(Config.class); assertThat(config, is(notNullValue())); @@ -177,8 +173,6 @@ public void testConfigWithConfig() { public void testExceptionTranslationEnabledSpecifyFalse() { this.contextRunner .withPropertyValues("doma.exception-translation-enabled=false") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { assertThrows(NoSuchBeanDefinitionException.class, () -> context.getBean(PersistenceExceptionTranslator.class)); @@ -189,8 +183,6 @@ public void testExceptionTranslationEnabledSpecifyFalse() { public void testExceptionTranslationEnabledSpecifyTrue() { this.contextRunner .withPropertyValues("doma.exception-translation-enabled=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { PersistenceExceptionTranslator translator = context .getBean(PersistenceExceptionTranslator.class); @@ -203,8 +195,6 @@ public void testExceptionTranslationEnabledSpecifyTrue() { public void testChangeDialect() { this.contextRunner .withPropertyValues("doma.dialect=MYSQL") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Dialect dialect = context.getBean(Dialect.class); assertThat(dialect, is(instanceOf(MysqlDialect.class))); @@ -215,8 +205,6 @@ public void testChangeDialect() { public void testChangeMaxRows() { this.contextRunner .withPropertyValues("doma.max-rows=100") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Config config = context.getBean(Config.class); assertThat(config.getMaxRows(), is(100)); @@ -226,8 +214,6 @@ public void testChangeMaxRows() { @Test public void testSQLExceptionTranslator() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { PersistenceExceptionTranslator translator = context .getBean(PersistenceExceptionTranslator.class); @@ -262,8 +248,6 @@ public void testSQLExceptionTranslator() { @Test public void testAutoRegisteredCriteriaAPI() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Entityql entityql = context.getBean(Entityql.class); assertNotNull(entityql); @@ -276,8 +260,6 @@ public void testAutoRegisteredCriteriaAPI() { public void testCriteriaAPIWithConfig() { this.contextRunner .withUserConfiguration(MyCriteriaAPIConfig.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Map entityqlBeans = context.getBeansOfType(Entityql.class); assertEquals(1, entityqlBeans.size()); @@ -294,8 +276,6 @@ public void testDialectByDataSourceUrl() { .withPropertyValues( "spring.datasource.url=jdbc:postgresql://localhost:1234/example", "doma.exception-translation-enabled=false" /* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .run(context -> { Dialect dialect = context.getBean(Dialect.class); assertThat(dialect, is(instanceOf(PostgresDialect.class))); @@ -307,8 +287,6 @@ public void testDialectByJdbConnectionDetails() { this.contextRunner .withPropertyValues( "doma.exception-translation-enabled=false"/* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) .withBean(JdbcConnectionDetails.class, () -> new JdbcConnectionDetails() { @Override public String getUsername() { @@ -336,8 +314,7 @@ public void testDialectMissingJdbConnectionDetails() { this.contextRunner .withPropertyValues( "doma.exception-translation-enabled=false"/* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .withBean(DataSource.class, SimpleDriverDataSource::new) .run(context -> { assertThat(context.getStartupFailure().getMessage(), containsString( @@ -351,8 +328,7 @@ public void testDialectMissingJdbConnectionDetailsExplicitDialect() { .withPropertyValues( "doma.dialect=POSTGRES", "doma.exception-translation-enabled=false"/* prevent database connections */) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .withBean(DataSource.class, SimpleDriverDataSource::new) .run(context -> { Dialect dialect = context.getBean(Dialect.class); @@ -366,8 +342,7 @@ public void testDialectByDomaPropertiesIgnoreDataSourceUrl() { .withPropertyValues( "spring.datasource.url=jdbc:h2:mem:example", "doma.dialect=POSTGRES") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Dialect dialect = context.getBean(Dialect.class); assertThat(dialect, is(instanceOf(PostgresDialect.class))); @@ -378,8 +353,7 @@ public void testDialectByDomaPropertiesIgnoreDataSourceUrl() { public void testJdbcLoggerSlf4J() { this.contextRunner .withPropertyValues("doma.jdbcLogger=SLF4J") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { JdbcLogger jdbcLogger = context.getBean(JdbcLogger.class); assertThat(jdbcLogger.getClass().getSimpleName(), is("Slf4jJdbcLogger")); @@ -389,8 +363,7 @@ public void testJdbcLoggerSlf4J() { @Test public void testAutoRegisteredQueryDsl() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { QueryDsl queryDsl = context.getBean(QueryDsl.class); assertNotNull(queryDsl); @@ -401,8 +374,7 @@ public void testAutoRegisteredQueryDsl() { public void testQueryDslWithConfig() { this.contextRunner .withUserConfiguration(MyQueryDslConfig.class) - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Map queryDslBeans = context.getBeansOfType(QueryDsl.class); assertEquals(1, queryDslBeans.size()); @@ -414,8 +386,7 @@ public void testQueryDslWithConfig() { public void testThrowExceptionIfDuplicateColumn() { this.contextRunner .withPropertyValues("doma.throw-exception-if-duplicate-column=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertThat(config.getDuplicateColumnHandler(), @@ -429,8 +400,7 @@ public void testCustomizeShouldRemoveBlockComment() { when(predicate.test(anyString())).thenReturn(true); this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .withBean("shouldRemoveBlockComment", Predicate.class, () -> predicate) .run(context -> { Config config = context.getBean(Config.class); @@ -450,8 +420,7 @@ public void testCustomizeShouldRemoveLineComment() { when(predicate.test(anyString())).thenReturn(true); this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .withBean("shouldRemoveLineComment", Predicate.class, () -> predicate) .run(context -> { Config config = context.getBean(Config.class); @@ -471,8 +440,7 @@ public void testAnonymousPredicateAreNotAffected() { when(predicate.test(anyString())).thenReturn(true); this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .withBean(Predicate.class, () -> predicate) .run(context -> { Config config = context.getBean(Config.class); @@ -488,8 +456,7 @@ public void testAnonymousPredicateAreNotAffected() { @Test public void testShouldRemoveBlankLinesDefaultValue() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertFalse(config.getSqlBuilderSettings().shouldRemoveBlankLines()); @@ -500,8 +467,7 @@ public void testShouldRemoveBlankLinesDefaultValue() { public void testShouldRemoveBlankLinesChangedValue() { this.contextRunner .withPropertyValues("doma.sql-builder-settings.should-remove-blank-lines=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertTrue(config.getSqlBuilderSettings().shouldRemoveBlankLines()); @@ -511,8 +477,7 @@ public void testShouldRemoveBlankLinesChangedValue() { @Test public void testShouldRequireInListPaddingDefaultValue() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertFalse(config.getSqlBuilderSettings().shouldRequireInListPadding()); @@ -523,8 +488,7 @@ public void testShouldRequireInListPaddingDefaultValue() { public void testShouldRequireInListPaddingChangedValue() { this.contextRunner .withPropertyValues("doma.sql-builder-settings.should-require-in-list-padding=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertTrue(config.getSqlBuilderSettings().shouldRequireInListPadding()); @@ -534,8 +498,7 @@ public void testShouldRequireInListPaddingChangedValue() { @Test public void testStatisticManagerDefaultValue() { this.contextRunner - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertFalse(config.getStatisticManager().isEnabled()); @@ -546,16 +509,13 @@ public void testStatisticManagerDefaultValue() { public void testStatisticManagerChangedValue() { this.contextRunner .withPropertyValues("doma.statistic-manager.enabled=true") - .withConfiguration(AutoConfigurations.of(DomaAutoConfiguration.class, - DataSourceAutoConfiguration.class)) + .run(context -> { Config config = context.getBean(Config.class); assertTrue(config.getStatisticManager().isEnabled()); }); } - // tearDown method removed - no longer needed with ApplicationContextRunner - @Configuration public static class ConfigBuilderConfigure { static DuplicateColumnHandler testDuplicateColumnHandler = new DuplicateColumnHandler() { @@ -649,8 +609,6 @@ public StatisticManager getStatisticManager() { static class TestEntityListenerProvider implements EntityListenerProvider { } - // EnvironmentTestUtils inner class removed - no longer needed with ApplicationContextRunner - @Configuration public static class MyCriteriaAPIConfig { From a8fa90fb40d7a79cb5c05dc387eb673b4d935cef Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 18 May 2025 01:48:08 +0000 Subject: [PATCH 4/4] Remove unused imports Co-Authored-By: backpaper0@gmail.com --- .../doma/boot/autoconfigure/DomaAutoConfigurationTest.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java index a9183f8..2aeddc7 100644 --- a/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java +++ b/doma-spring-boot-autoconfigure/src/test/java/org/seasar/doma/boot/autoconfigure/DomaAutoConfigurationTest.java @@ -20,7 +20,6 @@ import java.sql.SQLException; import java.sql.SQLTimeoutException; -import java.util.HashMap; import java.util.Map; import java.util.function.Predicate; @@ -55,7 +54,6 @@ import org.seasar.doma.jdbc.statistic.StatisticManager; import org.seasar.doma.message.Message; import org.seasar.doma.slf4j.Slf4jJdbcLogger; -import org.springframework.beans.factory.BeanCreationException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.JdbcConnectionDetails; @@ -63,8 +61,6 @@ import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import org.springframework.core.env.MapPropertySource; -import org.springframework.core.env.MutablePropertySources; import org.springframework.dao.CannotAcquireLockException; import org.springframework.dao.DataAccessException; import org.springframework.dao.DataIntegrityViolationException;