Boosting JS SDK Testing Efficiency with a Unified Platform and AI‑Generated Test Code

Background

JavaScript SDKs serve as cross‑platform modules, and their quality directly impacts the reliability and user experience of higher‑level applications. Testing the SDK involves “secondary development” by calling its APIs to simulate real usage, covering functional correctness, performance, stability, and compatibility across many scenarios, which presents challenges such as complex test cases, numerous interfaces, and heavy code‑writing effort.

Overall Architecture

To address these challenges, a JS SDK testing platform was built with layered design and automation integration, aiming to improve test efficiency across the entire workflow and explore AI‑driven test case generation.

Capability Building

Framework Setup

A unified test “shell” project was created to host test pages and cases, enabling resource reuse and efficiency gains. Key decisions include consolidating test versions, integrating a single deployment pipeline, and providing a unified interaction entry point for better test experience.

Project structure example:

js-sdk-test-platform/
├── src/
│   ├── components/   # global components
│   │   └── test/      # test utilities
│   ├── views/
│   │   ├── testFunctional/   # functional tests
│   │   │   └── testCases/    # test cases
│   │   ├── testPerformance/  # performance tests
│   │   ├── testAutomation/   # automation framework
│   │   ├── testSmart/        # extensions
│   │   └── testReport/        # reports
│   └── ...
├── playwright/
│   ├── tests/               # test scripts
│   │   ├── functional/
│   │   └── performance/
│   └── ...

The project uses a mature Vue build pipeline and image‑based deployment to ensure stability across environments.

Functional Testing

Functional testing is treated as API‑driven secondary development. After analyzing requirements, eight core test object categories covering over 120 interface methods were identified. A unified test version was created, and test cases were modularized for reuse.

Implementation highlights:

Unified test entry page and case files for centralized management.

Dynamic loading of test cases via a component.

Interface Automation Testing

Automation complements functional testing by verifying single‑interface behavior, handling edge cases, and simulating network errors. Jasmine was chosen for its simplicity and built‑in assertions. Example using MSW for request mocking:

const allOptionsPath = import.meta.glob('./*.ts', { eager: true });
const allOptions = Object.keys(allOptionsPath).map(path => {
  // eslint-disable-next-line prefer-object-spread
  return Object.values(Object.assign({}, allOptionsPath[path]))[0];
});
allOptions.sort((a, b) => {
  if (a.groupName === b.groupName) {
    return a.label.length - b.label.length;
  }
  return a.groupName.localeCompare(b.groupName);
});
export const MENU_OPTIONS = [{
  label: '分组一',
  key: 'comObj',
  children: allOptions.map(item => ({ label: item.label, key: `comObj_${item.key}` }))
}, {
  label: '分组二',
  key: 'testObj',
  children: allOptions.map(item => ({ label: item.label, key: `testObj_${item.key}` }))
}];

Another example of a mocked API test:

const allOptionsPath = import.meta.glob('./*.ts', { eager: true });
// ... (omitted for brevity)

Performance Testing

Performance test cases were designed for SDK‑heavy operations, such as repeatedly calling setZoom. Stats.js was integrated for real‑time metrics like FPS and memory usage, and Playwright automated the execution and data collection.

export default {
  label: '性能测试',
  key: 'performance',
  groupName: 'performancebase',
  children: [{
    label: '连续 setZoom 100次',
    key: 'setZoom',
    methods: obj => {
      const currentZoom = obj.getZoom();
      let count = 0;
      const t = setInterval(() => {
        setZoom(obj);
        count++;
        if (count >= 100) {
          clearInterval(t);
          obj.setZoom(currentZoom, 1000);
          testEnd();
        }
      }, 1000);
    }
  }, /* ... */]
};

Stats.js visualizes frame rate and memory consumption directly in the browser.

import Stats from 'Stats.js';
const stats = new Stats();
stats.showPanel(0);
document.body.appendChild(stats.dom);
stats.domElement.style.position = 'absolute';
stats.domElement.style.right = '10px';
stats.domElement.style.top = '80px';
function animate() {
  stats.begin();
  // monitored code
  stats.end();
  requestAnimationFrame(animate);
}

Intelligent Test Code Generation

Leveraging large‑language‑model capabilities, the platform explores AI‑assisted generation of test code from natural‑language descriptions, reducing manual effort and enabling non‑developers to create test cases quickly. The system provides a RESTful API with SSE streaming to return highlighted code snippets.

Key components include context management, intent recognition, function mapping, and a Spring Boot backend that calls DeepSeek V3 via HTTP client.

Example of AI‑generated code for map positioning:

```javascript
// First random position in Beijing
const position1 = { lng: 116.404, lat: 39.915 };
// Second random position
const position2 = { lng: 116.408, lat: 39.918 };
// Third random position
const position3 = { lng: 116.412, lat: 39.920 };
map.setCenter(position1, 500);
await utils.sleep(500);
map.setCenter(position2, 500);
await utils.sleep(500);
map.setCenter(position3, 500);
```

These AI‑generated snippets can be directly executed, shortening test case creation time from ten minutes to a few seconds.

Future Plans

The platform will evolve to include task‑oriented management, online test case editing, continuous integration, coverage statistics, and deeper AI integration for complex scenario understanding and knowledge‑base‑driven code generation.