Bruno CLI vs Apidog CLI: ทดสอบ API ใน CI

การทดสอบ API ของคุณผ่านบนแล็ปท็อป แต่คำถามที่แท้จริงคือว่าการทดสอบเหล่านั้นทำงานได้หรือไม่กับการดึงคำขอแต่ละครั้ง การผสานแต่ละครั้ง การสร้างรายวันแต่ละครั้ง โดยไม่ต้องมีมนุษย์คลิกอะไรเลย นั่นคืองานของตัวรันแบบบรรทัดคำสั่ง (command-line runner) มันนำการทดสอบที่คุณได้สร้างไว้แล้วมาดำเนินการแบบ Headless ภายในไปป์ไลน์ของคุณ จบด้วยรหัสสถานะที่สะอาด และเขียนรายงานที่แดชบอร์ด CI ของคุณสามารถอ่านได้

ตัวรันสองตัวที่ถูกกล่าวถึงบ่อยครั้งเมื่อทีมตั้งค่าสิ่งนี้คือ Bruno CLI และ Apidog CLI ทั้งสองแก้ปัญหาเดียวกันแต่จากจุดเริ่มต้นที่ต่างกัน Bruno เป็นไคลเอนต์ API แบบ git-native, offline-first และ open-source โดย CLI ของมันจะรันไฟล์ .bru ที่อยู่ในคลังของคุณ Apidog เป็นแพลตฟอร์ม API แบบ All-in-one และ CLI ของมันจะรันสถานการณ์การทดสอบแบบภาพที่คุณสร้างขึ้นในแอป ทั้งคู่สามารถเชื่อมต่อกับ GitHub Actions, GitLab CI, Jenkins และอื่นๆ ที่รองรับ Node.js ทั้งคู่จะทำให้การสร้างล้มเหลวเมื่อการทดสอบล้มเหลว ความแตกต่างจะปรากฏให้เห็นในวิธีการสร้างการทดสอบ วิธีการตรวจสอบสิทธิ์ และวิธีการส่งนิยามการทดสอบไปยัง CI

button

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

สรุป

Bruno CLI (@usebruno/cli, ไบนารี bru) รันไฟล์ .bru โดยตรงจากโฟลเดอร์ใน Git repo ของคุณ เป็นโอเพ่นซอร์ส ทำงานแบบออฟไลน์ ไม่ต้องมีบัญชีหรือโทเค็น คุณเพียงแค่ชี้ไปยังไดเรกทอรีแล้วมันจะรันคำขอและการยืนยันทั้งหมดที่พบ
Apidog CLI (apidog-cli, ไบนารี apidog) รันสถานการณ์การทดสอบที่คุณออกแบบในแอป Apidog โดยดึงข้อมูลด้วย ID โดยใช้ Access Token คุณไม่ต้องเขียนการทดสอบใหม่เป็นโค้ด; สถานการณ์แบบภาพคือการทดสอบ และ CLI จะดำเนินการแบบ Headless
ทั้งคู่สามารถสร้างรายงานในรูปแบบ JUnit, JSON และ HTML และทั้งคู่จะทำให้การสร้างล้มเหลวหากการทดสอบล้มเหลว JUnit XML คือสิ่งที่เชื่อมต่อกับแดชบอร์ด CI ได้ในทั้งสองกรณี
เลือก Bruno เมื่อคุณต้องการทุกอย่างอยู่ใน repo, ไม่ต้องมีบัญชีใดๆ, และควบคุมไฟล์ทดสอบข้อความธรรมดาแบบออฟไลน์ได้อย่างสมบูรณ์
เลือก Apidog เมื่อคุณต้องการการสร้างแบบภาพ, การเชื่อมโยงสถานการณ์, การจัดการสภาพแวดล้อม และการรันที่ขับเคลื่อนด้วยข้อมูล โดยไม่ต้องดูแลโค้ดทดสอบด้วยตนเอง

ปัญหาที่แท้จริง: การทดสอบที่มีอยู่แต่ไม่เคยถูกรัน

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

