Maven is the build tool used to build Airsonic. It is a command-line tool that encapsulates all the parts of the build, from compiling the source code to packaging, and manages our dependencies.
The following page explains how Maven is structured for Airsonic, including many useful commands. Java IDE such as IntelliJ can run a subset of Maven features, though some are only available on the command-line.
The following command can be used to build the Airsonic WAR package (airsonic.war):
$ mvn package
The following command can be used to run a full Airsonic build, including Docker image and integration tests (this is what our CI currently runs):
$ mvn -P integration-test verify
The following command can be used to clean the build outputs:
$ mvn clean
Commands can also be combined, such as:
$ mvn -P integration-test clean verify
Maven’s main configuration is split into multiple pom.xml files, starting
from the one at the root of the repository.
The main Airsonic package is an executable Spring Boot WAR file
(airsonic.war), that can be both run in standalone mode or deployed on a
servlet container (such as Tomcat).
This is provided by spring-boot-maven-plugin in airsonic-main/pom.xml.
The Maven build runs a “style checker”, which checks the Airsonic code for common issues or style inconsistencies.
This is provided by maven-checkstyle-plugin, defined in pom.xml.
The Maven build runs the Dependency Checker plugin, which checks the Airsonic code for security issues (CVE) or common dependency resolution errors (missing packages, unused dependencies).
Disabling the dependency checker:
$ mvn package -Ddependency-check.skip=true
This is provided by dependency-check-maven, defined in pom.xml.
Airsonic unit tests are run using the Maven Surefire plugin.
Running all tests:
$ mvn test
Running a specific test or class of tests:
$ mvn -Dtest='*Service*Test' -DfailIfNoTests=false test
Package while disabling all tests:
$ mvn package -DskipTests
This plugin binds to the test phase of the lifecycle, which you’ll notice is
before the package phase. That means at that point there isn’t even a war/jar
or any such packaging. So your unit tests run directly on the compiled classes
in their loose individual forms (*.class files usually sitting in
target/generated or target/classes and target/test-classes).
Airsonic unit tests are run using the Maven Failsafe plugin in a Docker container.
Running all tests:
$ mvn -Pintegration-test verify
Running a specific test or class of tests:
$ mvn -Dit.test='StreamIT' -DfailIfNoTests=false test
Package while disabling all tests:
$ mvn -Pintegration-test verify -DskipTests
This plugin binds to the integration-test phase of the Maven lifecycle. This
happens after the packaging is done, so now (contrary to Surefire) your tests
actually run against the full packaged version of your code (that is,
airsonic.war) instead of individual class files.
There is a dedicated setup and teardown phase, that are run even if the
integration-test phase fails. The dedicated phases will run regardless and
the build only fails afterwards. This isn’t true, for instance, say the test
phase; if your test phase fails, maven will err out and not even go to the next
(package) phase.
Finally it is important to note that just running the integration-test phase is useless. You need to run verify because running the tests by itself doesn’t do much. You need to verify whether the tests passed or not.
List all dependencies (useful for checking conflicts on upgrades):
$ mvn dependency:tree
Get help on a plugin:
$ mvn help:describe -Dplugin=org.owasp:dependency-check-maven