@DataJpaTest failing when converted to Java Modules

Question

I have tried everything and am pulling my hair out which is really bad because I don't have much left :P

I have a multimodule maven project which I am modularizing (Java modules).

I have several modules: domain, persistence and service, and something is seriously wrong testing the persistence layer. When I use the persistence module in the service layer it works fine. I am getting Negative Matches on the Conditions Evaluation Report. I suspect I am missing something in my module-info.java file.

I am using OpenJdk 14 targeted at Java 11 with SpringBoot 2.6.2, I would greatly appreciate any insight or can point me to a modularized spring boot project with tests for the persistence layer I would really appreciate it.

I have tried not having the persistence layer as a module but then you get 'does not read the unnamed module' errors in the service layer. This should work but I've been messing about for a few weeks now.

In my domain module I have:

@Entity(name = "product")
@Table(name = "product")
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class Product extends AbstractEntity {
    /***
     * stock keeping unit e.g. FX-IL-51-150
     */
    @Column(name = "product_sku", unique = true)
    private String sku;

    /***
     * manufacturers part number e.g. EEP130121001
     */
    @Column(name = "product_mpn", unique = true)
    private String mpn;

    /***
     * name of the product e.g. Ilok Flex 51mm ID x 150mm Long
     */
    @Column(name = "product_name")
    private String name;

    /***
     * description of the product e.g. Ilok lined flex, 100% stainless steel
     */
    @Column(name = "product_description", length = 1000)
    private String description;

    /***
     * The details associated with this product.  OneToMany used because the amount of details associated with a product
     * is likely to be small
     */
    @Builder.Default
    @OneToMany(mappedBy = "product", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
    private List<ProductDetail> productDetailList = new ArrayList<>();
}

module-info.java for domain, there is a lot of redundant requires in there because I tried putting the persistence layer in the domain module. At one point I was getting unmanaged type errors.

open module salesforce.domain {
    requires com.fasterxml.jackson.annotation;

    requires org.hibernate.orm.core;

    requires java.persistence;
    requires java.sql;
    requires java.validation;

    requires lombok;

    requires net.bytebuddy;

    requires spring.beans;
    requires spring.boot;
    requires spring.boot.autoconfigure;
    requires spring.context;
    requires spring.core;
    requires spring.data.commons;
    requires spring.data.jpa;
    requires spring.jdbc;
    requires spring.orm;
    requires spring.tx;

    exports com.eep.salesforce.domain;
    //exports com.eep.salesforce.persistence;

}

In the persistence module I have the following:

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    /***
     * Finds a product by it's sku
     * @param sku - the sku to search by
     * @return an optional containing the product if it exists
     */
    Optional<Product> findProductBySku(String sku);

    /***
     * Finds a product by it's mpn
     * @param mpn - the mpn to search by
     * @return an option containing the product if it exists
     */
    Optional<Product> findProductByMpn(String mpn);

    /***
     * Finds a product by it's uid
     * @param uid - the uid to search for
     * @return an optional containing the product if it exists else an empty Optional
     */
    Optional<Product> findProductByUid(UUID uid);

    /***
     * Deletes the product by it's uid (unique identifier)
     * @param uid - the uid to delete
     */
    void deleteByUid(UUID uid);

    /***
     * Returns a list of products by UIDs
     * @param uids a list of uids
     * @return a list of Product
     */
    List<Product> findProductsByUidIn(List<UUID> uids);
}

module-info.java for persistence is:

open module persistence {
    requires salesforce.domain;

    requires com.fasterxml.jackson.annotation;

    requires org.hibernate.orm.core;

    requires java.persistence;
    requires java.sql;
    requires java.validation;

    requires net.bytebuddy;

    requires spring.beans;
    requires spring.core;
    requires spring.context;
    requires spring.tx;
    requires spring.data.commons;
    requires spring.data.jpa;
    requires spring.boot;
    requires spring.boot.autoconfigure;