ตัวรัน CLI คือสิ่งที่ช่วยอุดช่องว่างนั้น มันต้องการสามสิ่งเพื่อที่จะมีประโยชน์ใน CI: ต้องสามารถทำงานได้โดยไม่มี GUI, ต้องจบการทำงานด้วยค่าที่ไม่ใช่ศูนย์เมื่อมีบางอย่างล้มเหลวเพื่อให้การสร้างเป็นสีแดง, และต้องเขียนรายงานที่เครื่องสามารถอ่านได้ เพื่อให้ผู้ตรวจสอบเห็นว่าอะไรเสีย Bruno และ Apidog ทั้งคู่ผ่านเกณฑ์นี้ ความแตกต่างอยู่ที่ขั้นตอนก่อนการรันคำสั่ง ในวิธีการเขียนการทดสอบและที่อยู่ของมัน

หากคุณกำลังตั้งค่า CI ตั้งแต่เริ่มต้น รูปแบบที่กว้างขึ้นในการ ทำให้การทดสอบ API เป็นอัตโนมัติใน CI/CD นั้นคุ้มค่าที่จะอ่านควบคู่ไปกับการเปรียบเทียบนี้ ที่นี่เรามุ่งเน้นไปที่ตัวรันทั้งสองเอง

สิ่งที่ Bruno CLI ทำได้ดี

การออกแบบทั้งหมดของ Bruno เป็นแบบ git-native ทุกคำขอ สภาพแวดล้อม และการยืนยัน (assertion) เป็นไฟล์ข้อความธรรมดา .bru บนดิสก์ ภายใน repository ของคุณ ซึ่งถูกควบคุมเวอร์ชันเหมือนไฟล์ซอร์สโค้ดอื่นๆ โมเดลนี้มีข้อดีที่แท้จริง และคุ้มค่าที่จะกล่าวถึงอย่างชัดเจนก่อนที่จะเปรียบเทียบ

การทดสอบของคุณอยู่กับโค้ดของคุณ คำขอดึง (pull request) ที่เปลี่ยน Endpoint สามารถเปลี่ยนการทดสอบสำหรับ Endpoint นั้นใน Diff เดียวกัน ตรวจสอบโดยบุคคลเดียวกัน ไม่มีระบบแยกต่างหากที่จะต้องซิงค์ ไม่มีสำเนาบนคลาวด์ที่อาจแตกต่างจากสิ่งที่อยู่ใน Repository Diffs สามารถอ่านได้เนื่องจากรูปแบบเป็นข้อความ คุณสามารถ Grep การทดสอบของคุณ จัดโครงสร้างใหม่ด้วยเครื่องมือเดียวกับที่คุณใช้สำหรับโค้ด และแก้ไขข้อขัดแย้งในการผสานใน Editor

นอกจากนี้ยังเป็นโอเพ่นซอร์สและออฟไลน์ CLI ทำงานได้ทั้งหมดบนเครื่องของคุณหรือ CI runner ของคุณ โดยไม่มีบัญชี ไม่มีการล็อกอิน และไม่มีโทเค็น สำหรับทีมที่มีกฎการจัดการข้อมูลที่เข้มงวดหรือสภาพแวดล้อมที่แยกออกจากเครือข่าย นี่เป็นสิ่งสำคัญ Bruno Ultimate ซึ่งเป็นระดับที่ต้องชำระเงินของ Bruno เพิ่มคุณสมบัติสำหรับทีม รวมถึง SSO และ SCIM, การผสานรวมกับตัวจัดการความลับ และความสามารถในการตรวจสอบ ดังนั้นโปรเจกต์นี้จึงไม่ใช่แค่เครื่องมือสำหรับผู้เริ่มต้นเท่านั้น แต่ไคลเอนต์หลักและ CLI นั้นฟรีและเป็นอิสระ และนั่นคือจุดแข็งที่สำคัญ

การติดตั้งทำได้ด้วยคำสั่งเดียว:

npm install -g @usebruno/cli

ไบนารีคือ bru คุณสามารถรัน Collection โดยชี้ไปที่โฟลเดอร์ที่เก็บไฟล์ .bru ของคุณ:

bru run --env staging

