Improving Test Efficiency and Continuous Integration with the Beetle Platform: An Interface Testing Case Study

In today’s internet era, speed determines market competitiveness, making high‑pace, high‑pressure development the norm; QA teams must adapt to rapid iteration while ensuring product quality.

We follow a process that guarantees quality at every stage, thereby improving overall project efficiency.

Using the Beetle platform as an example, deployment and release processes have become much faster, but each business line still uses its own interface‑testing solution, preventing unified automation, continuous integration, and holistic test monitoring.

Embracing Change and Compatibility

Instead of imposing rigid standards that quickly become outdated, we store each party’s characteristics as configurations, categorize interface tests by type with unique execution methods, and ensure a closed‑loop execution that does not depend on other stages.

We then introduce the Case Management Platform.

1. Naming Rule Configuration

Based on the characteristics of each integrated business, we configure:

Engine name – matches the Git or SVN project name.

Configuration name – distinguishes different naming conventions within the same project.

Engine type – currently only testNG is supported.

Package, class, and method naming rules – used to generate a visual node tree.

Storage method and address – supports SVN or Git.

Config path – currently supports scfconfig; other paths will be added.

Listener – custom listener support; can be empty.

2. Node Tree

The node tree visualizes test methods according to the naming rules, showing only methods annotated with @Test (for testNG).

For example, a transaction test project’s node tree has three levels: package, class, and method, supporting select‑all, single‑select, multi‑select, and inverse‑select operations.

3. Test Suite

The test suite is the core of testNG execution; each test run follows the suite configuration.

Users can create suites, name them, choose suite types, and select nodes (single, multiple, or all). The association between the tested service and the test project is fully user‑defined, and the service IP can be configured before each execution.

4. Execution

Execution starts from the suite list, where the service IP can be manually changed before each run.

The end‑to‑end process includes pulling the test project, deploying it, compiling, modifying configuration files, running testNG tests, collecting logs, generating reports, and cleaning up; the report is displayed in the task management module.

Reports are generated using reportNG.

Although this solves the lack of unified management, it does not yet improve testing efficiency because the execution location merely changes.

Therefore, we integrate the case management platform with Beetle to take a major step toward continuous integration.

Integration Steps with Beetle

Beetle adds CI configuration for case suites, allowing definition of required test suites.

Each branch deployment triggers automatic execution of the configured suite’s test cases.

After execution, Beetle displays a report link that redirects to the detailed report page.

Since the case platform already provides core functionalities, only a simple interface is needed for Beetle, enabling triggers from either side.

After configuring a suite on the platform, each branch deployment automatically runs the suite’s test cases and generates a report (initially recommended for a few smoke‑test cases), providing real‑time insight into regression testing status.

This opens the door to continuous integration and creates favorable conditions for future automation.

The initial content of the case management platform is now introduced; future updates will include case file management, link testing execution, service response monitoring, and other monitoring features.

Finally, remember that the platform is only a tool; it ensures smooth workflow and makes CI possible, but test quality and correctness still depend on the users.

Improve cases to make them robust and repeatable; focus on the essence of testing.