    exports com.eep.salesforce.repos;

    //opens com.eep.salesforce to spring.core;
}

the ProductRepositoryTest looks like the following:

@DataJpaTest
class ProductRepositoryTest {
    @Autowired
    ProductRepository productRepository;

    @Autowired
    TestEntityManager testEntityManager;

    private Product product1;
    private Product product2;
    private Product product3;
    private Product product4;


    @BeforeEach
    void setup() {
        product1 = Product.builder()
                .name("2 inch flex x 4 inch")
                .mpn("EEP25012201")
                .sku("FX-50-100-I")
                .build();

        product2 = Product.builder().name("2 inch flex x 6 inch")
                .mpn("EEP25012202")
                .sku("FX-50-150-I")
                .build();
        product3 = Product.builder()
                .name("2 inch flex x 8 inch")
                .mpn("EEP25012203")
                .sku("FX-50-200-I")
                .build();

        product4 = Product.builder().name("2 inch flex x 10 inch")
                .mpn("EEP25012204")
                .sku("FX-50-250-I")
                .build();


    }

    @Test
    void setupTest() {
        assertAll(
                () -> assertNotNull(productRepository),
                () -> assertNotNull(testEntityManager)
        );
    }

    @Test
    void findProductBySkuTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        var product = productRepository.findProductBySku("FX-50-150-I");

        assertAll(
                () -> assertTrue(product.isPresent()),
                () -> assertEquals(product, Optional.of(product2))
        );
    }

    @Test
    void findProductByNonExistantSkuReturnsOptionalEmptyTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        var product = productRepository.findProductBySku("FX-50-200-I");

        assertAll(
                () -> assertFalse(product.isPresent()),
                () -> assertEquals(product, Optional.empty())
        );
    }

    @Test
    void findProductByMpnTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        var product = productRepository.findProductByMpn("EEP25012201");

        assertAll(
                () -> assertTrue(product.isPresent()),
                () -> assertEquals(product, Optional.of(product1))
        );
    }

    @Test
    void findProductByNonExistantMpnReturnsOptionalEmptyTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        var product = productRepository.findProductByMpn("EEP25012204");

        assertAll(
                () -> assertFalse(product.isPresent()),
                () -> assertEquals(product, Optional.empty())
        );
    }

    @Test
    void findProductByUidTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        var product = productRepository.findProductByUid(product2.getUid());

        assertAll(
                () -> assertTrue(product.isPresent()),
                () -> assertEquals(product, Optional.of(product2))
        );
    }

    @Test
    void findProductByNonExistantUidReturnsOptionalEmptyTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        var uid = UUID.randomUUID();
        //should theoretically never happen...
        while(uid.equals(product1.getUid()))
            uid = UUID.randomUUID();

        var product = productRepository.findProductByUid(uid);

        assertAll(
                () -> assertFalse(product.isPresent()),
                () -> assertEquals(product, Optional.empty())
        );
    }

    @Test
    void deleteByUidTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);

        UUID uid = product1.getUid();

        var product = productRepository.findProductByUid(uid);

        productRepository.deleteByUid(uid);

        var product2 = productRepository.findProductByUid(uid);

        assertAll(
                () -> assertTrue(product.isPresent()),
                () -> assertFalse(product2.isPresent()),
                () -> assertEquals(product, Optional.of(product1)),
                () -> assertEquals(product2, Optional.empty())
        );
    }

    @Test
    void findProductsByUidsInTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);
        product3 = testEntityManager.persistAndFlush(product3);
        product4 = testEntityManager.persistAndFlush(product4);

        var products = productRepository.findProductsByUidIn(Arrays.asList(
                product1.getUid(),
                product3.getUid()
        ));

        assertAll(
                () -> assertEquals(products.size(), 2),
                () -> assertTrue(products.containsAll(Arrays.asList(product1, product3)))
        );
    }

    @Test
    void findProductsByNonexistantUidsInTest() {
        product1 = testEntityManager.persistAndFlush(product1);
        product2 = testEntityManager.persistAndFlush(product2);
        product3 = testEntityManager.persistAndFlush(product3);
        product4 = testEntityManager.persistAndFlush(product4);

        var products = productRepository.findProductsByUidIn(Arrays.asList(
                UUID.randomUUID(),
                product2.getUid(),
                product3.getUid()
        ));

        assertAll(
                () -> assertEquals(products.size(), 2),
                () -> assertTrue(products.containsAll(Arrays.asList(product2, product3)))
        );
    }
}