รันจากภายในไดเรกทอรี Collection และ bru run จะดำเนินการคำขอที่พบที่นั่น เพิ่ม -r เพื่อวนซ้ำผ่านโฟลเดอร์ย่อยเพื่อให้มันเลือกคำขอที่ซ้อนกัน:

bru run -r --env staging

นั่นคือวงจรหลัก ไม่มี ID ไม่มีโทเค็น ไม่มีการดึงข้อมูลระยะไกล ไฟล์ในโฟลเดอร์คือการทดสอบ และ CLI จะรันมัน

เราได้กล่าวถึงเรื่องราวที่กว้างขึ้นของ Bruno ใน สิ่งที่ทำให้ Bruno แตกต่างในฐานะไคลเอนต์ API แบบ Git-native และ ข้อจำกัดของมันที่ปรากฏให้เห็นสำหรับทีมขนาดใหญ่ โดยเฉพาะอย่างยิ่งสำหรับ CI จุดแข็งที่กล่าวมาข้างต้นคือสิ่งที่สำคัญที่สุด

สิ่งที่ Apidog CLI ทำได้ดี

Apidog ใช้เส้นทางที่แตกต่างกันสำหรับไปป์ไลน์เดียวกัน คุณสร้างการทดสอบด้วยภาพในแอป Apidog: เชื่อมโยงคำขอเข้าเป็นสถานการณ์ (scenario), เพิ่มการยืนยัน (assertions), ดึงค่าจากผลลัพธ์หนึ่งไปยังคำขอถัดไป และวนซ้ำทั้งหมดกับไฟล์ข้อมูล CLI คือตัวดำเนินการแบบ Headless สำหรับสถานการณ์เหล่านั้น มันไม่มีรูปแบบไฟล์เป็นของตัวเอง มันดึงสถานการณ์ที่คุณระบุด้วย ID จากโปรเจกต์ Apidog ของคุณและรันมันเหมือนกับที่แอปจะทำ

ข้อดีคือไม่มีใครต้องดูแลการแสดงผลสองแบบของการทดสอบเดียวกัน สถานการณ์ในโปรเจกต์คือการทดสอบ คุณสร้างมันใน Visual Builder ที่จัดการการเชื่อมโยงคำขอ การดึงตัวแปร และการยืนยัน โดยที่คุณไม่ต้องเขียนและดีบักไฟล์สคริปต์ จากนั้น CLI จะรันสถานการณ์เดียวกันนั้นใน CI วงจรการสร้างที่รวดเร็วและวงจรการทำงานอัตโนมัติใช้แหล่งความจริงเดียว

การติดตั้งทำได้ด้วยคำสั่ง npm เดียว:

npm install -g apidog-cli

ไบนารีคือ apidog การรันทั่วไปจะระบุชื่อสถานการณ์ด้วย ID, เลือกสภาพแวดล้อม และตรวจสอบสิทธิ์ด้วย Access Token:

apidog run --access-token $APIDOG_ACCESS_TOKEN -t 605067 -e 1629989 -n 1 -r html,junit

คุณไม่จำเป็นต้องพิมพ์ ID เหล่านั้นด้วยตัวเอง เปิดสถานการณ์การทดสอบ, ไปที่แท็บ CI/CD, สร้าง Access Token, และ Apidog จะสร้างคำสั่งเต็มรูปแบบให้คุณพร้อมกับ ID สถานการณ์และ ID สภาพแวดล้อมที่กรอกไว้แล้ว คุณเพียงแค่คัดลอกครั้งเดียว จากนั้นย้ายโทเค็นไปเก็บใน CI secret และอ้างอิงด้วย $APIDOG_ACCESS_TOKEN การอ้างอิงแฟล็กทั้งหมดอยู่ใน คู่มือฉบับสมบูรณ์ของ Apidog CLI หากคุณต้องการตัวเลือกทั้งหมดในที่เดียว

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

เปรียบเทียบเคียงข้างกัน

