surefire vs failsafe : proguard issue - integration-testing

Question

I just start working with an existing application where tests are mixed up (unit tests and integration tests) under src/test and i need to sort things out and put right tests at right place.
All are running fine with surefire right now but when trying to move integration test to failsafe, i can't figure out why it is not working.
I am getting this error while performing a select during a bean creation : java.lang.IllegalStateException: Failed to load ApplicationContext
It seems a table is missing in the database.
I can see that whith surefire, there is a step which uses hibernate to clear database and recreate it before running the tests but i can't see it with failsafe.
I don't know where to look up for this step and how to activate it with failsafe.
I am not very familiar with the environment but i know there is :
maven 3.2.5
maven-surefire-plugin 2.19.1
maven-failsafe-plugin 2.19.1
spring framework 4.0.0
Thanks for any suggestion for where to look.
Is there any difference between surefire and failsafe that need to be configured differently from one to another to run the exact same test?
The problem
Trying to create an MCVE, i figured out that the issue is not annotations but proguard-maven-plugin.
The problem can be reproduced with an sql database and a simple maven project with these files :
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>myGroupId</groupId>
<artifactId>myArtifactId</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>MCVE</name>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.1.3.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.1-api</artifactId>
<version>1.0.0.Final</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>3.2.5.RELEASE</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>com.github.wvengen</groupId>
<artifactId>proguard-maven-plugin</artifactId>
<dependencies>
<dependency>
<groupId>net.sf.proguard</groupId>
<artifactId>proguard-base</artifactId>
<version>5.1</version>
<scope>runtime</scope>
</dependency>
</dependencies>
<executions>
<execution>
<phase>package</phase>
<goals><goal>proguard</goal></goals>
</execution>
</executions>
<configuration>
<proguardInclude>${basedir}/obfuscation.config.debug</proguardInclude>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
<configuration>
<skip>true</skip>
</configuration>
<executions>
<execution>
<id>integration-tests</id>
<phase>integration-test</phase>
<goals>
<goal>test</goal>
</goals>
<configuration>
<skip>true</skip>
<includes>
<include>**/*It.java</include>
</includes>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>2.19.1</version>
<executions>
<execution>
<id>integration-test</id>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
<configuration>
<skipTests>false</skipTests>
<includes>
<include>**/*It.java</include>
</includes>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
User.java
package myPackage;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
#Entity
#Table(name = "users")
public class User implements Serializable {
private static final long serialVersionUID = 1L;
#Id
#Column(name = "username", nullable = false)
private String username;
public User() {}
public final String getUsername() {
return username;
}
public final void setUsername(final String pUsername) {
username = pUsername;
}
}
UserIt.java
package myPackage;
import org.junit.Test;
import org.springframework.context.ApplicationContextAware;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
#ContextConfiguration({"classpath:/test.xml"})
public class UserIt extends AbstractJUnit4SpringContextTests implements ApplicationContextAware {
#Test
public void myTest() {
System.out.println("MyTestIsOK");
}
}
obfuscation.config.debug
-dontshrink
-dontoptimize
-dontobfuscate
-dontpreverify
-ignorewarnings
-keep class **
test.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- xmlns:websocket="http://www.springframework.org/schema/websocket" -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:sec="http://www.springframework.org/schema/security"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd"
>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://127.0.0.1:3306/test</value>
</property>
<property name="username">
<value>myUser</value>
</property>
<property name="password">
<value>myPwd</value>
</property>
</bean>
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan">
<list>
<value>myPackage</value>
</list>
</property>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="showSql" value="true" />
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<property name="generateDdl" value="true" />
</bean>
</property>
<property name="jpaProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">create-drop</prop>
</props>
</property>
</bean>
</beans>
Running clean integration-test with surefire will create the user table before running the test but not with failsafe.

Answer 1

It is hard to say something specific without having more information (e.g. relevant parts from pom.xml). Here are some general pointers to give some background though:
Maven build lifecycle
A normal Maven build runs through several phases. The relevant phases (with simplified descriptions) for this discussion are:
…
test: runs unit tests
…
(package: build a jar or war file)
pre-integration-test: prepares the environment for integration tests
integration-test: runs integration tests
post-integration-test: shuts down the integration test environment
verify: checks the result from the integration test
…
So Maven is designed to run integration tests in a special environment. An example would be that a Tomcat is set up and started and the projects war file (that was built in the package phase) is deployed on it in the pre-integration-test phase. Than the integration tests are run in the integration-test phase. In the post-integration-test phase the Tomcat is shut down. The test results are collected in the verify phase.
maven-surefire-plugin vs maven-failsafe-plugin
Both plugins belong to the Maven Surefire project.
The maven-surefire-plugin runs unit tests and binds to the test phase by default.
The maven-failsafe-plugin runs integration tests and binds to the integration-test and verify phases by default.
The reason that there are those two different plugins is, that the maven-failsafe-plugin does not fail the build immediately so the post-integration-test phase will run in any case. Only the verify phase fails the build on test failures.
Your problem
In response to your edits 1-3: Are you sure the integration tests include ContextManagerTest? It sounds like the maven-failsafe-plugin does not know about this test class and thus does not execute its #Before method and thus does not initialize the Spring context and thus does not recreate the database using Hibernate.
Try to create a MCVE by removing all irrelevant classes and configurations, only keeping e.g. one unit test, one integration test, the ContextManagerTest (each of which do something stupid like a System.out.println(…)) and the pom.xml.