ShrinkWrap Maven Resolver Use Cases

gistfile1.java

package org.jboss.shrinkwrap.resolver.test;

import java.io.File;

import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.jboss.shrinkwrap.resolver.api.DependencyResolvers;
import org.jboss.shrinkwrap.resolver.api.maven.Maven;
import org.jboss.shrinkwrap.resolver.api.maven.MavenConfigurationTypes;
import org.jboss.shrinkwrap.resolver.api.maven.MavenDependencyResolver;
import org.jboss.shrinkwrap.resolver.api.maven.MavenDependencyShortcut;
import org.jboss.shrinkwrap.resolver.api.maven.MavenImporter;
import org.jboss.shrinkwrap.resolver.api.maven.filter.CombinedFilter;
import org.jboss.shrinkwrap.resolver.api.maven.filter.DependenciesFilter;
import org.jboss.shrinkwrap.resolver.api.maven.filter.ExclusionFilter;
import org.jboss.shrinkwrap.resolver.api.maven.filter.ExclusionsFilter;
import org.jboss.shrinkwrap.resolver.api.maven.filter.ScopeFilter;
import org.jboss.shrinkwrap.resolver.api.maven.filter.StrictFilter;

/**
 * Manifestation of various use cases for ShrinkWrap Maven Resolver
 *
 * @author <a href="mailto:kpiwko@redhat.com">Karel Piwko</a>
 *
 */
public class ShrinkResUsageManifest {

    /**
     * Use case 1:
     *
     * Resolve a single artifact without transitive dependencies as Archive<?>
     */
    public void singleArtifact() {
        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").resolveAs(Archive.class, new StrictFilter())
                .iterator().next();

        // or, if GenericArchive is expected, following shortcut can be used
        DependencyResolvers.use(MavenDependencyShortcut.class).dependency("G:A:V");

        // or even shorter

        Maven.dependency("G:A:V");
    }

    /**
     * Use case 2:
     *
     * Resolve a single artifact without transitive dependencies as File
     */
    public void singleArtifactAsFile() {
        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").resolveAsFiles(new StrictFilter());

        // or

        DependencyResolvers.use(MavenDependencyShortcut.class).resolveAsFile("G:A:V");

        // or

        Maven.resolveAsFile("G:A:V");
    }

    /**
     * Use case 3:
     *
     * Resolve a single artifact without transitive dependencies, using version from a POM file
     */
    public void singleArtifactWithPomFile() {
        // !assignment error!
        File f = DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml").artifact("G:A")
                .resolveAsFiles(new StrictFilter())[0];

        // or

        f = DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml").artifact("G:A").exclusion("*")
                .resolveAsFiles()[0];

        // or

        f = DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml")
                .importAnyDependencies(new DependenciesFilter("G:A")).resolveAsFiles(new StrictFilter())[0];

        // or

        f = DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml")
                .importAnyDependencies(new DependenciesFilter("G:A")).resolveAsFiles(new DependenciesFilter("G:A"))[0];

        // or

        DependencyResolvers.use(MavenDependencyShortcut.class).withPom("pom.xml").resolveAsFile("G:A");

        // or

        Maven.withPom("pom.xml").resolveAsFile("G:A");

        // or using ShrinkWrap Maven plugin and current Maven execution

        f = DependencyResolvers.use(MavenDependencyResolver.class).configureFrom(MavenConfigurationTypes.ENVIRONMENT)
                .artifact("G:A").resolveAsFiles(new StrictFilter())[0];
    }

    /**
     * Use case 4:
     *
     * Resolve two or more artifacts without transitive dependencies
     */
    public void multipleArtifacts() {
        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").artifact("G:B:V")
                .resolveAsFiles(new StrictFilter());

        // or

        DependencyResolvers.use(MavenDependencyResolver.class).artifacts("G:A:V", "G:B:V").resolveAsFiles(new StrictFilter());

        // or

        DependencyResolvers.use(MavenDependencyShortcut.class).resolveAsFiles("G:A:V", "G:B:V");

        // or

        Maven.resolveAsFiles("G:A:V", "G:B:V");
    }

    /**
     * Use case 5:
     *
     * Resolve an artifact with transitive dependencies
     */
    public void transitiveArtifact() {
        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").resolveAsFiles();
    }

