grpc-test-automation

Complete gRPC test automation for embedded devices with C/C++ SDK. Input: requirements.md + SDK (C/C++ headers and libraries) Output: Test framework + JMX +...

Security Scan

The skill's code and instructions largely match its stated purpose (automating gRPC tests for a C/C++ SDK), but there are implementation and operational inconsistencies (undisclosed tool dependencies, runtime pip installs, hard-coded paths and network exposure) that you should review before running.

Purpose & Capability

Name, SKILL.md, scripts, and reference docs consistently implement gRPC test automation for a C/C++ SDK (many references to a 'venc' SDK). That alignment is reasonable. Minor mismatch: the skill assumes many external tools (protoc, cmake, make, gRPC libs, JMeter at /opt/jmeter, grpc_cpp_plugin) but the registry metadata lists no required binaries or environment variables.

Instruction Scope

Runtime instructions focus on analyzing SDK headers, generating proto/service wrappers, building a C++ gRPC server, deploying artifacts to an embedded board, running JMeter tests, and producing an Excel report. The instructions do not request unrelated secrets or system files. Note: the workflow includes deploying/mounting artifacts to a board and starting a server listening on 0.0.0.0 (insecure by default) — expected for testing but operationally sensitive.

Install Mechanism

There is no formal install spec, but scripts perform network installs at runtime: init_project.sh calls 'pip3 install grpcio grpcio-tools protobuf openpyxl', and generate_report.py will invoke pip (via subprocess) to install openpyxl if missing. These actions fetch packages from PyPI at runtime and write to the host environment. No downloads from arbitrary URLs were observed, but automatic package installation increases risk and should be reviewed.

Credentials

The skill declares no required environment variables or credentials and the code does not attempt to read secrets. It does rely on system tools and specific paths (/opt/jmeter, system protoc/grpc plugins). No environment-variable exfiltration or unrelated credential access was detected.

Persistence & Privilege

The skill does not request always:true, does not modify other skills, and does not try to persist credentials. It will start processes (gRPC server, JMeter) during tests but there is no sign of long-term privilege escalation or forced inclusion.

What to consider before installing

This skill appears to implement what it claims, but review and prepare before running: 1) Inspect scripts (especially init_project.sh, analyze_sdk.py, generate_report.py) and confirm you trust the SDK and repository. 2) Expect the scripts to install Python packages from PyPI at runtime — run these installs in a sandbox or virtualenv if needed. 3) Ensure required tools are present: protoc, cmake, make, gRPC C++ plugin, and JMeter (the templates assume /opt/jmeter). 4) The generated server binds 0.0.0.0 and uses insecure credentials by default — run it in an isolated test network, not on production or Internet-facing hosts. 5) Verify any mounting/deploy steps to your embedded board are safe for that device and do not overwrite critical files. 6) Because some parsing logic in analyze_sdk.py is brittle/specialized (e.g., filters around functions prefixed with 'venc_'), test the analyzer on sample headers first. If you need higher assurance, run the initialization and builds in a VM/container and audit any network activity and installed packages.

gRPC Test Automation for Embedded Devices

Automated framework for testing C/C++ SDK on embedded boards via gRPC + JMeter.

Complete Workflow

┌─────────────────────────────────────────────────────────────────┐
│  输入: 需求文档 + C/C++ SDK (头文件 + 库)                        │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 1: 分析 SDK 头文件                                         │
│  - 提取函数签名                                                   │
│  - 识别错误码枚举                                                 │
│  - 理解数据结构                                                   │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 2: 编写 C++ gRPC 服务端                                    │
│  - 创建 Proto 文件 (基于 SDK 接口)                                │
│  - 实现 gRPC 服务类 (封装 SDK 调用)                               │
│  - 编写 CMakeLists.txt                                          │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 3: 编译生成                                                │
│  - cmake + make → 生成可执行文件                                  │
│  - protoc → 生成 proto descriptor (.protobin)                   │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 4: 编写 JMeter JMX                                        │
│  - 引用 proto descriptor                                        │
│  - 配置 gRPC Sampler                                            │
│  - 定义测试用例                                                   │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 5: 串口下发资源到板端                                       │
│  - 模拟串口通信 (TCP Socket)                                     │
│  - 下发: SDK库 + 服务程序 + Proto                                │
│  - 挂载到板端目录                                                 │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 6: 板端拉起服务                                            │
│  - 设置 LD_LIBRARY_PATH                                         │
│  - 执行 ./grpc_server 8080                                      │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 7: JMeter 执行测试                                         │
│  - jmeter -n -t test.jmx                                       │
│  - 收集响应数据                                                  │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 8: 生成 Excel 报告                                         │
│  - 测试概览                                                      │
│  - 测试详情                                                      │
│  - 性能指标                                                      │
│  - 错误详情                                                      │
└─────────────────────────────────────────────────────────────────┘