and the test configuration is coming from @SpringBootApplication in PersistenceApplicationTests.java

@SpringBootApplication
@EntityScan("com.eep.salesforce.domain")
class PersistenceApplicationTests {

    public static void main(String[] args) {
        SpringApplication.run(PersistenceApplicationTests.class, args);
    }

}

The error I am getting is

============================
CONDITIONS EVALUATION REPORT
============================


Positive matches:
-----------------

   DataSourceAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'javax.sql.DataSource', 'org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType' (OnClassCondition)
      - @ConditionalOnMissingBean (types: io.r2dbc.spi.ConnectionFactory; SearchStrategy: all) did not find any beans (OnBeanCondition)

   DataSourceAutoConfiguration.PooledDataSourceConfiguration matched:
      - AnyNestedCondition 1 matched 1 did not; NestedCondition on DataSourceAutoConfiguration.PooledDataSourceCondition.PooledDataSourceAvailable PooledDataSource found supported DataSource; NestedCondition on DataSourceAutoConfiguration.PooledDataSourceCondition.ExplicitType @ConditionalOnProperty (spring.datasource.type) did not find property 'type' (DataSourceAutoConfiguration.PooledDataSourceCondition)
      - @ConditionalOnMissingBean (types: javax.sql.DataSource,javax.sql.XADataSource; SearchStrategy: all) did not find any beans (OnBeanCondition)

   DataSourceConfiguration.Hikari matched:
      - @ConditionalOnClass found required class 'com.zaxxer.hikari.HikariDataSource' (OnClassCondition)
      - @ConditionalOnProperty (spring.datasource.type=com.zaxxer.hikari.HikariDataSource) matched (OnPropertyCondition)
      - @ConditionalOnMissingBean (types: javax.sql.DataSource; SearchStrategy: all) did not find any beans (OnBeanCondition)

   DataSourceInitializationConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.jdbc.datasource.init.DatabasePopulator' (OnClassCondition)
      - @ConditionalOnSingleCandidate (types: javax.sql.DataSource; SearchStrategy: all) found a primary bean from beans 'dataSource'; @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.sql.init.SqlDataSourceScriptDatabaseInitializer,org.springframework.boot.autoconfigure.sql.init.SqlR2dbcScriptDatabaseInitializer; SearchStrategy: all) did not find any beans (OnBeanCondition)

   DataSourcePoolMetadataProvidersConfiguration.HikariPoolDataSourceMetadataProviderConfiguration matched:
      - @ConditionalOnClass found required class 'com.zaxxer.hikari.HikariDataSource' (OnClassCondition)

   DataSourceTransactionManagerAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'org.springframework.jdbc.core.JdbcTemplate', 'org.springframework.transaction.TransactionManager' (OnClassCondition)

   DataSourceTransactionManagerAutoConfiguration.JdbcTransactionManagerConfiguration matched:
      - @ConditionalOnSingleCandidate (types: javax.sql.DataSource; SearchStrategy: all) found a primary bean from beans 'dataSource' (OnBeanCondition)

   HibernateJpaAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean', 'javax.persistence.EntityManager', 'org.hibernate.engine.spi.SessionImplementor' (OnClassCondition)

   HibernateJpaConfiguration matched:
      - @ConditionalOnSingleCandidate (types: javax.sql.DataSource; SearchStrategy: all) found a primary bean from beans 'dataSource' (OnBeanCondition)

   JdbcTemplateAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'javax.sql.DataSource', 'org.springframework.jdbc.core.JdbcTemplate' (OnClassCondition)
      - @ConditionalOnSingleCandidate (types: javax.sql.DataSource; SearchStrategy: all) found a primary bean from beans 'dataSource' (OnBeanCondition)

   JdbcTemplateConfiguration matched:
      - @ConditionalOnMissingBean (types: org.springframework.jdbc.core.JdbcOperations; SearchStrategy: all) did not find any beans (OnBeanCondition)

   JpaBaseConfiguration#entityManagerFactory matched:
      - @ConditionalOnMissingBean (types: org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean,javax.persistence.EntityManagerFactory; SearchStrategy: all) did not find any beans (OnBeanCondition)

   JpaBaseConfiguration#entityManagerFactoryBuilder matched:
      - @ConditionalOnMissingBean (types: org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; SearchStrategy: all) did not find any beans (OnBeanCondition)

   JpaBaseConfiguration#jpaVendorAdapter matched:
      - @ConditionalOnMissingBean (types: org.springframework.orm.jpa.JpaVendorAdapter; SearchStrategy: all) did not find any beans (OnBeanCondition)

   JpaBaseConfiguration#transactionManager matched:
      - @ConditionalOnMissingBean (types: org.springframework.transaction.TransactionManager; SearchStrategy: all) did not find any beans (OnBeanCondition)

   JpaRepositoriesAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.data.jpa.repository.JpaRepository' (OnClassCondition)
      - @ConditionalOnProperty (spring.data.jpa.repositories.enabled=true) matched (OnPropertyCondition)
      - @ConditionalOnBean (types: javax.sql.DataSource; SearchStrategy: all) found bean 'dataSource'; @ConditionalOnMissingBean (types: org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean,org.springframework.data.jpa.repository.config.JpaRepositoryConfigExtension; SearchStrategy: all) did not find any beans (OnBeanCondition)

   NamedParameterJdbcTemplateConfiguration matched:
      - @ConditionalOnSingleCandidate (types: org.springframework.jdbc.core.JdbcTemplate; SearchStrategy: all) found a primary bean from beans 'jdbcTemplate'; @ConditionalOnMissingBean (types: org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; SearchStrategy: all) did not find any beans (OnBeanCondition)

   NoOpCacheConfiguration matched:
      - Cache org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration NONE cache type (CacheCondition)

   SqlInitializationAutoConfiguration matched:
      - @ConditionalOnProperty (spring.sql.init.enabled) matched (OnPropertyCondition)
      - NoneNestedConditions 0 matched 1 did not; NestedCondition on SqlInitializationAutoConfiguration.SqlInitializationModeCondition.ModeIsNever @ConditionalOnProperty (spring.sql.init.mode=never) did not find property 'mode' (SqlInitializationAutoConfiguration.SqlInitializationModeCondition)

   TestDatabaseAutoConfiguration#embeddedDataSourceBeanFactoryPostProcessor matched:
      - @ConditionalOnProperty (spring.test.database.replace=ANY) matched (OnPropertyCondition)

   TestEntityManagerAutoConfiguration matched:
      - @ConditionalOnClass found required class 'javax.persistence.EntityManagerFactory' (OnClassCondition)

   TestEntityManagerAutoConfiguration#testEntityManager matched:
      - @ConditionalOnMissingBean (types: org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; SearchStrategy: all) did not find any beans (OnBeanCondition)

   TransactionAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.transaction.PlatformTransactionManager' (OnClassCondition)

   TransactionAutoConfiguration#platformTransactionManagerCustomizers matched:
      - @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.transaction.TransactionManagerCustomizers; SearchStrategy: all) did not find any beans (OnBeanCondition)

   TransactionAutoConfiguration.EnableTransactionManagementConfiguration matched:
      - @ConditionalOnBean (types: org.springframework.transaction.TransactionManager; SearchStrategy: all) found bean 'transactionManager'; @ConditionalOnMissingBean (types: org.springframework.transaction.annotation.AbstractTransactionManagementConfiguration; SearchStrategy: all) did not find any beans (OnBeanCondition)

   TransactionAutoConfiguration.EnableTransactionManagementConfiguration.CglibAutoProxyConfiguration matched:
      - @ConditionalOnProperty (spring.aop.proxy-target-class=true) matched (OnPropertyCondition)

   TransactionAutoConfiguration.TransactionTemplateConfiguration matched:
      - @ConditionalOnSingleCandidate (types: org.springframework.transaction.PlatformTransactionManager; SearchStrategy: all) found a primary bean from beans 'transactionManager' (OnBeanCondition)

   TransactionAutoConfiguration.TransactionTemplateConfiguration#transactionTemplate matched:
      - @ConditionalOnMissingBean (types: org.springframework.transaction.support.TransactionOperations; SearchStrategy: all) did not find any beans (OnBeanCondition)