มิติ	Bruno CLI (`bru`)	Apidog CLI (`apidog`)
แพ็คเกจ	`@usebruno/cli`	`apidog-cli`
คำสั่งรัน	`bru run`	`apidog run`
แหล่งที่มาของการทดสอบ	ไฟล์ `.bru` ใน Git repo ของคุณ	สถานการณ์การทดสอบในโปรเจกต์ Apidog ของคุณ, ดึงด้วย ID
การสร้าง	แก้ไขไฟล์ข้อความด้วยตนเองหรือใช้แอป Bruno	Visual scenario builder ในแอป Apidog
การยืนยันสิทธิ์ใน CI	ไม่มี; รันแบบออฟไลน์	Access Token (`--access-token`)
เลือกสิ่งที่รัน	เส้นทางโฟลเดอร์, `-r` แบบเรียกซ้ำ, `--tags`	`-t` สถานการณ์, `-f` โฟลเดอร์, `--test-suite`
สภาพแวดล้อม	`--env <name>`	`-e <environmentId>`
ขับเคลื่อนด้วยข้อมูล	`--csv-file-path`, `--json-file-path`	`-d <path>` (CSV หรือ JSON)
การทำซ้ำ	`--iteration-count <n>`	`-n <n>`
ผู้รายงาน	JSON, JUnit, HTML	`cli`, `html`, `json`, `junit`
Fail-fast	`--bail`	`--on-error end` (ค่าเริ่มต้นจะล้มเหลวเมื่อเกิดข้อผิดพลาดครั้งแรก)
โอเพ่นซอร์ส	ใช่	ไม่ (CLI npm ฟรี; รันสถานการณ์จากแผนของคุณ)
ใบอนุญาต/บัญชี	ไม่มีสำหรับ CLI	บัญชี Apidog สำหรับโปรเจกต์

มีสองสิ่งที่โดดเด่น ประการแรก ตัวรันทั้งสองครอบคลุมองค์ประกอบสำคัญของ CI เหมือนกัน: การเลือกสภาพแวดล้อม, การวนซ้ำที่ขับเคลื่อนด้วยข้อมูล, รูปแบบรายงานที่สำคัญสามรูปแบบ, และการจบการทำงานด้วยค่าที่ไม่ใช่ศูนย์เมื่อล้มเหลว ประการที่สอง ความแตกต่างอยู่ที่ตำแหน่งของการทดสอบและวิธีที่คุณเขียนมัน ไม่ใช่ความสามารถดิบ Bruno เก็บการทดสอบไว้ใน Repo เป็นข้อความ Apidog เก็บไว้ในโปรเจกต์เป็นสถานการณ์แบบภาพและรันโดยการอ้างอิง

ผู้รายงานและรหัสทางออก: ส่วนที่ CI อ่านจริงๆ

ตัวรันจะได้รับการยอมรับในไปป์ไลน์ผ่านพฤติกรรมสองอย่าง: รายงานที่เขียนและรหัสทางออกที่ส่งคืน ทำให้สองสิ่งนี้ถูกต้อง ส่วนที่เหลือก็คือการเชื่อมต่อ

Bruno เขียนรายงานด้วยแฟล็กตามรูปแบบ คุณต้องระบุเส้นทางสำหรับแต่ละรูปแบบที่คุณต้องการ:

bru run -r --env staging \
  --reporter-junit ./results/junit.xml \
  --reporter-html ./results/report.html \
  --reporter-json ./results/report.json

JUnit XML คือสิ่งที่แดชบอร์ด CI ของคุณใช้ในการแยกวิเคราะห์เป็นแผนผังผ่าน/ไม่ผ่าน รายงาน HTML เป็น Artifact ที่สามารถเรียกดูได้ --bail ของ Bruno หยุดการรันหลังจากคำขอ การทดสอบ หรือการยืนยันที่ล้มเหลวครั้งแรก ซึ่งช่วยให้การตอบกลับรวดเร็วในการทดสอบ Smoke Test หากไม่มี --bail มันจะรันทุกอย่างและรายงานความล้มเหลวทั้งหมดในคราวเดียว

Apidog ใช้แฟล็ก -r เดียวพร้อมกับรายการที่คั่นด้วยคอมมา และเขียนทุกอย่างภายใต้ไดเรกทอรีเอาต์พุตเดียว:

apidog run --access-token $APIDOG_ACCESS_TOKEN -t 605067 \
  -r html,junit --out-dir ./apidog-reports

แฟล็ก --on-error กำหนดพฤติกรรมระหว่างสถานการณ์: end หยุดเมื่อเกิดข้อผิดพลาดครั้งแรก (ค่าเริ่มต้น), continue รันทุกขั้นตอนเพื่อให้คุณรวบรวมข้อผิดพลาดทั้งหมดในรายงานเดียว, และ ignore ข้ามขั้นตอนที่รู้ว่ามีปัญหา อย่างไรก็ตาม การรันจะจบลงด้วยรหัสที่ไม่ใช่ศูนย์หากมีสิ่งใดล้มเหลว

สัญญาของรหัสทางออกเหมือนกันทั้งสองฝ่ายและเป็นส่วนที่รับภาระ เมื่อการยืนยันล้มเหลว ตัวรันจะออกจากระบบด้วยรหัสที่ไม่ใช่ศูนย์ CI จะอ่านรหัสนั้น, ทำเครื่องหมายขั้นตอนว่าล้มเหลว, ทำให้งานล้มเหลว และบล็อกการผสานหรือการปรับใช้ คุณไม่ต้องกำหนดค่าอะไรเพิ่มเติม ข้อผิดพลาดเดียวที่เหมือนกันสำหรับทั้งสองคือการกลืนรหัสทางออก: หากคุณห่อการรันใน Shell Pipeline หรือเพิ่ม || true, รหัสทางออกที่ไม่ใช่ศูนย์จะถูกกลืนไปและประตูจะหยุดทำงานอย่างเงียบๆ อย่าทำเช่นนั้น

Bruno CLI ใน GitHub Actions

เนื่องจากไฟล์ .bru อยู่ใน repo อยู่แล้ว ขั้นตอนการทำงานจึงสั้นมาก ตรวจสอบโค้ด, ติดตั้ง CLI, รัน Collection, อัปโหลดรายงาน

name: API tests

on:
  pull_request:
    branches: [main]

jobs:
  api-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Bruno CLI
        run: npm install -g @usebruno/cli

      - name: Run API tests
        working-directory: ./api-tests
        run: bru run -r --env staging --reporter-junit ./results/junit.xml

      - name: Upload report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: bruno-report
          path: ./api-tests/results

working-directory ชี้ไปที่โฟลเดอร์ที่เก็บ Collection ของคุณ if: always() ทำให้การอัปโหลดรายงานทำงานต่อไปแม้ว่าการทดสอบจะล้มเหลว ซึ่งเป็นช่วงเวลาที่คุณต้องการอ่านรายงานนั้นพอดี ไม่จำเป็นต้องมี Secret เนื่องจากไม่มีการตรวจสอบสิทธิ์กับบริการระยะไกล

Apidog CLI ใน GitHub Actions

เวิร์กโฟลว์ของ Apidog มีโครงสร้างเหมือนกัน โดยมีสิ่งเพิ่มเติมหนึ่งอย่าง: Access Token มาจาก Repository Secrets และคุณเลือกสถานการณ์ด้วย ID แทนที่จะเป็นเส้นทางโฟลเดอร์

name: API tests

on:
  pull_request:
    branches: [main]

jobs:
  api-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Apidog CLI
        run: npm install -g apidog-cli

      - name: Run API test scenario
        run: |
          apidog run \
            --access-token "$APIDOG_ACCESS_TOKEN" \
            -t 605067 \
            -e 1629989 \
            -r html,junit \
            --out-dir ./apidog-reports
        env:
          APIDOG_ACCESS_TOKEN: ${{ secrets.APIDOG_ACCESS_TOKEN }}

      - name: Upload report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: apidog-report
          path: ./apidog-reports