Input Files

Required

• sdk/include/*.h - SDK header files
• sdk/lib/*.so or sdk/lib/*.a - SDK libraries

Optional

• requirements.md - Interface specifications
• test_cases.md - Historical test cases
• test_framework/ - Historical framework code

Output Structure

grpc_test/
├── proto/
│   └── service.proto            # Generated from SDK analysis
├── server/
│   ├── CMakeLists.txt          # Build configuration
│   ├── grpc_server.cpp         # gRPC server (wraps SDK)
│   ├── build/                  # Build output
│   │   ├── grpc_server         # Compiled executable
│   │   └── service.protobin    # Proto descriptor for JMeter
│   └── service.pb.h/cc         # Generated protobuf code
├── client/
│   └── test_client.cpp         # Optional test client
├── jmeter/
│   ├── test_plans/
│   │   └── test.jmx           # JMeter test plan
│   ├── results/
│   │   ├── result.jtl         # Raw results
│   │   └── report.xlsx        # Excel report
│   └── service.protobin       # Proto descriptor (copied)
├── scripts/
│   ├── serial_simulator.py    # Serial communication simulator
│   ├── deploy_to_board.sh     # Deploy resources to board
│   ├── run_server.sh          # Start server on board
│   └── run_tests.sh           # Execute full test cycle
└── sdk/                        # Original SDK (mounted to board)
    ├── include/
    └── lib/

Scripts Usage

1. Analyze SDK Headers

scripts/analyze_sdk.py sdk/include/

Extracts: functions, enums, structs, error codes

2. Generate Proto + Server

scripts/generate_grpc_server.py --sdk sdk/ --output server/

Creates: proto file, server.cpp, CMakeLists.txt

3. Build

cd server/build && cmake .. && make

Generates: grpc_server executable, service.protobin

4. Deploy to Board

scripts/deploy_to_board.sh --board localhost:9999 --sdk sdk/ --server server/build/

5. Run Tests

scripts/run_tests.sh --jmx jmeter/test_plans/test.jmx --output jmeter/results/

Key Implementation Details

SDK Analysis Pattern

// SDK Header
venc_error_t venc_get_device_info(venc_device_info_t *info);
typedef struct { char device_id[64]; ... } venc_device_info_t;
typedef enum { VENC_OK=0, VENC_ERR_PARAM=1001 } venc_error_t;

↓ Analysis ↓

// Proto Definition
service VencService {
    rpc GetDeviceInfo(GetDeviceInfoRequest) returns (GetDeviceInfoResponse);
}

message GetDeviceInfoResponse {
    string device_id = 1;
    ErrorCode error = 2;
}

Server Wrapper Pattern

// gRPC Server wraps SDK calls
Status GetDeviceInfo(ServerContext* ctx, 
                     const GetDeviceInfoRequest* req,
                     GetDeviceInfoResponse* resp) override {
    venc_device_info_t info;
    venc_error_t err = venc_get_device_info(&info);  // Call SDK
    
    if (err == VENC_OK) {
        resp->set_device_id(info.device_id);
        return Status::OK;
    }
    return Status(StatusCode::INTERNAL, "SDK error");
}

Serial Communication Protocol

// Commands
{"command": "MOUNT", "source_path": "/path/to/sdk"}
{"command": "UPLOAD", "filename": "grpc_server", "content": "..."}
{"command": "START_SERVER", "port": 8080}
{"command": "STATUS"}
{"command": "STOP_SERVER"}

See Also

• references/sdk-analysis.md - SDK header parsing patterns
• references/cpp-server.md - C++ gRPC server implementation
• references/serial-protocol.md - Serial communication details
• references/jmeter-config.md - JMeter gRPC plugin configuration