    /**
     * Use case 6:
     *
     * Resolve an artifact with transitive dependencies using extra exclusion
     */
    public void transitiveArtifactExtraExclusion() {
        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").exclusion("G:B").resolveAsFiles();

        // or

        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").resolveAsFiles(new ExclusionFilter("G:B"));
    }

    /**
     * Use case 7:
     *
     * Resolve artifacts with transitive dependencies using extra exclusions
     */
    public void transitiveArtifactsExtraExclusions() {
        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").exclusion("G:B").artifact("G:B:V")
                .exclusion("G:C").resolveAsFiles();

        // or

        DependencyResolvers.use(MavenDependencyResolver.class).artifact("G:A:V").artifact("G:B:V")
                .resolveAsFiles(new ExclusionsFilter("G:B", "G:C"));

        // or
        // note, this does exclusion of both exclusions for both artifacts which is not same!

        DependencyResolvers.use(MavenDependencyResolver.class).artifacts("G:A:V", "G:B:V").exclusions("G:B", "G:C")
                .resolveAsFiles();
    }

    /**
     * Use case 8:
     *
     * Resolve an artifact with transitive dependencies, using pom for version
     */
    public void transitiveArtifactWithPom() {
        DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml").artifact("G:A").resolveAsFiles();

        // or using ShrinkWrap Maven plugin and current Maven execution

        DependencyResolvers.use(MavenDependencyResolver.class).configureFrom(MavenConfigurationTypes.ENVIRONMENT)
                .artifact("G:A").resolveAsFiles();
    }

    /**
     * Use case 9:
     *
     * Import the same dependencies as Maven would do.
     */
    public void mimickMavenDependencies() {
        DependencyResolvers.use(MavenDependencyResolver.class).loadSettings("settings.xml").loadEffectivePom("pom.xml")
                .importAnyDependencies(new ScopeFilter("compile", "runtime", "")).resolveAsFiles();

        // or using ShrinkWrap Maven plugin and current Maven execution

        DependencyResolvers.use(MavenDependencyResolver.class).configureFrom(MavenConfigurationTypes.ENVIRONMENT)
                .importAnyDependencies(new ScopeFilter("compile", "runtime", "")).resolveAsFiles();

        // or using MavenImporter, which does a bit different thing

        ShrinkWrap.create(MavenImporter.class).loadSettings("settings.xml").loadEffectivePom("pom.xml")
                .importAnyDependencies(new ScopeFilter("compile", "runtime", ""));
    }

    /**
     * Use case 10:
     *
     * Import test dependencies and exclude G:A:V
     */
    public void importTestDependenciesWithExtraExclusion() {
        DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml")
                .importTestDependencies(new ExclusionFilter("G:A")).resolveAsFiles();

        // or

        DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml").importTestDependencies()
                .resolveAsFiles(new ExclusionFilter("G:A:V"));

        // or
        // note this would not work if G:A:V is a transitive dependency!

        DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml")
                .importAnyDependencies(new CombinedFilter(new ScopeFilter("test"), new ExclusionFilter("G:A:V")))
                .resolveAsFiles();
    }

    /**
     * Use case 11:
     *
     * Import test dependencies and exclude arquillian/shrinkwrap/container (SHRINKRES-30)
     */
    public void importTestDependenciesWithArquillianExclusions() {
        // solution 1 = enumerate within previous use case
        // solution 2 = write a GroupExclusionFilter, note that MavenDependency has no getter for groupId!
        // solution 3 = move shrinkwrap/arquillian/container to a distinct profile, then exclude it
    }

    /**
     * Use case 12:
     *
     * Import a dependency using different classloader (SHRINKRES-26)
     */
    public void bootstrapShrinResWithDifferentClassloader() {

        // not possible
    }

    /**
     * Use case 13:
     *
     * Do the same as Maven would do
     */
    public void mimickMaven() {
        ShrinkWrap
                .create(WebArchive.class)
                .addClasses(Class.class)
                .addAsResource("resources")
                .addAsLibraries(
                        DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml")
                                .importAnyDependencies(new ScopeFilter("compile", "", "runtime")).resolveAsFiles());

        // or
        // note current implementation is expecting mvn package to be run first (SHRINKRES-18)

        ShrinkWrap.create(MavenImporter.class).loadEffectivePom("pom.xml").importBuildOutput();

        // note usage of ENVIRONMENT configuration is not possible
    }
}