Negative matches:
-----------------

   CacheAutoConfiguration:
      Did not match:
         - @ConditionalOnBean (types: org.springframework.cache.interceptor.CacheAspectSupport; SearchStrategy: all) did not find any beans of type org.springframework.cache.interceptor.CacheAspectSupport (OnBeanCondition)
      Matched:
         - @ConditionalOnClass found required class 'org.springframework.cache.CacheManager' (OnClassCondition)

   CacheAutoConfiguration.CacheManagerEntityManagerFactoryDependsOnPostProcessor:
      Did not match:
         - Ancestor org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration did not match (ConditionEvaluationReport.AncestorsMatchedCondition)
      Matched:
         - @ConditionalOnClass found required class 'org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean' (OnClassCondition)

   CaffeineCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'com.github.benmanes.caffeine.cache.Caffeine' (OnClassCondition)

   CouchbaseCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'com.couchbase.client.java.Cluster' (OnClassCondition)

   DataSourceAutoConfiguration.EmbeddedDatabaseConfiguration:
      Did not match:
         - EmbeddedDataSource spring.datasource.url is set (DataSourceAutoConfiguration.EmbeddedDatabaseCondition)

   DataSourceConfiguration.Dbcp2:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.apache.commons.dbcp2.BasicDataSource' (OnClassCondition)

   DataSourceConfiguration.Generic:
      Did not match:
         - @ConditionalOnProperty (spring.datasource.type) did not find property 'spring.datasource.type' (OnPropertyCondition)

   DataSourceConfiguration.OracleUcp:
      Did not match:
         - @ConditionalOnClass did not find required classes 'oracle.ucp.jdbc.PoolDataSourceImpl', 'oracle.jdbc.OracleConnection' (OnClassCondition)

   DataSourceConfiguration.Tomcat:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.apache.tomcat.jdbc.pool.DataSource' (OnClassCondition)

   DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration:
      Did not match:
         - AnyNestedCondition 0 matched 2 did not; NestedCondition on DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.DifferentCredentialsCondition.DataCredentials @ConditionalOnProperty (spring.datasource.data-username) did not find property 'data-username'; NestedCondition on DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.DifferentCredentialsCondition.SchemaCredentials @ConditionalOnProperty (spring.datasource.schema-username) did not find property 'schema-username' (DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.DifferentCredentialsCondition)

   DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration:
      Did not match:
         - DataSource Initialization did not find configured properties spring.datasource.data-username, spring.datasource.schema-password, spring.datasource.schema[0], spring.datasource.data[0], spring.datasource.data, spring.datasource.schema-username, spring.datasource.data-password, spring.datasource.initialization-mode, spring.datasource.schema, spring.datasource.sql-script-encoding, spring.datasource.separator, spring.datasource.platform, spring.datasource.continue-on-error (DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.DataSourceInitializationCondition)

   DataSourceJmxConfiguration:
      Did not match:
         - @ConditionalOnProperty (spring.jmx.enabled=true) found different value in property 'enabled' (OnPropertyCondition)

   DataSourcePoolMetadataProvidersConfiguration.CommonsDbcp2PoolDataSourceMetadataProviderConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.apache.commons.dbcp2.BasicDataSource' (OnClassCondition)

   DataSourcePoolMetadataProvidersConfiguration.OracleUcpPoolDataSourceMetadataProviderConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'oracle.ucp.jdbc.PoolDataSource', 'oracle.jdbc.OracleConnection' (OnClassCondition)

   DataSourcePoolMetadataProvidersConfiguration.TomcatDataSourcePoolMetadataProviderConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.apache.tomcat.jdbc.pool.DataSource' (OnClassCondition)

   DataSourceTransactionManagerAutoConfiguration.JdbcTransactionManagerConfiguration#transactionManager:
      Did not match:
         - @ConditionalOnMissingBean (types: org.springframework.transaction.TransactionManager; SearchStrategy: all) found beans of type 'org.springframework.transaction.TransactionManager' transactionManager (OnBeanCondition)

   EhCacheCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'net.sf.ehcache.Cache' (OnClassCondition)

   FlywayAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.flywaydb.core.Flyway' (OnClassCondition)

   GenericCacheConfiguration:
      Did not match:
         - Cache org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration unknown cache type (CacheCondition)

   HazelcastCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'com.hazelcast.core.HazelcastInstance' (OnClassCondition)

   InfinispanCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager' (OnClassCondition)

   JCacheCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.cache.Caching' (OnClassCondition)

   JpaBaseConfiguration.JpaWebConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.springframework.web.servlet.config.annotation.WebMvcConfigurer' (OnClassCondition)

   JpaRepositoriesAutoConfiguration#entityManagerFactoryBootstrapExecutorCustomizer:
      Did not match:
         - AnyNestedCondition 0 matched 2 did not; NestedCondition on JpaRepositoriesAutoConfiguration.BootstrapExecutorCondition.LazyBootstrapMode @ConditionalOnProperty (spring.data.jpa.repositories.bootstrap-mode=lazy) found different value in property 'bootstrap-mode'; NestedCondition on JpaRepositoriesAutoConfiguration.BootstrapExecutorCondition.DeferredBootstrapMode @ConditionalOnProperty (spring.data.jpa.repositories.bootstrap-mode=deferred) found different value in property 'bootstrap-mode' (JpaRepositoriesAutoConfiguration.BootstrapExecutorCondition)

   LiquibaseAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'liquibase.change.DatabaseChange' (OnClassCondition)

   R2dbcInitializationConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'io.r2dbc.spi.ConnectionFactory', 'org.springframework.r2dbc.connection.init.DatabasePopulator' (OnClassCondition)

   RedisCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.springframework.data.redis.connection.RedisConnectionFactory' (OnClassCondition)

   SimpleCacheConfiguration:
      Did not match:
         - Cache org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration unknown cache type (CacheCondition)

   TestDatabaseAutoConfiguration#dataSource:
      Did not match:
         - @ConditionalOnProperty (spring.test.database.replace=AUTO_CONFIGURED) did not find property 'replace' (OnPropertyCondition)

   TransactionAutoConfiguration#transactionalOperator:
      Did not match:
         - @ConditionalOnSingleCandidate (types: org.springframework.transaction.ReactiveTransactionManager; SearchStrategy: all) did not find any beans (OnBeanCondition)

   TransactionAutoConfiguration.EnableTransactionManagementConfiguration.JdkDynamicAutoProxyConfiguration:
      Did not match:
         - @ConditionalOnProperty (spring.aop.proxy-target-class=false) did not find property 'proxy-target-class' (OnPropertyCondition)


Exclusions:
-----------

    None


Unconditional classes:
----------------------

    org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfiguration