如何在Maven中配置JPA以进行测试


68

有没有一种方法可以在Maven项目中设置第二个persistence.xml文件,以使其用于测试,而不是用于部署的常规文件?

我尝试将persistence.xml放入src / test / resources / META-INF中,该副本被复制到target / test-classes / META-INF中,但似乎是target / classes / META-INF(来自src / main的副本/ resources)成为首选,尽管mvn -X test以正确的顺序列出了类路径条目:

[DEBUG] Test Classpath :
[DEBUG]   /home/uqpbecke/dev/NetBeansProjects/UserManager/target/test-classes
[DEBUG]   /home/uqpbecke/dev/NetBeansProjects/UserManager/target/classes
[DEBUG]   /home/uqpbecke/.m2/repository/junit/junit/4.5/junit-4.5.jar
...

我希望能够针对简单的hsqldb配置运行测试,而不必更改JPA配置的部署版本,理想情况下,在项目检出后立即进行,而无需进行任何本地调整。

Answers:


26

以下内容适用于Maven 2.1+(在测试和程序包之间没有可以绑定执行的阶段之前)。

您可以在测试期间使用maven-antrun-plugin将persistence.xml替换为测试版本,然后在打包项目之前还原正确的版本。

本示例假定生产版本为src / main / resources / META-INF / persistence.xml,测试版本为src / test / resources / META-INF / persistence.xml,因此将其复制到target / classes / META -INF和目标/测试类别/ META-INF。

将其封装到mojo中会更加优雅,但是由于您仅复制文件,因此似乎有些过头。

<plugin>
  <artifactId>maven-antrun-plugin</artifactId>
  <version>1.3</version>
  <executions>
    <execution>
      <id>copy-test-persistence</id>
      <phase>process-test-resources</phase>
      <configuration>
        <tasks>
          <!--backup the "proper" persistence.xml-->
          <copy file="${project.build.outputDirectory}/META-INF/persistence.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml.proper"/>
          <!--replace the "proper" persistence.xml with the "test" version-->
          <copy file="${project.build.testOutputDirectory}/META-INF/persistence.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml"/>
        </tasks>
      </configuration>
      <goals>
        <goal>run</goal>
      </goals>
    </execution>
    <execution>
      <id>restore-persistence</id>
      <phase>prepare-package</phase>
      <configuration>
        <tasks>
          <!--restore the "proper" persistence.xml-->
          <copy file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml"/>
        </tasks>
      </configuration>
      <goals>
        <goal>run</goal>
      </goals>
    </execution>
  </executions>
</plugin>

2
确实,这是一个巧妙的解决方案。但是,可能还需要将overwite =“ true”属性添加到上一个Ant任务中,以确保将正确的XML文件复制回去。在我的环境中,由于目的地和目标的时间戳相同,它似乎失败了。
Vineet Reynolds,2010年

20

在EE6 / CDI / JPA项目中,src/test/resources/META-INF/persistence.xml无需任何进一步配置就可以很好地进行测试。

在Spring中使用JPA时,以下将在用于测试的应用程序上下文中起作用:

<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!--
        JPA requires META-INF/persistence.xml, but somehow prefers the one
        in classes/META-INF over the one in test-classes/META-INF. Spring
        to the rescue, as it allows for setting things differently, like by
        referring to "classpath:persistence-TEST.xml". Or, simply referring
        to "META-INF/persistence.xml" makes JPA use the test version too: 
    -->
    <property name="persistenceXmlLocation" value="META-INF/persistence.xml" />

    <!-- As defined in /src/test/resources/META-INF/persistence.xml -->
    <property name="persistenceUnitName" value="myTestPersistenceUnit" />
    <property name="jpaVendorAdapter">
        <bean
            class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        </bean>
    </property>
</bean>

在这里,/src/test/resources/META-INF/persistence.xml(复制到target/test-classes)比/src/main/resources/META-INF/persistence.xml(复制到target/classes)更可取。

不幸的是,persistence.xml文件的位置也确定了所谓的“持久性单元的根”,然后确定了要扫描哪些类的@Entity注释。因此,使用/src/test/resources/META-INF/persistence.xml将扫描中的类target/test-classes,而不是中的类target/classes(需要测试的类将存在)。

因此,为了进行测试,需要向显式添加<class>条目persistence.xml以避免java.lang.IllegalArgumentException: Not an entity: class ...。需要<class>的条目可以通过使用不同的文件名,如避免persistence-TEST.xml,并把该文件中的非常相同的文件夹常规persistence.xml文件。然后可以从您的测试文件夹中引用Spring上下文<property name="persistenceXmlLocation" value="META-INF/persistence-TEST.xml" />,Spring会在中为您找到它src/main

作为一种替代方法,persistence.xml对于实际的应用程序和测试,可以保持相同,并且仅在中定义一个src/main。大多数配置(例如驱动程序,方言和可选凭据)都可以在Spring上下文中完成。也hibernate.hbm2ddl.auto可以在上下文中传递诸如之类的设置:

<bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <!-- For example: com.mysql.jdbc.Driver or org.h2.Driver -->
    <property name="driverClassName" value="#{myConfig['db.driver']}" />
    <!-- For example: jdbc:mysql://localhost:3306/myDbName or 
        jdbc:h2:mem:test;DB_CLOSE_DELAY=-1 -->
    <property name="url" value="#{myConfig['db.url']}" />
    <!-- Ignored for H2 -->
    <property name="username" value="#{myConfig['db.username']}" />
    <property name="password" value="#{myConfig['db.password']}" />
</bean>

<bean id="jpaAdaptor"
    class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
    <!-- For example: org.hibernate.dialect.MySQL5Dialect or 
        org.hibernate.dialect.H2Dialect -->
    <property name="databasePlatform" value="#{myConfig['db.dialect']}" />
</bean>

<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="jpaVendorAdapter" ref="jpaAdapter" />
    <property name="jpaProperties">
        <props>
            <!-- For example: validate, update, create or create-drop -->
            <prop key="hibernate.hbm2ddl.auto">#{myConfig['db.ddl']}</prop>
            <prop key="hibernate.show_sql">#{myConfig['db.showSql']}</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
</bean>

2
最初的问题中没有关于春天的消息。
德米特里·凯戈罗多夫

1
是的,@ Dmitry,但这值得您投降吗?那么,与Spring相同的问题应该是另一个问题吗?在我看来,这不是Stack Overflow的工作方式,显然有18位支持者找到了他们的问题的答案,标题为“如何在Maven中配置JPA以进行测试”。更重要的是,我回答的第一段与Spring无关,其后是“在Spring中使用JPA时”
Arjan

“那么,与Spring相同的问题会是另一个问题吗?” -是的,还有这样的问题。而且很难找到非弹簧配置问题的答案。“ 18位支持者”-这就是为什么我必须必须支持投票。因为这是一个很好的答案。但是还有另一个问题。
德米特里·凯戈罗多夫

好吧,那么我们(很多)不同意,@ Dmitry。显然,六年前我需要答案“如何配置JPA以在Maven中进行测试”时,并没有发现任何特定于Spring的问题,并在找到解决方案后将其发布。(顺便说一句,即使是以Spring-config开头的部分也不仅与Spring有关;如果您自己遇到此问题,请务必阅读链接在“持久性单元的根”上的说明。)
Arjan

13

似乎多个persistence.xml文件是JPA的一个普遍问题,只能通过类加载技巧来解决。

一个对我有用的解决方法是在一个persistence.xml文件中定义多个持久性单元,然后确保您的部署和测试代码使用不同的绑定(在Spring中,您可以在实体管理器工厂上设置“ persistenceUnitName”属性)。它会使用测试配置污染您的部署文件,但是如果您不介意它可以正常运行。


10

添加用于测试的persistanceance.xml:/src/test/resources/META-INF/persistence.xml 如@Arjan所说,这将更改持久性单元的根,实体类将在目标/测试类中进行扫描。要处理此问题,请将jar-file元素添加到该persistance.xml:

/src/test/resources/META-INF/persistence.xml

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <persistence-unit name="com.some.project">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <jar-file>${project.basedir}/target/classes</jar-file>
        <properties>
            <property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/test_database" />
            <property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver" />
            <property name="javax.persistence.jdbc.user" value="user" />
            <property name="javax.persistence.jdbc.password" value="..." />
        </properties>
    </persistence-unit>
