Apidog CLI ผนวก Claude Skills: ทดสอบ API อัตโนมัติในขั้นตอนพัฒนา

บทความนี้จะแนะนำวิธีการรวม Apidog CLI เข้ากับ Claude Skills เพื่อสร้างเวิร์กโฟลว์ที่มีประสิทธิภาพสำหรับการ ทดสอบ API อัตโนมัติด้วยภาษาธรรมชาติ

ในเวิร์กโฟลว์นี้ คุณเพียงแค่พูดประโยคเดียวกับ Claude Code ในเทอร์มินัลของคุณ เช่น:

"รันการทดสอบขั้นตอนการสั่งซื้อของผู้ใช้ใน dev"

Claude Code จะเข้าใจความตั้งใจของคุณโดยอัตโนมัติ ค้นหา สถานการณ์ทดสอบ หรือ ชุดทดสอบ ที่เกี่ยวข้อง ดำเนินการทดสอบ และสรุปและตีความผลลัพธ์ให้คุณ

ภาพรวมเครื่องมือ

เวิร์กโฟลว์นี้ประกอบด้วยเครื่องมือสามอย่าง:

1. Apidog CLI

อินเทอร์เฟซบรรทัดคำสั่งที่ Apidog จัดให้ ใช้สำหรับรันการทดสอบ API อัตโนมัติจากเทอร์มินัลและสร้างรายงานการทดสอบ

2. Claude Code

ผู้ช่วย AI แบบบรรทัดคำสั่งที่ Anthropic เปิดตัว สามารถทำงานกับไฟล์ รันคำสั่ง รันสคริปต์ และโต้ตอบกับสภาพแวดล้อมการพัฒนาในเครื่องของคุณได้

3. Claude Skills

หรือที่เรียกว่า Agent Skills ซึ่งเป็นกลไกส่วนขยายของ Claude Code Skill จะกำหนด _วิธีการที่ Claude ควรทำงานเฉพาะให้เสร็จสมบูรณ์_ ซึ่งโดยพื้นฐานแล้วจะทำหน้าที่เป็นชุดคำสั่งการทำงานที่สามารถรันได้

ในเวิร์กโฟลว์นี้ Claude Code มีหน้าที่ทำความเข้าใจคำสั่งภาษาธรรมชาติ เมื่อคำขอของผู้ใช้ตรงกับ Claude Skill ที่กำหนดไว้ล่วงหน้า Claude จะรันคำสั่ง Apidog CLI ที่เกี่ยวข้องโดยอัตโนมัติและวิเคราะห์ผลลัพธ์

เวิร์กโฟลว์นี้ทำอะไรได้บ้าง

ด้านล่างนี้คือสถานการณ์จริงหลายอย่างเพื่อแสดงให้เห็นว่าเวิร์กโฟลว์นี้สามารถนำไปใช้ในทางปฏิบัติได้อย่างไร

รันการทดสอบเดียว

หากคุณต้องการรันสถานการณ์ทดสอบเฉพาะ คุณสามารถระบุชื่อได้อย่างชัดเจน ตัวอย่างเช่น:

"รันการทดสอบการเข้าสู่ระบบใน dev"

หลังจากทดสอบเสร็จสิ้น Claude จะวิเคราะห์ผลลัพธ์และให้สรุปผล

รายการการทดสอบที่มีอยู่ทั้งหมด

หากต้องการดูว่าสถานการณ์ทดสอบหรือชุดทดสอบใดบ้างที่มีอยู่ คุณสามารถพูดว่า:

"แสดงการทดสอบที่มีอยู่"

Claude จะรันสคริปต์ที่เกี่ยวข้องและแสดงรายการการทดสอบทั้งหมด

รันการทดสอบทั้งหมดสำหรับโมดูลธุรกิจ

หากคุณต้องการรันการทดสอบทั้งหมดสำหรับโดเมนธุรกิจเฉพาะ—เช่น การทดสอบที่เกี่ยวข้องกับการชำระเงิน—คุณสามารถพูดว่า:

"รันการทดสอบการชำระเงินทั้งหมดใน test env"

Claude จะค้นหาไฟล์ทดสอบที่เกี่ยวข้องทั้งหมดโดยอัตโนมัติและดำเนินการตามลำดับหรือพร้อมกัน

เปรียบเทียบผลการทดสอบข้ามสภาพแวดล้อม

หากต้องการเปรียบเทียบผลลัพธ์ข้ามสภาพแวดล้อม คุณสามารถพูดว่า:

"รันการทดสอบการเข้าสู่ระบบใน dev และ test"

Claude จะรันการทดสอบในทั้งสองสภาพแวดล้อมและวิเคราะห์ความแตกต่างของผลลัพธ์

รันการทดสอบตามการเปลี่ยนแปลงโค้ด

หลังจากการเปลี่ยนแปลงโค้ด คุณสามารถขอให้ Claude รันเฉพาะการทดสอบที่ได้รับผลกระทบ:

"ตามการเปลี่ยนแปลงโค้ดล่าสุด ให้รันการทดสอบ API ที่ได้รับผลกระทบใน dev"

Claude จะวิเคราะห์การเปลี่ยนแปลง Git ระบุสถานการณ์ทดสอบหรือชุดทดสอบที่ได้รับผลกระทบ และรันเฉพาะการทดสอบเหล่านั้น—ซึ่งช่วยประหยัดเวลาและทรัพยากร

มีสถานการณ์อื่น ๆ อีกมากมายรอให้คุณสำรวจ

ถัดไป เราจะมาดูวิธีการติดตั้งและกำหนดค่า Apidog CLI, Claude Code และ Claude Skills และวิธีการรวมเข้าด้วยกันเพื่อสร้างเวิร์กโฟลว์ที่สมบูรณ์

การเตรียมการ

ข้อกำหนดด้านสภาพแวดล้อม

ตรวจสอบให้แน่ใจว่าได้ติดตั้ง Node.js บนเครื่องของคุณแล้ว ตรวจสอบได้ในเทอร์มินัลของคุณ:

node -v
npm -v

การติดตั้ง Apidog CLI ติดตั้งผ่าน npm:

npm install -g apidog-cli

ตรวจสอบการติดตั้ง:

apidog --version

หากมีการแสดงหมายเลขเวอร์ชัน แสดงว่าการติดตั้งสำเร็จ
คุณสามารถคัดลอกคำสั่ง CLI สำหรับ สถานการณ์ทดสอบ หรือ ชุดทดสอบ จาก Apidog → Tests → CI/CD เพิ่ม Access Token ของคุณ แล้วรันในเทอร์มินัลได้

หากมีเอาต์พุตการทดสอบปรากฏขึ้น แสดงว่า Apidog CLI ทำงานได้อย่างถูกต้อง

การติดตั้ง Claude

ติดตั้ง Code ผ่าน npm:

npm install -g @anthropic-ai/claude-code

ตรวจสอบ:

claude --version

ในการรันครั้งแรก คุณต้องเข้าสู่ระบบ:

claude

ทำตามขั้นตอนการให้สิทธิ์ จำเป็นต้องมีบัญชี Claude หลังจากเข้าสู่ระบบ คุณจะเข้าสู่อินเทอร์เฟซแบบโต้ตอบและสามารถถามคำถามพื้นฐานได้

ณ จุดนี้ Claude ยังไม่ทราบวิธีรันการทดสอบ Apidog ถัดไป เราจะสอนมันโดยใช้ Claude Skills

การสร้าง Claude Skills

ทำความเข้าใจว่า Skills ทำงานอย่างไร

เมื่อใช้ Claude Code คุณไม่จำเป็นต้องเลือก Skill ด้วยตนเอง คุณเพียงแค่อธิบายสิ่งที่คุณต้องการทำด้วยภาษาธรรมชาติ

หากคำขอของคุณตรงกับคำอธิบายของ Skill Claude จะโหลด Skill นั้นโดยอัตโนมัติและดำเนินการตามเวิร์กโฟลว์ที่กำหนดไว้