Rather than the term "Shortcut", I recommend the term "Shorthand". Shorthand means "abbreviated writing to increase speed or brevity", so it fits rather perfectly.

Karel: => Makes sense. Note that this class should be hidden from user perspective or removed completely.

Why is use case #3 returning an array of results instead of an iterator. I don't really have a preference as to which return type is best, but what is important is that it's consistent.

Karel: => We are returning an Array for all cases, so we are consistent. reason given by what Archive.addAsLibrary(...) supports. No support for Iterator in ShrinkWrap. Yes, Arrays have disadvantages, but so has collections.

In use case #13, my instinct is to rename importAnyDependencies to importAllDependencies. I would then read the statement as "import all dependencies that are of scope runtime or compile". At the moment, I can't recall why "any" is not appropriate here, but my gut tells me it's not.

Karel: If importAllDependencies will add runtime and compile, how would user add "test" and "provided" ones? What about subsets?

Dan: I was reading the example as it is coded. Of course, if you added different scopes, then the sentence would be different. I'm basically just saying that the word "Any" should be "All", grammatically speaking.

When you are doing a single exclusion, I think that "exclude()" reads better than "exclusion()". Case in point:

DependencyResolvers.use(MavenDependencyResolver.class).loadEffectivePom("pom.xml").artifact("G:A").exclude("*")

In fact, this is consistent with the naming that Ivy uses.

Although perhaps we can even be more explicit (at the cost of a few more characters):

artifact("G:A").excludeDependents("*")

...or something to that effect, to call out what you are excluding.

Karel: exclusion is consistent with ...... from Maven. However, we can have a better naming if it makes more sense in Java API.

There may be a better name for the StrictFilter, to make it more clear what it is being strict about. How about ExclusiveFilter, where exclusive means "select the artifact exclusively" (ignoring its friends). Another alternative is ExactFilter or even SingularFilter.

Karel: Any more clear naming is welcomed. Note this we've discussed a proposal of resolution strategies, which might render StrictFilter obsolete.

Dan,

I've update your comments with my responses. I'm not sure if that will trigger notification, so I'm writing an extra comment just in case.

Cool!

Yep, you have to add a comment for the notification to kick in.

Linking this back to the forum Thread from which this discussion is based: https://community.jboss.org/message/732721

I can't use DependencyResolvers, Do I need any additional thing in my POM file?

This is my POM file:

4.0.0

<groupId>ch.swissbytes.mitsuba.giftcard</groupId>
<artifactId>mitsuba-giftcard-web</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>mitsuba-giftcard-web</name>
<description>A starter Java EE 6 webapp project for use on JBoss AS 7 / EAP 6, generated from the jboss-javaee6-webapp archetype</description>

<url>http://jboss.org/jbossas</url>
<licenses>
    <license>
        <name>Apache License, Version 2.0</name>
        <distribution>repo</distribution>
        <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
    </license>
</licenses>

<properties>
    <!-- Explicitly declaring the source encoding eliminates the following 
        message: -->
    <!-- [WARNING] Using platform encoding (UTF-8 actually) to copy filtered 
        resources, i.e. build is platform dependent! -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- JBoss dependency versions -->
    <version.jboss.maven.plugin>7.4.Final</version.jboss.maven.plugin>

    <!-- Define the version of the JBoss BOMs we want to import to specify 
        tested stacks. -->
    <version.jboss.bom>1.0.7.Final</version.jboss.bom>
    <!-- Alternatively, comment out the above line, and un-comment the line 
        below to use version 1.0.4.Final-redhat-4 which is a release certified to 
        work with JBoss EAP 6. It requires you have access to the JBoss EAP 6 maven 
        repository. -->
    <!-- <version.jboss.bom>1.0.4.Final-redhat-4</version.jboss.bom>> -->

    <!-- other plugin versions -->
    <version.surefire.plugin>2.10</version.surefire.plugin>
    <version.war.plugin>2.1.1</version.war.plugin>

    <!-- maven-compiler-plugin -->
    <maven.compiler.target>1.6</maven.compiler.target>
    <maven.compiler.source>1.6</maven.compiler.source>

    <version.arquillian_core>1.0.3.Final</version.arquillian_core>
</properties>

<repositories>
    <repository>
        <id>prime-repo</id>
        <name>Prime Repo</name>
        <url>http://repository.primefaces.org</url>
    </repository>
</repositories>