</persistence>

然后,将测试资源过滤添加到pom.xml中:

<project>
    ...
    <build>
        ...
        <testResources>
            <testResource>
                <directory>src/test/resources</directory>
                <filtering>true</filtering>
            </testResource>
        </testResources>
        ...
    </build>
...
</project>

这将起作用,因为jar文件可以定位到目录,而不仅是jar文件。


我在哪里添加?在我的<build>中,只有一个<plugins>元素。是testResources插件的一部分,还是应该放在下面?
休伯特·格热斯科维克

@HubertGrzeskowiak,应将其放在pluginsxml元素下面。这是带有pom.xml示例的页面,其中testResources存在element。
Vlad-HC

6

我尝试了ClassLoaderProxy方法,但是有一个问题,即Hibernate无法将JPA批注的类作为持久类处理。

因此决定尝试不使用persistence.xml进行尝试。优点在于,无需进行任何修改即可直接进行maven构建和Eclipse JUnit测试。

我有一个针对JUnit测试的支持类。

public class PersistenceTestSupport {

    protected EntityManager em;
    protected EntityTransaction et;

    /**
     * Setup the the {@code EntityManager} and {@code EntityTransaction} for
     * local junit testing.
     */
    public void setup() {

        Properties props = new Properties();
        props.put("hibernate.hbm2ddl.auto", "create-drop");
        props.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
        props.put("hibernate.connection.url", "jdbc:mysql://localhost/db_name");
        props.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
        props.put("hibernate.connection.username", "user");
        props.put("hibernate.connection.password", "****");

        Ejb3Configuration cfg = new Ejb3Configuration();
        em = cfg.addProperties(props)
            .addAnnotatedClass(Class1.class)
            .addAnnotatedClass(Class2.class)
            ...
                    .addAnnotatedClass(Classn.class)
            .buildEntityManagerFactory()
            .createEntityManager();

        et = em.getTransaction();
    }
}

我的测试类只是扩展PersistenceTestSupport并在TestCase.setup()中调用setup()。

唯一的缺点是使持久性类保持最新,但是对于JUnit测试,这对我来说是可以接受的。


5

我更喜欢像Rich Seller发布的那样使用不同的persistence.xml进行测试和生产的解决方案(谢谢!)。

但需要更改:

<copy file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml"/>

对于:

<move file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml" overwrite="true"/>

为了不将persistence.xml.proper嵌入到.jar文件中


除了富卖方的答案之外,这个答案对我也很有效。
的Caffé

4

这个答案听起来很愚蠢,但是我正在寻找一种方法,让我可以通过Run As->从eclipse运行这些测试JUnit Test。这是我的方法:

@BeforeClass
public static void setUp() throws IOException {
    Files.copy(new File("target/test-classes/META-INF/persistence.xml"), new File("target/classes/META-INF/persistence.xml"));
    // ...
}

我只是将test / persistence.xml复制到classes / persistence.xml。这可行。


真好 只是后人:在EE6 / CDI / JPA项目(其中在所有不需要弄虚作假)在使用本时,JPA仍倾向于target/test-classes/META-INF/persistence.xml过度target/classes/META-INF/persistence.xml,因此JPA只会扫描类中target/test-classes,而不是在那些target/classes(当这可能是麻烦依靠@Entity注释)。
2014年

3

保留persistence.xml文件的两个副本。一个用于测试,另一个用于正常构建。

默认生命周期将构建persistence.xml复制到src / test / resources / META-INF

创建一个单独的配置文件,该配置文件在运行时会将测试persistence.xml复制到src / test / resources / META-INF


3

除非您明确列出所有类并添加,否则Persistence.xml用作搜索实体类的起点。因此,如果要用另一个文件覆盖此文件,例如从src / test / resources中覆盖,则必须在第二个persistence.xml中指定每个单个实体类,否则将找不到任何实体类。

另一个解决方案是使用maven-resources-plugin(“ copy-resources”目标)覆盖文件。但是随后您必须重写两次,一次进行测试(例如,阶段过程测试类),一次进行实际打包(阶段“ prepare-package”)。


2

这是Rich Seller回答的扩展,它对Hibernate进行了适当的处理,从而在类路径上找到了多个persistence.xml文件并进行了预测试状态恢复。

设定:

创建一个用于部署/打包的持久性文件,以及一个用于测试的持久性文件:

  • src / main / resources / persistence.xml

  • src /测试/ resources / persistence-测试.xml

在您的pom.xml中,将其添加到插件部分:

        <plugin>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.3</version>
            <executions>
                <execution>
                    <id>copy-test-persistence</id>
                    <phase>process-test-resources</phase>
                    <configuration>
                        <tasks>
                            <echo>renaming deployment persistence.xml</echo>
                            <move file="${project.build.outputDirectory}/META-INF/persistence.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml.proper"/>
                            <echo>replacing deployment persistence.xml with test version</echo>
                            <copy file="${project.build.testOutputDirectory}/META-INF/persistence-testing.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml" overwrite="true"/>
                        </tasks>
                    </configuration>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
                <execution>
                    <id>restore-persistence</id>
                    <phase>prepare-package</phase>
                    <configuration>
                        <tasks>
                            <echo>restoring the deployment persistence.xml</echo>
                            <move file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml" overwrite="true"/>
                        </tasks>
                    </configuration>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

与其他解决方案相比的优势

  • 无需额外的Java代码
  • 类路径上只有一个persistence.xml
  • 构建和测试均按预期工作
  • 描述控制台上的输出(回显)
  • 对于打包状态,已100%恢复。没有剩余文件

1

我正在尝试做同样的事情。我有一个适合我的解决方案-您的解决方案可能会有所不同(并且您可能不喜欢该解决方案...有点低级)。

我在网上碰到过一篇文章,他们在其中使用自定义类加载器来做类似的事情,从而激发了灵感。如果有人能看到如何改进,那么欢迎提出建议。为了进行部署,我依赖于EntityManager的容器注入,但是为了进行测试,我使用以下代码自己创建了容器:

final Thread currentThread = Thread.currentThread();
final ClassLoader saveClassLoader = currentThread.getContextClassLoader();
currentThread.setContextClassLoader(new ClassLoaderProxy(saveClassLoader));

EntityManagerFactory emFactory = Persistence.createEntityManagerFactory("test");
em = emFactory.createEntityManager();

然后,ClassLoaderProxy尽可能地少,并且将META-INF / persistence.xml的请求重定向到META-INF / test-persist.xml:

public class ClassLoaderProxy extends ClassLoader {

    public ClassLoaderProxy(final ClassLoader parent) {
        super();
    }

    @Override
    public Enumeration<URL> getResources(final String name) throws IOException {
        if (!"META-INF/persistence.xml".equals(name)) {
            return super.getResources(name);
        } else {
            System.out.println("Redirecting persistence.xml to test-persist.xml");
            return super.getResources("META-INF/test-persist.xml");
        }
    }
}

只是解释一下:

  1. 有两个persistence.xml文件(一个用于外部测试的名为persistence.xml的文件,另一个用于测试的名为test-persist.xml的文件)。
  2. 定制类加载器仅对单元测试有效(对于部署,一切正常)
  3. 定制类加载器将对“ META-INF / persistence.xml”的请求重定向到测试版本(“ META-INF / test-persist.xml”)。

我最初遇到了一些问题,因为Hibernate将(以某种方式)还原到用于加载Hibernate的类加载器(至少我认为这是发生了什么)。我发现将ClassLoader切换代码(第一个块)作为静态块放入您的测试用例中,它将在Hibernate之前被加载,但这取决于您的单元测试结构,您可能还需要将相同的代码放在其他地方(y)


有趣的...它会起作用,但是您会从其他开发人员那里得到一些有趣的外观。另外,您忘记了还原线程的上下文类加载器。
约书亚·戴维斯

很公平。关于“忘了”的评论……这是几年前的事,所以谁知道我是否忘了,但我看不出意图是如何变得更加清晰。添加代码(使用try / finally等等)似乎会分散目标的注意力,但我想每个代码都是针对自己的。
Macbutch 2012年

同意代码清晰。我只是想像有人复制粘贴该代码而遇到麻烦。虽然,如果您想避免麻烦,最好不要复制粘贴随机代码。:)
约书亚·戴维斯

1

另一种方法是使用单独的persistence.xml进行测试(test /../ META-INF / persistence.xml,但按以下方式覆盖扫描程序:-

测试persistence.xml需要包含

<property name="hibernate.ejb.resource_scanner" value = "...TestScanner" />

新类TestScanner的代码如下。

import java.lang.annotation.Annotation;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Set;
import org.hibernate.ejb.packaging.NamedInputStream;
import org.hibernate.ejb.packaging.NativeScanner;


public class TestScanner extends NativeScanner
{

@Override
public Set <Class <?> > 
getClassesInJar (URL jar, Set <Class <? extends Annotation> > annotations)
{  return super.getClassesInJar (getUpdatedURL (jar), annotations); }

@Override
public Set <NamedInputStream> 
getFilesInJar (URL jar, Set <String> patterns)
{  return super.getFilesInJar (getUpdatedURL (jar), patterns); }

@Override
public Set <Package> 
getPackagesInJar (URL jar, Set <Class <? extends Annotation> > annotations)
{  return super.getPackagesInJar (getUpdatedURL (jar), annotations); }

private URL getUpdatedURL (URL url)
{
  String oldURL = url.toExternalForm ();
  String newURL = oldURL.replaceAll ("test-classes", "classes");
  URL result;
  try {
    result = newURL.equals (oldURL) ? url : new URL (newURL);
  } catch (MalformedURLException e)
  {  // Whatever  }
  return result;
}

}

看来这不再适用于Hibernate 5。
Hubert Grzeskowiak


1

此用例的另一种选择是添加多个持久性单元,一个用于说生产,另一个用于测试并相应地注入EntityManagerFactory。

将两个persistence-units都放入实际项目的persistence.xml中,并让您的测试用例注入正确的EntityManager。下面的示例说明了如何使用guice。请注意,为了完整性起见,我保留了一些模拟模仿,相应地标记了特定于模拟的代码,并且注入不是必需的。

public class HibernateTestDatabaseProvider extends AbstractModule {
    private static final ThreadLocal<EntityManager> ENTITYMANAGER_CACHE = new ThreadLocal<>();

    @Override
    public void configure() {
    }

    @Provides
    @Singleton
    public EntityManagerFactory provideEntityManagerFactory() {
        return Persistence.createEntityManagerFactory("my.test.persistence.unit");
    }

    @Provides
    public CriteriaBuilder provideCriteriaBuilder(EntityManagerFactory entityManagerFactory) {
        return entityManagerFactory.getCriteriaBuilder();
    }

    @Provides
    public EntityManager provideEntityManager(EntityManagerFactory entityManagerFactory) {
        EntityManager entityManager = ENTITYMANAGER_CACHE.get();
        if (entityManager == null) {
            // prevent commits on the database, requires mockito. Not relevant for this answer
            entityManager = spy(entityManagerFactory.createEntityManager());


            EntityTransaction et = spy(entityManager.getTransaction());
            when(entityManager.getTransaction()).thenReturn(et);
            doNothing().when(et).commit();

            ENTITYMANAGER_CACHE.set(entityManager);
        }
        return entityManager;
    }
}

0

使用persistence.xml将测试放在自己的Maven项目中


那是一种解决方案,但是如果您的persistence.xml是域模型(JPA)模块的一部分,那么它将不起作用。
约书亚·戴维斯

0

我建议使用不同的Maven配置文件,您可以在其中过滤您的database.proprerties文件,并且每个配置文件具有一个database.properties。

这样,您不必保留.properties以外的任何其他配置文件的副本。

<properties>
    <!-- Used to locate the profile specific configuration file. -->
    <build.profile.id>default</build.profile.id>
    <!-- Only unit tests are run by default. -->
    <skip.integration.tests>true</skip.integration.tests>
    <skip.unit.tests>false</skip.unit.tests>
    <integration.test.files>**/*IT.java</integration.test.files>
</properties>
<profiles>
    <profile>
        <id>default</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <!--
                Specifies the build profile id, which is used to find out the correct properties file.
                This is not actually necessary for this example, but it can be used for other purposes.
            -->
            <build.profile.id>default</build.profile.id>
            <skip.integration.tests>true</skip.integration.tests>
            <skip.unit.tests>false</skip.unit.tests>
        </properties>
        <build>
            <filters>
                <!--
                    Specifies path to the properties file, which contains profile specific
                    configuration. In this case, the configuration file should be the default spring/database.properties file
                -->
                <filter>src/main/resources/META-INF/spring/database.properties</filter>
            </filters>
            <resources>
                <!--
                    Placeholders found from files located in the configured resource directories are replaced
                    with values found from the profile specific configuration files.
                -->
                <resource>
                    <filtering>true</filtering>
                    <directory>src/main/resources</directory>
                    <!--
                        You can also include only specific files found from the configured directory or
                        exclude files. This can be done by uncommenting following sections and adding
                        the configuration under includes and excludes tags.
                    -->
                    <!--
                    <includes>
                        <include></include>
                    </includes>
                    <excludes>
                        <exclude></exclude>
                    </excludes>
                    -->
                </resource>
            </resources>
        </build>
    </profile>
    <profile>
        <id>integration</id>
        <properties>
            <!--
                Specifies the build profile id, which is used to find out the correct properties file.
                This is not actually necessary for this example, but it can be used for other purposes.
            -->
            <build.profile.id>integration</build.profile.id>
            <skip.integration.tests>false</skip.integration.tests>
            <skip.unit.tests>true</skip.unit.tests>
        </properties>
        <build>
            <filters>
                <!--
                    Specifies path to the properties file, which contains profile specific
                    configuration. In this case, the configuration file is searched
                    from spring/profiles/it/ directory.
                -->
                <filter>src/main/resources/META-INF/spring/profiles/${build.profile.id}/database.properties</filter>
            </filters>
            <resources>
                <!--
                    Placeholders found from files located in the configured resource directories are replaced
                    with values found from the profile specific configuration files.
                -->
                <resource>
                    <filtering>true</filtering>
                    <directory>src/main/resources</directory>
                    <!--
                        You can also include only specific files found from the configured directory or
                        exclude files. This can be done by uncommenting following sections and adding
                        the configuration under includes and excludes tags.
                    -->
                    <!--
                    <includes>
                        <include></include>
                    </includes>
                    <excludes>
                        <exclude></exclude>
                    </excludes>
                    -->
                </resource>
            </resources>
        </build>
    </profile>
</profiles>

借助用于单元测试的surefire和用于集成测试的failfe,您已经完成了。

    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.12</version>
    <configuration>
        <junitArtifactName>org.junit:com.springsource.org.junit</junitArtifactName>
        <!--see: https://issuetracker.springsource.com/browse/EBR-220-->
        <printSummary>false</printSummary>
        <redirectTestOutputToFile>true</redirectTestOutputToFile>
        <!-- Skips unit tests if the value of skip.unit.tests property is true -->
        <skipTests>${skip.unit.tests}</skipTests>
        <!-- Excludes integration tests when unit tests are run. -->
        <excludes>
            <exclude>${integration.test.files}</exclude>
        </excludes>
    </configuration>
</plugin>


<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-failsafe-plugin</artifactId>
    <version>2.12</version>
    <configuration>
        <!-- Skips integration tests if the value of skip.integration.tests property is true -->
        <skipTests>${skip.integration.tests}</skipTests>
        <includes>
            <include>${integration.test.files}</include>
        </includes>
        <forkMode>once</forkMode>
        <!--
                            <reuseForks>false</reuseForks>
                            <forkCount>1</forkCount>
        -->
    </configuration>
    <executions>
        <execution>
            <id>integration-test</id>
            <goals>
                <goal>integration-test</goal>
            </goals>
        </execution>
        <execution>
            <id>verify</id>
            <goals>
                <goal>verify</goal>
            </goals>
        </execution>
    </executions>
</plugin>

现在,您只需要mvn test进行单元测试和mvn verify -Pintegration集成测试。显然,您应该在指定的(在配置文件上)路径(或其他位置)中创建database.properties文件,并更改路径

基于参考:http//www.petrikainulainen.net/programming/tips-and-tricks/creating-profile-specific-configuration-files-with-maven/

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.