What does the "default-test" stand for in the maven-surefire plugin

Question

I have defined the following configuration in my pom for surefire with TestNg:

<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.12</version>
            <configuration>
                <skipTests>${skip-all-tests}</skipTests>
            </configuration>
            <executions>
                <execution>
                    <id>unit-tests</id>
                    <phase>test</phase>
                    <goals>
                        <goal>test</goal>
                    </goals>
                    <configuration>
                        <skip>${skip-unit-tests}</skip>
                        <groups>unit</groups>

                        <excludedGroups>integration</excludedGroups>
                    </configuration>
                </execution>
                <execution>
                    <id>integration-tests</id>
                    <phase>integration-test</phase>
                    <goals>
                        <goal>test</goal>
                    </goals>
                    <configuration>
                        <skip>${skip-integration-tests}</skip>
                        <groups>integration</groups>
                        <excludedGroups>unit</excludedGroups>
                    </configuration>
                </execution>
            </executions>
        </plugin>

But it seems the two executions are always preceded by a "default-test" run which seems to run every @test annotated method (at least I think so).

--- maven-surefire-plugin:2.12:test (default-test) @ my-project

For example running "mvn test" on the project, two test executions take place. The "default-test" and the "unit-test".

Could someone explain this a little more to me? Can this be disabled or controlled (configured what is tested and what not)?

Answer 1

People wanted to have a way to override the default built-in executions of plugins within Maven.

Maven 3 (or it may have been introduced as early as 2.1.0 or 2.2.0) solved this by defining a default execution id for each plugin execution added to the effective pom by the packaging's lifecycle.

The name of this implicit id is always default-_____ I cannot recall the exact rule that it is generated for.

You can therefore override the packaging's injected executions by defining a matching execution.

To solve your case I would either change <id>unit-tests</id> to <id>default-test</id> or add

            <execution>
                <id>default-test</id>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </execution>

either will have the same effect, though the <id>unit-tests</id> to <id>default-test</id> solution will be slightly more performant as you only need to invoke two executions of surefire.

The other thing I would point out is you would probably be better off using maven-failsafe-plugin to execute your integration tests as at some point in time you may want to do some stuff pre & post integration testing, and failsafe is designed for that use case (though it should be trivial to switch further down the line)