<dependencyManagement>
    <dependencies>
        <!-- JBoss distributes a complete set of Java EE 6 APIs including a Bill 
            of Materials (BOM). A BOM specifies the versions of a "stack" (or a collection) 
            of artifacts. We use this here so that we always get the correct versions 
            of artifacts. Here we use the jboss-javaee-6.0-with-tools stack (you can 
            read this as the JBoss stack of the Java EE 6 APIs, with some extras tools 
            for your project, such as Arquillian for testing) and the jboss-javaee-6.0-with-hibernate 
            stack you can read this as the JBoss stack of the Java EE 6 APIs, with extras 
            from the Hibernate family of projects) -->
        <dependency>
            <groupId>org.jboss.bom</groupId>
            <artifactId>jboss-javaee-6.0-with-tools</artifactId>
            <version>${version.jboss.bom}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.jboss.bom</groupId>
            <artifactId>jboss-javaee-6.0-with-hibernate</artifactId>
            <version>${version.jboss.bom}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    <dependency>
        <groupId>org.jboss.shrinkwrap.resolver</groupId>
        <artifactId>shrinkwrap-resolver-bom</artifactId>
        <version>2.0.0-beta-2</version>
        <type>pom</type>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.jboss.arquillian</groupId>
        <artifactId>arquillian-bom</artifactId>
        <version>${arquillian.version}</version>
        <type>pom</type>
        <scope>test</scope>
    </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- querydsl -->

    <dependency>
        <groupId>com.mysema.querydsl</groupId>
        <artifactId>querydsl-apt</artifactId>
        <version>3.2.4</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>com.mysema.querydsl</groupId>
        <artifactId>querydsl-jpa</artifactId>
        <version>3.2.4</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.6.1</version>
    </dependency>

    <!-- primefaces -->
    <dependency>
        <groupId>org.primefaces</groupId>
        <artifactId>primefaces</artifactId>
        <version>4.0</version>
    </dependency>
    <!-- Paginator -->
    <dependency>
        <groupId>com.github.timoteoponce</groupId>
        <artifactId>paginator</artifactId>
        <version>0.0.5</version>
    </dependency>
    <!-- First declare the APIs we depend on and need for compilation. All 
        of them are provided by JBoss AS 7 -->

    <!-- Import the CDI API, we use provided scope as the API is included in 
        JBoss AS 7 -->
    <dependency>
        <groupId>javax.enterprise</groupId>
        <artifactId>cdi-api</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- Import the Common Annotations API (JSR-250), we use provided scope 
        as the API is included in JBoss AS 7 -->
    <dependency>
        <groupId>org.jboss.spec.javax.annotation</groupId>
        <artifactId>jboss-annotations-api_1.1_spec</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- Import the JAX-RS API, we use provided scope as the API is included 
        in JBoss AS 7 -->
    <dependency>
        <groupId>org.jboss.spec.javax.ws.rs</groupId>
        <artifactId>jboss-jaxrs-api_1.1_spec</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- Import the JPA API, we use provided scope as the API is included in 
        JBoss AS 7 -->
    <dependency>
        <groupId>org.hibernate.javax.persistence</groupId>
        <artifactId>hibernate-jpa-2.0-api</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- Import the EJB API, we use provided scope as the API is included in 
        JBoss AS 7 -->
    <dependency>
        <groupId>org.jboss.spec.javax.ejb</groupId>
        <artifactId>jboss-ejb-api_3.1_spec</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- JSR-303 (Bean Validation) Implementation -->
    <!-- Provides portable constraints such as @Email -->
    <!-- Hibernate Validator is shipped in JBoss AS 7 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <scope>provided</scope>
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!-- Import the JSF API, we use provided scope as the API is included in 
        JBoss AS 7 -->
    <dependency>
        <groupId>org.jboss.spec.javax.faces</groupId>
        <artifactId>jboss-jsf-api_2.1_spec</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- Now we declare any tools needed -->

    <!-- Annotation processor that raising compilation errors whenever constraint 
        annotations are incorrectly used. -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator-annotation-processor</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- Needed for running tests (you may also use TestNG) -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <!-- <version>4.11</version> -->
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.jboss.shrinkwrap.resolver</groupId>
        <artifactId>shrinkwrap-resolver-impl-maven</artifactId>
        <!-- version>2.0.0</version -->
        <!-- scope>test</scope -->
    </dependency>

    <!-- Optional, but highly recommended -->
    <!-- Arquillian allows you to test enterprise code such as EJBs and Transactional(JTA) 
        JPA from JUnit/TestNG -->
    <dependency>
        <groupId>org.jboss.arquillian.junit</groupId>
        <artifactId>arquillian-junit-container</artifactId>
        <!-- <version>${arquillian.version}</version>  -->
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.jboss.arquillian.protocol</groupId>
        <artifactId>arquillian-protocol-servlet</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- For serializing entities with bidirection navigation -->
    <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-core-asl</artifactId>
        <version>1.9.13</version>
        <scope>provided</scope>
    </dependency>


