Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

...

  • Java

    For java there are different plugins/properties that must be included in the pom.xml to execute the tests and record the coverage during the execution

    Maven Properties

    Code Block
    languagexml
    <properties>
    ...
                    <sonar.java.coveragePlugin>jacoco</sonar.java.coveragePlugin>
                    <sonar.surefire.reportsPath>${project.build.directory}/surefire-reports</sonar.surefire.reportsPath>
                    <sonar.jacoco.reportPath>${project.build.directory}/coverage-reports/jacoco.exec</sonar.jacoco.reportPath>
                    <sonar.jacoco.itReportPath>${project.build.directory}/coverage-reports/jacoco-it.exec</sonar.jacoco.itReportPath>
                    <sonar.jacoco.reportMissing.force.zero>true</sonar.jacoco.reportMissing.force.zero>
                    <sonar.projectVersion>${project.version}</sonar.projectVersion>
                    <!-- Enable language to disable other language analysis -->
                    <sonar.language>java</sonar.language>
                    <sonar.exclusions>src/main/resources/**</sonar.exclusions>
    ...
    </properties>

    Surefire (Unit tests)

    This one is used to execute the unit tests, various config are available depending of the project need (https://maven.apache.org/surefire/maven-surefire-plugin/index.html)

    Code Block
    languagexml
    <plugin>
    	<groupId>org.apache.maven.plugins</groupId>
    	<artifactId>maven-surefire-plugin</artifactId>
    	<version>X.XX.X</version>
    	<configuration>
    		<forkCount>1</forkCount>
    		<reuseForks>true</reuseForks>
    		<useSystemClassLoader>false</useSystemClassLoader>
    	</configuration>
    </plugin>

    Failsafe (Integration tests)

    This one is used to execute the integration tests, various config are available depending of the project need (https://maven.apache.org/surefire/maven-failsafe-plugin/index.html)

    Code Block
    languagexml
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <version>X.XX.X</version>
        <executions>
          <execution>
             <id>integration-tests</id>
             <goals>
               <goal>integration-test</goal>
               <goal>verify</goal>
             </goals>
             <configuration>
               <additionalClasspathElements>
                  <additionalClasspathElement>${project.build.directory}/classes</additionalClasspathElement>
               </additionalClasspathElements>
               <includes>
                 <include>**/*ItCase.java</include>
               </includes>
               <forkCount>1</forkCount>
               <reuseForks>false</reuseForks>
               <useSystemClassLoader>false</useSystemClassLoader>
             </configuration>
          </execution>
        </executions>
    </plugin>

    Jacoco

    This one is used to record the coverage of the unit tests and integration tests, also a result merge for the developer IDE (https://www.eclemma.org/jacoco/trunk/doc/maven.html)

    Code Block
    languagexml
    <plugin>
                                    <groupId>org.jacoco</groupId>
                                    <artifactId>jacoco-maven-plugin</artifactId>
                                    <version>0.8.2</version>
                                    <configuration>
                                            <dumpOnExit>true</dumpOnExit>
                                            <includes>
                                                    <include>org.onap.*</include>
                                            </includes>
                                            <propertyName>surefireArgLine</propertyName>
                                    </configuration>
                                    <executions>
                                            <execution>
                                                    <id>pre-unit-test</id>
                                                    <goals>
                                                            <goal>prepare-agent</goal>
                                                    </goals>
                                                    <configuration>
                                                            <destFile>${project.build.directory}/coverage-reports/jacoco.exec</destFile>
                                                            <!-- <append>true</append> -->
                                                    </configuration>
                                            </execution>
                                            <execution>
                                                    <id>pre-integration-test</id>
                                                    <phase>pre-integration-test</phase>
                                                    <goals>
                                                            <goal>prepare-agent</goal>
                                                    </goals>
                                                    <configuration>
                                                            <destFile>${project.build.directory}/coverage-reports/jacoco-it.exec</destFile>
                                                            <!-- <append>true</append> -->
                                                    </configuration>
                                            </execution>
                                            <execution>
                                                    <goals>
                                                            <goal>merge</goal>
                                                    </goals>
                                                    <phase>post-integration-test</phase>
                                                    <configuration>
                                                            <fileSets>
                                                                    <fileSet implementation="org.apache.maven.shared.model.fileset.FileSet">
                                                                            <directory>${project.build.directory}/coverage-reports</directory>
                                                                            <includes>
                                                                                    <include>*.exec</include>
                                                                            </includes>
                                                                    </fileSet>
                                                            </fileSets>
                                                            <destFile>${project.build.directory}/jacoco-dev.exec</destFile>
                                                    </configuration>
                                            </execution>
                                    </executions>
    </plugin>

    Note that for the integration tests, it could more complex than the following Jacoco plugin usage.

    If it's a remote server or anything else the jacoco agent must be provided to the running JVM to do the coverage recording (https://www.eclemma.org/jacoco/trunk/doc/agent.html), then brought back to build folder.

    Docker Plugin (Integration tests)

    This plugin can be used to start containers before doing the integration tests. The following example starts Mariadb and Python before the integration tests phase.

    Code Block
    languagexml
    <plugin>
                                    <groupId>io.fabric8</groupId>
                                    <artifactId>docker-maven-plugin</artifactId>
                                    <version>0.26.0</version>
                                    <configuration>
                                            <verbose>true</verbose>
                                            <apiVersion>1.23</apiVersion>
                                            <images>
                                                    <image>
                                                            <name>library/mariadb:10.1.11</name>
                                                            <alias>mariadb</alias>
                                                            <run>
                                                                    <env>
                                                                            <MYSQL_ROOT_PASSWORD>secret</MYSQL_ROOT_PASSWORD>
                                                                    </env>
                                                                    <hostname>mariadb</hostname>
                                                                    <volumes>
                                                                            <bind>
                                                                                    <volume>${project.basedir}/extra/sql/:/docker-entrypoint-initdb.d</volume>
                                                                                    <volume>${project.basedir}/extra/docker/mariadb/conf1:/etc/mysql/conf.d</volume>
                                                                            </bind>
                                                                    </volumes>
                                                                    <wait>
                                                                            <log>socket: '/var/run/mysqld/mysqld.sock'  port: 3306  mariadb.org binary distribution</log>
                                                                            <time>600000</time>
                                                                    </wait>
                                                                    <ports>
                                                                            <port>${docker.mariadb.port.host}:3306</port>
                                                                    </ports>
                                                            </run>
                                                    </image>
                                                    <image>
                                                            <name>library/python:2-slim</name>
                                                            <alias>python</alias>
                                                            <run>
                                                                    <hostname>python</hostname>
                                                                    <volumes>
                                                                            <bind>
                                                                                    <volume>${project.basedir}/src/test/resources/http-cache/:/usr/src/http-cache-app</volume>
                                                                                    <volume>${project.basedir}/src/test/resources/http-cache/example/:/usr/src/http-cache-app/data-cache</volume>
                                                                            </bind>
                                                                    </volumes>
                                                                    <wait>
                                                                            <tcp>
                                                                                    <ports>
                                                                                            <port>8080</port>
                                                                                    </ports>
                                                                                    <mode>direct</mode>
                                                                            </tcp>
                                                                            <time>120000</time>
                                                                    </wait>
                                                                    <ports>
                                                                            <port>${docker.http-cache.port.host}:8080</port>
                                                                    </ports>
                                                                    <workingDir>/usr/src/http-cache-app</workingDir>
                                                                    <cmd>
                                                                            <shell>./start_http_cache.sh ${python.http.proxy.param} --python_proxyaddress=localhost:${docker.http-cache.port.host}</shell>
                                                                    </cmd>
                                                            </run>
                                                   </image>                                      
                                    </configuration>
                                    <executions>
                                            <execution>
                                                    <id>docker-start-for-it</id>
                                                    <phase>pre-integration-test</phase>
                                                    <goals>
                                                            <goal>start</goal>
                                                    </goals>
                                            </execution>
                                            <execution>
                                                    <id>docker-stop-for-it</id>
                                                    <phase>post-integration-test</phase>
                                                    <goals>
                                                            <goal>stop</goal>
                                                    </goals>
                                            </execution>
                                    </executions>
    </plugin>
  • Javascript

    Maven properties

    For the javascript testing, the goal is to use JEST framework to execute the unit testing and record the coverage (Mocking is also possible with JEST)

    The setup is based on NPM, so it uses a maven plugin that handles that (similar idea to docker-maven-plugin)

    Beforehand the Javascript code must be copied to the target folder, plus the package.json file that will be used by NPM

    Code Block
    languagexml
                    <testResources>
                            <!-- Copy the NPM package.json for UI javascript testing framework -->
                            <testResource>
                                    <directory>src/test/javascript</directory>
                                    <includes>
                                            <include>**/**.json</include>
                                    </includes>
                                    <filtering>true</filtering>
                                    <targetPath>${project.build.directory}/my-ui</targetPath>
                            </testResource>
                            <testResource>
                                    <directory>src/main/resources/META-INF/resources/designer</directory>
                                    <filtering>false</filtering>
                                    <targetPath>${project.build.directory}/my-ui/designer</targetPath>
                            </testResource>
                    </testResources>


    Maven properties

    Code Block
    languagexml
                    <sonar.javascript.lcov.reportPaths>${project.build.directory}/my-ui/coverage/lcov.info</sonar.javascript.lcov.reportPaths>
                    <sonar.projectVersion>${project.version}</sonar.projectVersion>
                    <sonar.sources>src/main,${project.build.directory}/my-ui/designer</sonar.sources>
                    <sonar.exclusions>src/main/resources/**,**/my-ui/designer/lib/*</sonar.exclusions>
    
    
    


    frontend-maven-plugin

  • This one is used to setup the required libraries and environment to execute the test under JEST framework ((https://github.com/eirslett/frontend-maven-plugin)

    Code Block
    languagexml
            <plugin>
                            <groupId>com.github.eirslett</groupId>
                            <artifactId>frontend-maven-plugin</artifactId>
                            <version>1.6</version>
                            <configuration>
                                <installDirectory>${project.build.directory}/my-ui</installDirectory>
                                <workingDirectory>${project.build.directory}/my-ui</workingDirectory>
                                <skip>${maven.test.skip}</skip>
                            </configuration>
    
                            <executions>
                                <execution>
                                    <id>install_node_and_npm</id>
                                    <goals>
                                        <goal>install-node-and-npm</goal>
                                    </goals>
                                    <phase>test</phase>
                                    <configuration>
                                        <nodeVersion>v8.11.1</nodeVersion>
                                        <npmVersion>5.6.0</npmVersion>
                                    </configuration>
                                </execution>
                                <execution>
                                    <id>npm_install</id>
                                    <goals>
                                        <goal>npm</goal>
                                    </goals>
                                    <phase>test</phase>
                                    <configuration>
                                        <arguments>install</arguments>
                                    </configuration>
                                </execution>
                                <execution>
                                    <id>npm_test</id>
                                    <goals>
                                        <goal>npm</goal>
                                    </goals>
                                    <phase>test</phase>
                                    <configuration>
                                        <arguments>run-script test:coverage</arguments>
                                    </configuration>
                                </execution>
    
                            </executions>
        </plugin>

    Package.json

    This file must be stored in your project and will be used by the Npm maven plugin to setup the javascript environment.

    Here is an example to setup an angular environment, others libraries can be setup depending of the need

    Code Block
    languagexml
    {
        "scripts": {
            "test": "jest",
            "test:watch": "jest --watch",
            "test:coverage": "jest --coverage"
        },
        "jest": {
            "verbose": true,
            "coverageDirectory": "${project.build.directory}/my-ui/coverage",
            "collectCoverageFrom": [
                "**/designer/**/*.{js,jsx}",
                "!**/designer/lib/**"
            ],
            "rootDir": "${project.build.directory}/my-ui",
            "roots": [
                "${project.basedir}/src/test/javascript/",
                "<rootDir>/designer/"
            ],
            "moduleDirectories": [
                "${project.build.directory}/my-ui/node/node_modules",
                "${project.build.directory}/my-ui/node_modules",
                "<rootDir>/designer"
            ],
            "coverageReporters": [
                "lcov"
            ]
        },
        "devDependencies": {
            "angular": "1.3.2",
            "angular-resource": "1.3.2",
            "angular-cookies": "1.3.2",
            "angular-route": "1.3.2",
            "angular-mocks": "1.3.2",
            "angular-animate": "1.3.2",
            "angular-sanitize": "1.3.2",
            "angular-touch": "1.3.2",
            "angular-dialog-service": "5.3.0",
    
    Code Block
    languagexml
            "angular-loading-bar": "0.9.0",
           <sonar.javascript.lcov.reportPaths>${project.build.directory}/clamp-ui/coverage/lcov.info</sonar.javascript.lcov.reportPaths> "jquery": "3.3.1",
            "popper.js": "1.14.4",
             <sonar.projectVersion>${project.version}</sonar.projectVersion>"bootstrap": "4.1.1",
            "angular-ui-bootstrap": "2.5.6",
            <sonar.sources>src/main,${project.build.directory}/clamp-ui/designer</sonar.sources>"jest": "^23.6.0",
            "jest-cli": "^21.2.1"
           <sonar.exclusions>src/main/resources/**,**/clamp-ui/designer/lib/*</sonar.exclusions>}
    }
    
    
    
  • Python

    Section TBD