ขั้นตอนที่ 1: สร้างโฟลเดอร์ Skill

การกำหนดค่า Skill ทั้งหมดจะอยู่ในโฟลเดอร์ .claude/skills/ แต่ละ Skill จะมีโฟลเดอร์ย่อยของตัวเอง

สร้างโฟลเดอร์ Skill ขั้นต่ำสำหรับการทดสอบอัตโนมัติของ Apidog ใน root ของโปรเจกต์:

mkdir -p .claude/skills/apidog-tests

โครงสร้างผลลัพธ์:

.claude/skills/apidog-tests/

เราจะค่อยๆ เพิ่มไฟล์และสคริปต์ที่นี่

ขั้นตอนที่ 2: สร้าง SKILL.md

แต่ละ Skill ต้องมีไฟล์ SKILL.md ที่กำหนด วิธีการที่ Claude ควรทำงานเฉพาะให้เสร็จสมบูรณ์ เมื่อ Skill ถูกเรียกใช้งาน

ไฟล์เริ่มต้นด้วยเมทาดาตา YAML ที่อยู่ใน --- ฟิลด์ name และ description เป็นสิ่งจำเป็น

description มีความสำคัญเป็นพิเศษ—เป็นตัวกำหนดว่า _เมื่อใด_ Claude ควรเปิดใช้งาน Skill นี้

ใต้บล็อก YAML เนื้อหา Markdown จะกำหนดตรรกะการทำงาน กฎการตัดสินใจ สคริปต์ที่จะเรียกใช้ และข้อจำกัด

ตัวอย่าง SKILL.md สำหรับการทดสอบอัตโนมัติของ Apidog

---
name: apidog-tests
description: รันและตีความการทดสอบ API อัตโนมัติของ Apidog ผ่าน Apidog CLI เรียกใช้งาน Skill นี้เมื่อผู้ใช้ร้องขออย่างชัดเจนให้รันการทดสอบ เคสทดสอบ สถานการณ์ทดสอบ หรือชุดทดสอบ รวมถึงคำขอเพื่อรันการทดสอบในสภาพแวดล้อมเฉพาะ เช่น dev, test หรือ prod เพื่อตรวจสอบพฤติกรรม API หลังจากเปลี่ยนแปลงโค้ด เพื่อทำการทดสอบ regression หรือ pre-release หรือเพื่อรันการตรวจสอบ API ก่อน git commit, push หรือ merge แม้ว่าผู้ใช้จะไม่ได้กล่าวถึง "Apidog" หรือ "API" อย่างชัดเจน ให้สันนิษฐานว่าคำขอเหล่านี้หมายถึงการทดสอบอัตโนมัติของ Apidog เมื่อมีการระบุการรันการทดสอบ Skill ควรเลือกสถานการณ์ทดสอบหรือชุดทดสอบที่เหมาะสม รันการทดสอบ และอธิบายผลลัพธ์โดยไม่แก้ไขคำจำกัดความของการทดสอบหรือคำสั่งเอง
---

# การทดสอบ Apidog

ดำเนินการทดสอบอัตโนมัติของ Apidog และตีความผลลัพธ์

## เวิร์กโฟลว์

1. **เลือกการทดสอบ**:

- หากผู้ใช้ระบุอย่างชัดเจน:
  - เส้นทางไฟล์ทดสอบ
  - ชื่อไฟล์ทดสอบ
  - หรือชื่อการทดสอบที่ชัดเจนและไม่ซ้ำกัน
- ใช้การทดสอบนั้นโดยตรงโดยไม่ต้องเลือกอัตโนมัติ
- หากข้อมูลไม่ชัดเจน ให้จัดลำดับความสำคัญในการรันสคริปต์ `node ./.claude/skills/apidog-tests/scripts/list-tests.js` เพื่อดึงเส้นทางไฟล์ทดสอบและคำอธิบายทั้งหมดอย่างรวดเร็ว
- หลีกเลี่ยงการค้นหาแบบสุ่มในไดเรกทอรีโปรเจกต์ขนาดใหญ่; ให้ค้นหาไดเรกทอรีไฟล์ทดสอบ `./.claude/skills/apidog-tests/tests/` ที่จัดสรรไว้สำหรับ Skill นี้แทน