</dependencies>

<build>
    <!-- Maven will append the version to the finalName (which is the name 
        given to the generated war, and hence the context root) -->
    <finalName>${project.artifactId}</finalName>
    <plugins>
        <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <version>${version.war.plugin}</version>
            <configuration>
                <!-- Java EE 6 doesn't require web.xml, Maven needs to catch up! -->
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
        </plugin>
        <!-- The JBoss AS plugin deploys your war to a local JBoss AS container -->
        <!-- To use, run: mvn package jboss-as:deploy -->
        <plugin>
            <groupId>org.jboss.as.plugins</groupId>
            <artifactId>jboss-as-maven-plugin</artifactId>
            <version>${version.jboss.maven.plugin}</version>
        </plugin>

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <version>1.8</version>
            <executions>
                <execution>
                    <id>add-source</id>
                    <phase>generate-sources</phase>
                    <goals>
                        <goal>add-source</goal>
                    </goals>

                    <configuration>
                        <sources>
                            <source>src/generated/java</source>
                        </sources>
                    </configuration>
                </execution>
            </executions>
        </plugin>

        <!-- query dsl -->

        <plugin>
            <groupId>com.mysema.maven</groupId>
            <artifactId>apt-maven-plugin</artifactId>
            <version>1.1.1</version>
            <executions>
                <execution>
                    <phase>prepare-sources</phase>
                    <goals>
                        <goal>process</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>src/generated/java</outputDirectory>
                        <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor>
                    </configuration>
                </execution>
            </executions>
            <dependencies>
                <dependency>
                    <groupId>com.mysema.querydsl</groupId>
                    <artifactId>querydsl-apt</artifactId>
                    <version>3.2.4</version>
                </dependency>
                <dependency>
                    <groupId>com.mysema.querydsl</groupId>
                    <artifactId>querydsl-jpa</artifactId>
                    <classifier>apt</classifier>
                    <version>3.2.4</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile>
        <!-- The default profile skips all tests, though you can tune it to run 
            just unit tests based on a custom pattern -->
        <!-- Seperate profiles are provided for running all tests, including Arquillian 
            tests that execute in the specified container -->
        <id>default</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <build>
            <plugins>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>${version.surefire.plugin}</version>
                    <configuration>
                        <skip>true</skip>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>

    <profile>
        <!-- An optional Arquillian testing profile that executes tests in your 
            JBoss AS instance -->
        <!-- This profile will start a new JBoss AS instance, and execute the 
            test, shutting it down when done -->
        <!-- Run with: mvn clean test -Parq-jbossas-managed -->
        <id>arq-jbossas-managed</id>
        <dependencies>
            <dependency>
                <groupId>org.jboss.as</groupId>
                <artifactId>jboss-as-arquillian-container-managed</artifactId>
                <version>7.1.1.Final</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </profile>

    <profile>
        <!-- An optional Arquillian testing profile that executes tests in a remote 
            JBoss AS instance -->
        <!-- Run with: mvn clean test -Parq-jbossas-remote -->
        <id>arq-jbossas-remote</id>
        <dependencies>
            <dependency>
                <groupId>org.jboss.as</groupId>
                <artifactId>jboss-as-arquillian-container-remote</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </profile>

    <profile>
        <!-- When built in OpenShift the 'openshift' profile will be used when 
            invoking mvn. -->
        <!-- Use this profile for any OpenShift specific customization your app 
            will need. -->
        <!-- By default that is to put the resulting archive into the 'deployments' 
            folder. -->
        <!-- http://maven.apache.org/guides/mini/guide-building-for-different-environments.html -->
        <id>openshift</id>
        <build>
            <plugins>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>${version.war.plugin}</version>
                    <configuration>
                        <outputDirectory>deployments</outputDirectory>
                        <warName>ROOT</warName>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>

</profiles>