สังเกตความสมมาตร การเช็คเอาต์เหมือนกัน, การตั้งค่า Node เหมือนกัน, รูปแบบการติดตั้งแล้วรันเหมือนกัน, การอัปโหลดเสมอเหมือนกัน ความแตกต่างที่แท้จริงเพียงอย่างเดียวคือโทเค็นที่เชื่อมต่อเป็น Secret และสถานการณ์ที่เลือกด้วย ID หากคุณต้องการขยายสิ่งนี้ด้วย GitLab CI และ Jenkins ด้วย คู่มือ Apidog CLI ฉบับสมบูรณ์ จะใช้รูปแบบเดียวกันนี้กับตัวรันอื่นๆ

วิธีการเลือก

การตัดสินใจไม่ค่อยจะขึ้นอยู่กับว่าตัวรันตัวไหน "ดีกว่า" แต่มันขึ้นอยู่กับว่าทีมของคุณต้องการสร้างและจัดเก็บการทดสอบอย่างไร

เลือก Bruno เมื่อ Repo เป็นแหล่งความจริง. หากคุณต้องการให้ทุกการทดสอบเป็นไฟล์ข้อความธรรมดาที่อยู่ข้างโค้ดที่มันครอบคลุม ตรวจสอบใน Pull Request เดียวกัน โดยไม่ต้องมีบัญชีและไม่มีการเรียกเครือข่ายขณะรัน Bruno เหมาะสมกับโมเดลนั้นอย่างแน่นอน มันเป็นตัวเลือกตามธรรมชาติสำหรับทีมที่ปฏิบัติต่อการทดสอบเหมือนโค้ด ให้ความสำคัญกับเครื่องมือแบบออฟไลน์และโอเพ่นซอร์ส และสะดวกในการแก้ไขไฟล์ .bru โดยตรง Bruno Ultimate เพิ่มคุณสมบัติสำหรับทีมและธรรมาภิบาล เช่น SSO, SCIM, การผสานรวมกับผู้จัดการความลับ และการตรวจสอบ หากคุณต้องการเลเยอร์ทีมและการกำกับดูแลในภายหลัง ดังนั้นการเติบโตไปพร้อมกับมันจึงเป็นทางเลือกมากกว่าอุปสรรค

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

นอกจากนี้ยังมีคำตอบแบบใช้ทั้งสองเครื่องมือด้วย บางทีมเก็บไฟล์แบบ git-native ของ Bruno ไว้สำหรับการตรวจสอบคำขอระดับต่ำ และใช้ Apidog สำหรับสถานการณ์ที่เชื่อมโยงกันขนาดใหญ่และการรันการทดสอบ Regression ที่ต้องใช้สภาพแวดล้อมมาก CLI ทั้งสองสามารถทำงานร่วมกันได้อย่างลงตัวในไปป์ไลน์เดียว พวกมันเป็นขั้นตอนที่แยกจากกันโดยมีรหัสทางออกที่แยกจากกัน

หากคุณกำลังตัดสินใจเลือกระหว่างแพลตฟอร์มต่างๆ โดยรวม ไม่ใช่แค่ CLI เท่านั้น การเปรียบเทียบ Apidog vs Bruno ครอบคลุมการออกแบบ, การจำลอง, และการทำงานร่วมกันนอกเหนือจาก Command Line หากต้องการตั้งค่าสถานการณ์อัตโนมัติแรกของคุณและรันจากเทอร์มินัลในบ่ายวันเดียวกัน ให้ดาวน์โหลด Apidog และคัดลอกคำสั่งที่สร้างขึ้นจากแท็บ CI/CD ของสถานการณ์ใดๆ

button

คำถามที่พบบ่อย

Bruno CLI ฟรีหรือไม่?

ฟรี Bruno CLI เป็นโอเพ่นซอร์สและมาในรูปแบบแพ็คเกจ npm @usebruno/cli มันทำงานทั้งหมดบนเครื่องของคุณหรือ CI runner โดยไม่มีบัญชีหรือโทเค็น Bruno Ultimate เป็นระดับที่ต้องชำระเงินแยกต่างหากที่เพิ่มคุณสมบัติสำหรับทีมและการกำกับดูแล เช่น SSO, SCIM, การผสานรวมกับตัวจัดการความลับ และการตรวจสอบ แต่ตัว CLI นั้นฟรี

Apidog CLI ฟรีหรือไม่?