2. **กฎการดำเนินการทดสอบหลายรายการ**

- โดยค่าเริ่มต้น จะรันการทดสอบเพียงครั้งเดียว แต่มีตัวเลือกสำหรับการดำเนินการแบบแบตช์
- หากผู้ใช้ระบุอย่างชัดเจน:
  - "รันสองสามอันนี้"
  - "รันทั้งหมด"
- เข้าสู่ **โหมดการดำเนินการแบบแบตช์**

ในโหมดการดำเนินการแบบแบตช์:
- แสดงรายการการทดสอบที่จะรันอย่างชัดเจน
- **ถามวิธีการดำเนินการ**: ให้ผู้ใช้เลือกระหว่าง "การดำเนินการตามลำดับ" (อ่านง่ายกว่า) หรือ "การดำเนินการแบบขนาน" (เร็วกว่า)
  - **การดำเนินการตามลำดับ**: รันการทดสอบทีละรายการและวิเคราะห์ทันที เหมาะสำหรับการดีบัก
  - **การดำเนินการแบบขนาน**: เริ่มการทดสอบหลายรายการพร้อมกัน (โดยใช้ `&` หรือสคริปต์พร้อมกัน) เหมาะสำหรับการ regression อย่างรวดเร็ว แม้ว่าบันทึกอาจจะสลับกัน
- ร้องขอการยืนยันจากผู้ใช้สำหรับวิธีการดำเนินการและรายการทดสอบ (ใช่ / ไม่ใช่)
- ดำเนินการทดสอบตามวิธีการที่เลือก
- สุดท้าย สรุปหรืออธิบายผลลัพธ์ของการทดสอบแต่ละรายการแยกกัน

3. **ยืนยันสภาพแวดล้อม**:
- สภาพแวดล้อมที่รองรับได้แก่:
  - `dev`
  - `test`
  - `prod`
- หากผู้ใช้ไม่ได้ระบุสภาพแวดล้อม:
  - แสดงรายการชื่อสภาพแวดล้อมด้านบน
  - ให้ผู้ใช้ยืนยันว่าจะใช้ตัวใด

4. **ดำเนินการทดสอบ**:
- ดำเนินการทดสอบเมื่อข้อมูลต่อไปนี้ชัดเจน:
  - เส้นทางไฟล์ทดสอบ
  - ชื่อสภาพแวดล้อม (dev / test / prod)
```bash
node ./.claude/skills/apidog-tests/scripts/run-cli.js <test_file_path> <env_name>
```

5. **ตีความผลลัพธ์**: วิเคราะห์เอาต์พุต Apidog CLI และอธิบายสาเหตุของความล้มเหลว

## การจัดการความล้มเหลว

- ห้ามแก้ไขไฟล์ทดสอบ
- ห้ามแก้ไขคำสั่งการทำงาน
- อธิบายสาเหตุของความล้มเหลวโดยอิงจากชื่อการทดสอบ ความหมายของ API และเอาต์พุต CLI

ขั้นตอนที่ 3: ไฟล์สนับสนุน

ในขั้นตอนก่อนหน้า เราได้สร้างไฟล์ SKILL.md ซึ่งกำหนดเงื่อนไขการเรียกใช้และเวิร์กโฟลว์การทำงานโดยรวมสำหรับ Skill นี้

จากพื้นฐานนี้ ไฟล์ที่เหลือทั้งหมดจะทำหน้าที่เป็นส่วนประกอบสนับสนุนสำหรับ SKILL.md เท่านั้น ไฟล์เพิ่มเติมจะถูกนำมาใช้ตามความต้องการ เมื่อเวิร์กโฟลว์ต้องการข้อมูลเพิ่มเติม เช่น สภาพแวดล้อมรันไทม์ คำสั่งการทำงาน หรือคำจำกัดความของการทดสอบ

