Continuous Integration: Concepts, Benefits, Workflow, and Test Coverage Practices

Continuous Integration Overview

Continuous Integration (CI) is a standard practice in modern software development that integrates code changes into the main branch frequently, enabling early error detection and preventing large divergences between branches.

Benefits of CI

1) Fast error detection – By integrating each update promptly, errors are identified quickly and are easier to locate.

2) Prevents branch drift – Regular integration avoids the difficulty of merging large, outdated branches later on.

Typical CI Process

The end‑to‑end CI pipeline generally includes the following steps:

Commit – Developers push code to the repository, triggering the pipeline.

First‑round testing – Automated tests (unit, integration, and optionally end‑to‑end) run on each commit.

Build – The code is compiled and packaged, often using Jenkins.

Second‑round testing – Comprehensive automated testing, including unit, integration, and possible end‑to‑end tests.

Deploy – A successful build is archived and deployed to production servers.

Rollback – If a problem occurs, the system reverts to the previous stable build.

Unit & Integration Test Case Submission

Initially, test engineers wrote and ran test cases locally and asked developers to commit them, which became cumbersome as the number of cases grew. To address permission issues, a derived repository was created for testers, but keeping it in sync with the main repository required manual pulls and pushes, leading to version lag.

Current research explores automatic synchronization: whenever the main repository receives a commit, a sync operation updates the derived repository, eliminating manual delays.

CI Tools

Popular open‑source CI platforms include Jenkins, TeamCity, Travis CI, Go CD, Bamboo, GitLab CI, CircleCI, etc.

Qone – JD’s In‑house CI System

Qone, developed by JD’s Quality Management team, integrates project, personnel, and effort management with CI/CD capabilities. It seamlessly connects to existing JD project management and Jenkins for automated unit test execution and coverage reporting.

Integration Test Data Statistics & Code Coverage

Test coverage analysis helps identify untested code, detect dead code, and assess overall code quality. JD uses JaCoCo, an open‑source Java coverage tool, integrated via Maven.

Below is the Maven configuration required to enable JaCoCo reporting:

<plugins>
  ...
  <plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.1</version>
    <executions>
      <execution>
        <id>pre-test</id>
        <goals>
          <goal>prepare-agent</goal>
        </goals>
      </execution>
      <execution>
        <id>post-test</id>
        <phase>test</phase>
        <goals>
          <goal>report</goal>
        </goals>
      </execution>
      <execution>
        <id>post-test-aggregate</id>
        <phase>test</phase>
        <goals>
          <goal>report-aggregate</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
  ...
</plugins>

Test Execution Result Statistics

Each unit‑test run sends an email with results, and weekly summaries are generated to provide stakeholders with an overview of test pass rates and coverage.

Testers can also view detailed results, including coverage metrics, via the internally developed "Linglong" system.

Final Thoughts

While high pass rates and coverage numbers are useful, they should not become the sole goal; understanding why certain code is uncovered or why tests fail after code changes is essential for improving both test quality and overall software reliability. Future work will focus on mutation testing to further enhance test effectiveness.