CLI เป็นแพ็คเกจ npm ฟรี คือ apidog-cli มันรันสถานการณ์การทดสอบจากโปรเจกต์ Apidog ของคุณ ดังนั้นสิ่งที่คุณสามารถรันได้ขึ้นอยู่กับแผน Apidog ของคุณ แต่ตัวรันแบบบรรทัดคำสั่งนี้ไม่ใช่ผลิตภัณฑ์ที่ต้องชำระเงินแยกต่างหาก

ฉันต้องเขียนการทดสอบเป็นโค้ดสำหรับตัวรันทั้งสองหรือไม่?

สำหรับ Bruno การทดสอบของคุณคือไฟล์ .bru ที่คุณสามารถแก้ไขด้วยตนเองหรือสร้างในแอป Bruno ดังนั้นจึงมีรูปแบบข้อความที่คุณจะต้องสัมผัสโดยตรง สำหรับ Apidog คุณสร้างสถานการณ์ด้วยภาพในแอป และ CLI จะรันตาม ID ดังนั้นคุณจึงไม่ต้องดูแลโค้ดทดสอบด้วยตนเอง นั่นคือความแตกต่างหลักในการสร้างระหว่างทั้งสอง

ตัวรันทั้งสองตัวจะทำให้ Build ล้มเหลวเมื่อการทดสอบล้มเหลวหรือไม่?

ใช่ ทั้งคู่จะจบการทำงานด้วยรหัสที่ไม่ใช่ศูนย์เมื่อมีการยืนยันล้มเหลว ซึ่ง CI จะอ่านเพื่อทำเครื่องหมายขั้นตอนว่าล้มเหลวและบล็อกการรวมหรือการปรับใช้ --bail ของ Bruno จะหยุดเมื่อเกิดข้อผิดพลาดครั้งแรก; --on-error end ของ Apidog ก็ทำเช่นเดียวกันและเป็นค่าเริ่มต้น หลีกเลี่ยงการห่อการรันด้วย || true ซึ่งจะกลืนรหัสทางออกและทำให้ประตูหยุดทำงาน

ฉันควรใช้รูปแบบรายงานใดใน CI?

ใช้ JUnit XML สำหรับผลลัพธ์ที่เครื่องสามารถอ่านได้ซึ่งแดชบอร์ด CI ของคุณจะแยกวิเคราะห์เป็นแผนผังผ่าน/ไม่ผ่าน และเพิ่ม HTML หากคุณต้องการ Artifact ที่สามารถเรียกดูได้ Bruno เขียนด้วย --reporter-junit และ --reporter-html; Apidog ใช้ -r html,junit ทั้งคู่ยังรองรับ JSON สำหรับการประมวลผลหลังการรันแบบกำหนดเอง

Bruno CLI จำเป็นต้องมีการเชื่อมต่ออินเทอร์เน็ตหรือบัญชีเพื่อรันหรือไม่?

ไม่ Bruno รันไฟล์ .bru ใน repository ของคุณแบบโลคอล โดยไม่มีการล็อกอินและไม่มีการดึงข้อมูลระยะไกล ซึ่งทำให้เหมาะสำหรับ CI แบบออฟไลน์หรือ air-gapped ส่วน CLI ของ Apidog จะตรวจสอบสิทธิ์ด้วย Access Token และดึงสถานการณ์จากโปรเจกต์ของคุณ ดังนั้นจึงจำเป็นต้องมีการเข้าถึงเครือข่ายไปยังบริการ Apidog ในขณะที่รัน

ฉันสามารถรัน CLI ตัวใดตัวหนึ่งโดยไม่ต้องติดตั้งแบบ Global ได้หรือไม่?

ได้ทั้งคู่ ใช้ npx @usebruno/cli run ... หรือ npx apidog-cli run ... เพื่อดำเนินการโดยไม่ต้องติดตั้งแบบ Global แบบถาวร ซึ่งสะดวกสำหรับ CI runner ที่มีอายุการใช้งานสั้นๆ รัน bru run --help หรือ apidog run --help เพื่อยืนยันตัวเลือกที่แน่นอนที่มีในเวอร์ชันที่คุณติดตั้ง