โครงสร้างโฟลเดอร์สุดท้าย:

.claude/skills/apidog-tests/
├── SKILL.md
├── env/
│   ├── dev.env
│   ├── test.env
│   └── prod.env
├── scripts/
│   ├── list-tests.js
│   └── run-cli.js
└── tests/
    ├── payment-flow.md
    └── refund-flow.md

ด้านล่างนี้ เราจะอธิบายไฟล์สนับสนุนแต่ละไฟล์ โดยอธิบายวัตถุประสงค์และให้ตัวอย่าง

การกำหนดค่าสภาพแวดล้อม (env)

โฟลเดอร์ env/ ใช้สำหรับจัดเก็บการกำหนดค่าตัวแปรสภาพแวดล้อม เช่น โทเค็นการเข้าถึง Apidog และ ID สภาพแวดล้อม

โดยการแยก ID สภาพแวดล้อมออกเป็นตัวแปร เราสามารถสลับสภาพแวดล้อมการทำงานของการทดสอบได้อย่างรวดเร็ว (เช่น การพัฒนา การทดสอบ การผลิต) โดยไม่ต้องแก้ไขคำสั่งหรือสคริปต์ใดๆ

ตัวอย่างเช่น สร้างไฟล์ dev.env ใต้โฟลเดอร์ env/:

APIDOG_ACCESS_TOKEN=APS-your-access-token
APIDOG_ENV_ID=your-environment-id

หากต้องการสภาพแวดล้อมหลายอย่าง คุณสามารถสร้างไฟล์เพิ่มเติมได้ในลักษณะเดียวกัน:

• test.env
• prod.env
• …

แต่ละไฟล์จำเป็นต้องคงตัวแปรสำหรับสภาพแวดล้อมที่เกี่ยวข้องเท่านั้น

ID สภาพแวดล้อมจะสอดคล้องกับค่าตัวเลขที่ส่งไปยังพารามิเตอร์ -e ในคำสั่ง Apidog CLI สภาพแวดล้อมรันไทม์แต่ละแห่ง (เช่น การพัฒนา การทดสอบ หรือการผลิต) มี ID สภาพแวดล้อมที่ไม่ซ้ำกัน ใน Apidog

สคริปต์การดำเนินการ (scripts)

โฟลเดอร์ scripts/ มีสคริปต์ที่รันได้ ซึ่งมีหน้าที่แปลงคำจำกัดความของการทดสอบเป็นคำสั่ง Apidog CLI ที่สามารถรันได้จริง ฉีดตัวแปรสภาพแวดล้อม และดำเนินการทดสอบ

ใน Skill นี้ Node.js ถูกเลือกด้วยเหตุผลหลักสองประการ:

1. Apidog CLI เองก็ขึ้นอยู่กับ Node.js การนำรันไทม์เดียวกันกลับมาใช้ใหม่ช่วยหลีกเลี่ยงความจำเป็นในการติดตั้งรันไทม์เพิ่มเติม เช่น Python
2. ลดโอเวอร์เฮดของบริบทและการใช้โทเค็น โดยการจัดการการแยกวิเคราะห์คำสั่ง การฉีดตัวแปร และตรรกะการทำงานภายในสคริปต์ Claude ไม่จำเป็นต้องสร้างคำสั่ง CLI แบบเต็มซ้ำๆ ในระหว่างการสนทนา ซึ่งช่วยลดการใช้บริบทได้อย่างมาก

หากคุณไม่คุ้นเคยกับการเขียนสคริปต์ คุณอาจเลือกที่จะไม่ใช้สคริปต์เลยก็ได้ คุณสามารถให้ Claude ประกอบและรันคำสั่ง CLI โดยตรงใน SKILL.md แทนได้

อย่างไรก็ตาม วิธีการนี้มาพร้อมกับบริบทและค่าใช้จ่ายโทเค็นที่สูงขึ้น
สร้าง run-cli.js ใต้โฟลเดอร์ scripts/ ความรับผิดชอบหลักคือ:

• แยกคำสั่ง Apidog CLI จากไฟล์ทดสอบ Markdown ที่ระบุ
• โหลดไฟล์ .env ที่เกี่ยวข้องตามสภาพแวดล้อมที่เลือก (เช่น dev / test)
• ฉีดตัวแปรสภาพแวดล้อมและรันการทดสอบ

ตัวอย่างสคริปต์ที่พร้อมใช้งานจะแสดงด้านล่าง:

import fs from "fs";
import path from "path";
import { execSync } from "child_process";
import dotenv from "dotenv";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// args
const mdPath = process.argv[2];
const envName = process.argv[3] || "local";

if (!mdPath) {
    console.error("❌ Missing test .md file path");
    process.exit(1);
}

// env path: always relative to the skill folder
const envPath = path.join(__dirname, "..", "env", `${envName}.env`);

if (!fs.existsSync(envPath)) {
    console.error(`❌ Environment configuration not found: ${envPath}`);
    process.exit(1);
}

dotenv.config({ path: envPath });

// Read markdown file
const content = fs.readFileSync(mdPath, "utf-8");
const match = content.match(/```bash([\s\S]*?)```/);

if (!match) {
    console.error("❌ Bash command block not found");
    process.exit(1);
}

let command = match[1].trim();

// Variable replacement
command = command
    .replaceAll("$APIDOG_ACCESS_TOKEN", process.env.APIDOG_ACCESS_TOKEN)
    .replaceAll("$APIDOG_ENV_ID", process.env.APIDOG_ENV_ID);

console.log(`▶ Running (${envName})`);
console.log(command);

// Execute
try {
    execSync(command, { stdio: "inherit" });
} catch (e) {
    // Apidog CLI returns exit code 1 when tests fail
    process.exit(1);
}

สร้าง list-tests.js ใต้โฟลเดอร์ scripts/ ด้วย ใช้สำหรับ:

• สแกนโฟลเดอร์ tests/ แบบวนซ้ำ
• ค้นหาไฟล์ทดสอบ Markdown ทั้งหมด
• แยกคำอธิบายออกจากบรรทัดแรก
• แสดงรายการการทดสอบอัตโนมัติของ Apidog ที่มีอยู่ทั้งหมด

ตัวอย่างสคริปต์ที่พร้อมใช้งานจะแสดงด้านล่าง:

import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const testsDir = path.join(__dirname, "..", "tests");

function scan(dir, relativePath = "") {
    const items = fs.readdirSync(dir, { withFileTypes: true });
    
    for (const item of items) {
        const fullPath = path.join(dir, item.name);
        const relPath = path.join(relativePath, item.name);
        
        if (item.isDirectory()) { // Corrected from isfolder() to isDirectory()
            scan(fullPath, relPath);
        } else if (item.name.endsWith(".md")) {
            try {
                const content = fs.readFileSync(fullPath, "utf-8");
                const firstLine = content.split("\n")[0].trim();
                const description = firstLine.startsWith(">")
                    ? firstLine.replace(/^>\s*/, "").trim()
                    : "No description";
                const displayPath = path.join(
                    "./.claude/skills/apidog-tests/tests",
                    relPath
                );
                console.log(`[${displayPath}] - ${description}`);
            } catch (err) {
                console.log(`[${relPath}] - (Unable to read file)`);
            }
        }
    }
}

console.log("🔍 Available Apidog automated tests:");
if (fs.existsSync(testsDir)) {
    scan(testsDir);
} else {
    console.log("❌ tests folder not found");
}

คำจำกัดความของการทดสอบ (tests)

โฟลเดอร์ tests/ จัดเก็บคำจำกัดความของการทดสอบที่เขียนใน Markdown

หลักการออกแบบ: ไฟล์ Markdown แต่ละไฟล์จะสอดคล้องกับ สถานการณ์ทดสอบ Apidog หรือชุดทดสอบเดียว คุณสามารถนำโครงสร้างโฟลเดอร์ที่มีอยู่ ชื่อสถานการณ์ทดสอบ ชื่อชุดทดสอบ และคำอธิบายจากการทดสอบอัตโนมัติของ Apidog กลับมาใช้ใหม่ได้โดยตรง

ไฟล์ Markdown แต่ละไฟล์จำเป็นต้องมีเพียงสองส่วนเท่านั้น:

1. คำอธิบายการทดสอบสั้นๆ
2. คำสั่ง Apidog CLI เดียวที่สามารถรันได้โดยตรง

ในคำสั่ง Apidog CLI:

• โทเค็นการเข้าถึงจะถูกแทนที่ด้วย $APIDOG_ACCESS_TOKEN
• ID สภาพแวดล้อมที่ส่งไปยัง -e จะถูกแทนที่ด้วย $APIDOG_ENV_ID

ตัวแปรทั้งสองถูกกำหนดค่าไว้ที่ส่วนกลางในไฟล์ .env วิธีการนี้ช่วยป้องกันการรั่วไหลของโทเค็นและช่วยให้สามารถสลับสภาพแวดล้อมได้อย่างยืดหยุ่น

ตัวอย่าง: login-auth-flow.md

> ตรวจสอบ API หลัก เช่น การเข้าสู่ระบบ การรีเฟรชโทเค็น และการออกจากระบบ

```bash
apidog run --access-token $APIDOG_ACCESS_TOKEN -t 5564xxx -e $APIDOG_ENV_ID -n 1 -r html,cli
```

ณ จุดนี้ Skill ถูกสร้างขึ้นอย่างสมบูรณ์แล้ว คุณสามารถตรวจสอบโครงสร้างโฟลเดอร์และเปรียบเทียบกับสิ่งที่คุณสร้างขึ้นเองเพื่อระบุความแตกต่าง

การใช้เวิร์กโฟลว์ใน Claude Code

รัน claude ในโฟลเดอร์โปรเจกต์ Claude จะสแกน .claude/skills/ โดยอัตโนมัติและโหลด apidog-tests Skill

คุณสามารถแสดงรายการ Skills ที่โหลดโดยใช้ /skills

จากนั้นลองใช้คำสั่งภาษาธรรมชาติ:

"รันการทดสอบการเข้าสู่ระบบใน dev"

Claude จะค้นหาการทดสอบ ดำเนินการผ่าน Apidog CLI วิเคราะห์เอาต์พุต และสรุปผลลัพธ์

สรุป

บทความนี้แสดงให้เห็นถึงวิธีการสร้างเวิร์กโฟลว์การทดสอบ API อัตโนมัติโดยใช้ Claude Code, Apidog CLI และ Claude Skills

แนวคิดหลักคือการทำให้ Claude เป็น สะพานเชื่อมระหว่างมนุษย์และเครื่องมือ โดย:

• คุณอธิบายความตั้งใจด้วยภาษาธรรมชาติ
• Claude เข้าใจและเรียกใช้สคริปต์
• สคริปต์รัน Apidog CLI
• Claude วิเคราะห์และนำเสนอผลลัพธ์ในรูปแบบที่มนุษย์เข้าใจได้

เพื่อให้เวิร์กโฟลว์นี้มีประสิทธิภาพอย่างแท้จริง คุณควรปรับแต่งให้เข้ากับโปรเจกต์ของคุณ—การจัดระเบียบการทดสอบ กลยุทธ์ด้านสภาพแวดล้อม และตรรกะการวิเคราะห์ผลลัพธ์ ล้วนสามารถปรับแต่งได้

หากทีมของคุณรันการทดสอบ API บ่อยครั้งและต้องการประสบการณ์ที่เป็นอัตโนมัติและชาญฉลาดมากขึ้น วิธีการนี้ก็น่าลองเป็นอย่างยิ่ง ต้องมีการตั้งค่าเบื้องต้นบ้าง แต่เมื่อจัดตั้งแล้ว ก็จะสามารถปรับปรุงประสิทธิภาพได้อย่างมาก และจะดียิ่งขึ้นไปอีกเมื่อคุณปรับปรุงให้สมบูรณ์แบบ