Bruno CLI vs Apidog CLI: Chạy kiểm thử API trong CI

Các thử nghiệm API của bạn chạy thành công trên máy tính xách tay của bạn. Câu hỏi thực sự là liệu chúng có chạy trên mỗi pull request, mỗi merge, mỗi bản dựng nightly, mà không cần con người nhấp chuột vào bất cứ thứ gì hay không. Công việc đó thuộc về một trình chạy dòng lệnh. Nó lấy các thử nghiệm mà bạn đã tạo và thực thi chúng không giao diện (headless) bên trong pipeline của bạn, thoát với mã trạng thái rõ ràng, và ghi một báo cáo mà bảng điều khiển CI của bạn có thể đọc được.

Hai trình chạy thường xuyên được nhắc đến khi các nhóm thiết lập điều này là Bruno CLI và Apidog CLI. Chúng giải quyết cùng một vấn đề nhưng từ những điểm khởi đầu khác nhau. Bruno là một API client ưu tiên git, ưu tiên ngoại tuyến, mã nguồn mở, và CLI của nó chạy các tệp .bru nằm trong kho lưu trữ của bạn. Apidog là một nền tảng API tất cả trong một, và CLI của nó chạy các kịch bản kiểm thử trực quan mà bạn xây dựng trong ứng dụng. Cả hai đều tích hợp với GitHub Actions, GitLab CI, Jenkins, và bất kỳ hệ thống nào khác có Node.js. Cả hai đều làm gián đoạn bản dựng khi một thử nghiệm thất bại. Sự khác biệt nằm ở cách bạn tạo thử nghiệm, cách bạn xác thực, và cách định nghĩa thử nghiệm di chuyển vào CI.

button

Đây là một so sánh trung thực, ở cấp lệnh giữa hai công cụ này. Không có sự phóng đại. Bruno thực sự làm tốt một số việc, và bạn sẽ thấy chính xác vị trí phù hợp của từng trình chạy trước khi bạn tích hợp một trong số chúng vào pipeline của mình.

TL;DR

Bruno CLI (@usebruno/cli, binary bru) chạy các tệp .bru trực tiếp từ một thư mục trong kho lưu trữ git của bạn. Nó là mã nguồn mở, ngoại tuyến và không cần tài khoản hay token. Bạn chỉ nó vào một thư mục và nó chạy mọi yêu cầu và xác nhận mà nó tìm thấy.
Apidog CLI (apidog-cli, binary apidog) chạy các kịch bản kiểm thử mà bạn thiết kế trong ứng dụng Apidog, được tìm nạp bằng ID sử dụng access token. Bạn không viết lại các thử nghiệm dưới dạng mã; kịch bản trực quan là thử nghiệm, và CLI thực thi nó không giao diện.
Cả hai đều xuất báo cáo JUnit, JSON và HTML, và cả hai đều làm gián đoạn bản dựng khi một thử nghiệm thất bại. JUnit XML là định dạng tích hợp vào bảng điều khiển CI trong cả hai trường hợp.
Chọn Bruno khi bạn muốn mọi thứ nằm trong kho lưu trữ, không cần tài khoản, và kiểm soát hoàn toàn ngoại tuyến các tệp thử nghiệm văn bản thuần túy.
Chọn Apidog khi bạn muốn tạo thử nghiệm trực quan, chuỗi kịch bản, quản lý môi trường, và chạy dựa trên dữ liệu mà không cần duy trì mã thử nghiệm thủ công.

Vấn đề thực sự: Các thử nghiệm tồn tại nhưng không bao giờ chạy

Một thử nghiệm bạn chạy thủ công là một thử nghiệm lỗi thời. Ai đó đã xây dựng nó, nó đã chạy thành công một lần, và sau đó nó nằm yên không được chạm tới trong khi API thay đổi bên dưới. Giải pháp không phải là có thêm nhiều thử nghiệm. Mà là các thử nghiệm chạy tự động trên mỗi thay đổi, với tín hiệu pass/fail mà pipeline có thể hành động dựa trên đó.

Một trình chạy CLI là thứ giúp lấp đầy khoảng trống đó. Nó cần ba điều để hữu ích trong CI: nó phải chạy mà không có GUI, nó phải thoát với mã khác 0 khi có gì đó thất bại để bản dựng chuyển sang màu đỏ, và nó phải ghi một báo cáo có thể đọc được bằng máy để người xem biết điều gì đã bị hỏng. Bruno và Apidog đều vượt qua tiêu chuẩn đó. Điểm khác biệt nằm ở phía trước lệnh chạy, ở cách thử nghiệm được viết và nơi nó tồn tại.

Nếu bạn đang thiết lập CI từ đầu, các mẫu rộng hơn trong bài viết tự động hóa thử nghiệm API trong CI/CD đáng đọc kèm theo so sánh này. Ở đây chúng ta tập trung vào hai trình chạy này.

Những điểm Bruno CLI làm tốt

Toàn bộ thiết kế của Bruno là ưu tiên git. Mỗi yêu cầu, môi trường và xác nhận là một tệp .bru văn bản thuần túy trên đĩa, bên trong kho lưu trữ của bạn, được kiểm soát phiên bản như bất kỳ tệp nguồn nào khác. Mô hình đó có những lợi thế thực sự, và đáng để trình bày rõ ràng trước khi so sánh.

Các thử nghiệm của bạn sống cùng với mã của bạn. Một pull request thay đổi một endpoint có thể thay đổi thử nghiệm cho endpoint đó trong cùng một diff, được xem xét bởi cùng một người. Không có hệ thống riêng biệt để đồng bộ, không có bản sao đám mây có thể lệch khỏi những gì có trong kho lưu trữ. Các diff dễ đọc vì định dạng là văn bản. Bạn có thể tìm kiếm các thử nghiệm của mình, tái cấu trúc chúng bằng các công cụ tương tự bạn dùng cho mã, và giải quyết xung đột hợp nhất trong trình chỉnh sửa.

Nó cũng là mã nguồn mở và ngoại tuyến. CLI chạy hoàn toàn trên máy của bạn hoặc trình chạy CI của bạn mà không cần tài khoản, không cần đăng nhập và không cần token. Đối với các nhóm có quy tắc xử lý dữ liệu nghiêm ngặt hoặc môi trường air-gapped, điều đó rất quan trọng. Gói trả phí của Bruno, Bruno Ultimate, bổ sung các tính năng nhóm bao gồm SSO và SCIM, tích hợp quản lý bí mật và khả năng kiểm toán, vì vậy dự án không chỉ là một công cụ dành cho người có sở thích. Nhưng client cốt lõi và CLI là miễn phí và độc lập, và đó là một sức mạnh hợp pháp.

Cài đặt nó chỉ cần một lệnh:

npm install -g @usebruno/cli

Binary là bru. Bạn chạy một collection bằng cách chỉ nó vào thư mục chứa các tệp .bru của bạn:

bru run --env staging

Chạy từ bên trong thư mục collection và bru run thực thi các yêu cầu mà nó tìm thấy ở đó. Thêm -r để đệ quy qua các thư mục con để nó tìm thấy các yêu cầu lồng nhau:

bru run -r --env staging

Đó là vòng lặp cốt lõi. Không có ID, không có token, không tìm nạp từ xa. Các tệp trong thư mục là các thử nghiệm, và CLI chạy chúng.

Chúng tôi đã đề cập đến câu chuyện rộng hơn của Bruno trong bài viết điều gì làm Bruno khác biệt như một API client ưu tiên git và nơi những hạn chế của nó xuất hiện đối với các nhóm lớn hơn. Đối với CI cụ thể, những điểm mạnh trên là những điểm đáng kể.

Những điểm Apidog CLI làm tốt

Apidog đi theo một con đường khác để đạt được cùng một pipeline. Bạn xây dựng các thử nghiệm trực quan trong ứng dụng Apidog: xâu chuỗi các yêu cầu thành một kịch bản, thêm các xác nhận, lấy một giá trị từ một phản hồi vào yêu cầu tiếp theo, và lặp lại toàn bộ quá trình qua một tệp dữ liệu. CLI là trình thực thi không giao diện cho các kịch bản đó. Nó không có định dạng tệp riêng. Nó tìm nạp kịch bản bạn đặt tên bằng ID từ dự án Apidog của bạn và chạy nó chính xác như cách ứng dụng sẽ làm.

Ưu điểm là không ai phải duy trì hai biểu diễn của cùng một thử nghiệm. Kịch bản trong dự án là thử nghiệm. Bạn tạo nó trong một trình xây dựng trực quan xử lý việc xâu chuỗi yêu cầu, trích xuất biến và xác nhận mà không cần bạn phải viết và gỡ lỗi các tệp script. Sau đó, CLI chạy cùng kịch bản đó trong CI. Vòng lặp tạo nhanh và vòng lặp tự động hóa sử dụng một nguồn sự thật duy nhất.

Cài đặt là một lệnh npm:

npm install -g apidog-cli

Binary là apidog. Một lần chạy điển hình đặt tên kịch bản bằng ID, chọn một môi trường và xác thực bằng một access token:

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

Bạn không gõ các ID đó bằng tay. Mở kịch bản kiểm thử, chuyển sang tab CI/CD của nó, tạo một access token, và Apidog sẽ xây dựng lệnh đầy đủ cho bạn với ID kịch bản và ID môi trường đã được điền sẵn. Bạn sao chép nó một lần, sau đó di chuyển token vào một bí mật CI và tham chiếu nó dưới dạng $APIDOG_ACCESS_TOKEN. Toàn bộ tham chiếu cờ có trong hướng dẫn đầy đủ về Apidog CLI nếu bạn muốn tất cả các tùy chọn ở một nơi.

Mô hình dựa trên token là sự khác biệt rõ ràng nhất so với Bruno. Apidog chạy các thử nghiệm được lưu trữ trong một dự án mà CLI truy cập qua mạng, đã được xác thực. Bruno chạy các thử nghiệm được lưu trữ dưới dạng tệp mà CLI đọc từ đĩa. Cả hai đều không sai; chúng phù hợp với các thiết lập nhóm khác nhau.

So sánh đối chiếu

Khía cạnh	Bruno CLI (`bru`)	Apidog CLI (`apidog`)
Gói	`@usebruno/cli`	`apidog-cli`
Lệnh chạy	`bru run`	`apidog run`
Nguồn thử nghiệm	Các tệp `.bru` trong kho lưu trữ git của bạn	Các kịch bản thử nghiệm trong dự án Apidog của bạn, được tìm nạp bằng ID
Tạo thử nghiệm	Chỉnh sửa thủ công các tệp văn bản hoặc sử dụng ứng dụng Bruno	Trình xây dựng kịch bản trực quan trong ứng dụng Apidog
Xác thực trong CI	Không; chạy ngoại tuyến	Access token (`--access-token`)
Chọn những gì chạy	Đường dẫn thư mục, `-r` đệ quy, `--tags`	`-t` kịch bản, `-f` thư mục, `--test-suite`
Môi trường	`--env <tên>`	`-e <environmentId>`
Hướng dữ liệu	`--csv-file-path`, `--json-file-path`	`-d <đường dẫn>` (CSV hoặc JSON)
Lặp lại	`--iteration-count <n>`	`-n <n>`
Bộ báo cáo	JSON, JUnit, HTML	`cli`, `html`, `json`, `junit`
Thất bại nhanh	`--bail`	`--on-error end` (mặc định thất bại khi có lỗi đầu tiên)
Mã nguồn mở	Có	Không (CLI npm miễn phí; chạy các kịch bản từ gói của bạn)
Giấy phép/tài khoản	Không cần cho CLI	Tài khoản Apidog cho dự án

Có hai điều nổi bật. Thứ nhất, cả hai trình chạy đều bao gồm các yếu tố cần thiết của CI: lựa chọn môi trường, lặp lại theo dữ liệu, ba định dạng báo cáo quan trọng và thoát với mã khác 0 khi thất bại. Thứ hai, sự khác biệt nằm ở nơi thử nghiệm được lưu trữ và cách bạn viết nó, chứ không phải về khả năng thô. Bruno giữ thử nghiệm trong kho lưu trữ dưới dạng văn bản. Apidog giữ nó trong dự án dưới dạng một kịch bản trực quan và chạy nó bằng cách tham chiếu.

Bộ báo cáo và mã thoát: những phần CI thực sự đọc

Một trình chạy xứng đáng có vị trí trong một pipeline thông qua hai hành vi: báo cáo nó viết và mã thoát nó trả về. Làm đúng những điều này thì phần còn lại chỉ là kết nối.

Bruno viết báo cáo với các cờ theo định dạng. Bạn truyền một đường dẫn cho mỗi định dạng bạn muốn:

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

JUnit XML là định dạng mà bảng điều khiển CI của bạn phân tích thành một cây pass/fail. Báo cáo HTML là một artifact có thể duyệt được. Cờ --bail của Bruno dừng chạy sau yêu cầu, thử nghiệm hoặc xác nhận đầu tiên bị lỗi, giúp phản hồi nhanh chóng trong một thử nghiệm khói. Không có --bail, nó sẽ chạy tất cả và báo cáo tất cả các lỗi cùng một lúc.

Apidog sử dụng một cờ -r duy nhất với một danh sách được phân tách bằng dấu phẩy và ghi tất cả mọi thứ vào một thư mục đầu ra:

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

Cờ --on-error của nó định hình hành vi giữa kịch bản: end dừng ở lỗi đầu tiên (mặc định), continue chạy mọi bước để bạn thu thập tất cả các lỗi trong một báo cáo, và ignore bỏ qua một bước có thể thất bại đã biết. Dù bằng cách nào, quá trình chạy sẽ kết thúc với mã khác 0 nếu có bất kỳ điều gì thất bại.

Hợp đồng mã thoát là như nhau ở cả hai phía và đó là phần chịu tải. Khi một xác nhận thất bại, trình chạy thoát với mã khác không. CI đọc mã đó, đánh dấu bước thất bại, làm cho job thất bại, và chặn việc hợp nhất hoặc triển khai. Bạn không cần cấu hình thêm gì cả. Một cái bẫy, giống hệt nhau cho cả hai, là nuốt mã thoát: nếu bạn bao bọc quá trình chạy trong một pipeline shell hoặc thêm || true, mã thoát khác không sẽ bị nuốt và cổng sẽ ngừng hoạt động một cách im lặng. Đừng làm như vậy.

Bruno CLI trong GitHub Actions

Vì các tệp .bru đã có trong kho lưu trữ, quy trình làm việc rất ngắn gọn. Lấy mã, cài đặt CLI, chạy collection, tải báo cáo lên.

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 trỏ đến thư mục chứa collection của bạn. if: always() giữ cho việc tải báo cáo lên chạy ngay cả khi các thử nghiệm thất bại, đây chính là lúc bạn muốn đọc nó. Không cần bí mật vì không có gì xác thực với một dịch vụ từ xa.

Apidog CLI trong GitHub Actions

Quy trình làm việc của Apidog về mặt cấu trúc là giống nhau, với một bổ sung: access token đến từ các bí mật của kho lưu trữ, và bạn chọn kịch bản bằng ID thay vì bằng đường dẫn thư mục.

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

Lưu ý sự đối xứng. Cùng checkout, cùng thiết lập Node, cùng hình thức cài đặt rồi chạy, cùng luôn tải lên. Sự khác biệt thực sự duy nhất là token được kết nối như một bí mật và kịch bản được chọn bằng ID. Nếu bạn muốn mở rộng điều này với các biến thể GitLab CI và Jenkins, hướng dẫn đầy đủ về Apidog CLI mang cùng một mẫu trên các trình chạy.

Cách lựa chọn

Quyết định hiếm khi phụ thuộc vào việc trình chạy nào "tốt hơn". Nó phụ thuộc vào cách nhóm của bạn muốn tạo và lưu trữ các thử nghiệm.

Chọn Bruno khi kho lưu trữ là nguồn sự thật. Nếu bạn muốn mọi thử nghiệm là một tệp văn bản thuần túy nằm cạnh mã mà nó bao quát, được xem xét trong cùng một pull request, không cần tài khoản và không cần gọi mạng khi chạy, Bruno hoàn toàn phù hợp với mô hình đó. Đây là lựa chọn tự nhiên cho các nhóm coi thử nghiệm là mã, coi trọng công cụ ngoại tuyến và mã nguồn mở, và thoải mái chỉnh sửa trực tiếp các tệp .bru. Bruno Ultimate bổ sung SSO, SCIM, tích hợp quản lý bí mật và các tính năng kiểm toán nếu sau này bạn cần lớp quản lý và nhóm, vì vậy việc phát triển lên đó là một lựa chọn chứ không phải một rào cản.

Chọn Apidog khi tốc độ tạo thử nghiệm và quy trình làm việc tích hợp quan trọng hơn việc kiểm soát cấp độ tệp. Nếu bạn muốn xây dựng một kịch bản thử nghiệm trực quan, xâu chuỗi các yêu cầu, trích xuất biến và chạy cùng một kịch bản trên các môi trường mà không cần tự tay viết và gỡ lỗi mã thử nghiệm, mô hình của Apidog sẽ loại bỏ sự khó khăn đó. Thiết kế, gỡ lỗi, mô phỏng và thử nghiệm đều diễn ra trong một không gian làm việc, và CLI chạy chính xác kịch bản bạn đã xây dựng. Đối với các nhóm chuyển từ thiết lập Postman, mô hình tư duy được ánh xạ rõ ràng, và lộ trình di chuyển là một trong những điều Apidog đáp ứng như một giải pháp thay thế Postman tốt nhất cho thử nghiệm API.

Cũng có một câu trả lời là sử dụng cả hai công cụ. Một số nhóm giữ các tệp ưu tiên git của Bruno cho các kiểm tra yêu cầu cấp thấp và sử dụng Apidog cho các kịch bản chuỗi lớn hơn và các lần chạy regression nặng về môi trường. Hai CLI này cùng tồn tại tốt trong một pipeline; chúng là các bước riêng biệt với các mã thoát riêng biệt.

Nếu bạn đã quyết định giữa các nền tảng nói chung, không chỉ các CLI, thì so sánh Apidog vs Bruno bao gồm thiết kế, mô phỏng và cộng tác ngoài dòng lệnh. Để thiết lập kịch bản tự động đầu tiên của bạn và chạy nó từ terminal cùng buổi chiều, hãy tải xuống Apidog và sao chép lệnh được tạo từ tab CI/CD của bất kỳ kịch bản nào.

button

Các câu hỏi thường gặp

Bruno CLI có miễn phí không?

Có. Bruno CLI là mã nguồn mở và được phân phối dưới dạng gói npm @usebruno/cli. Nó chạy hoàn toàn trên máy của bạn hoặc trình chạy CI mà không cần tài khoản hay token. Bruno Ultimate là một gói trả phí riêng biệt bổ sung các tính năng nhóm và quản trị như SSO, SCIM, tích hợp quản lý bí mật và kiểm toán, nhưng bản thân CLI là miễn phí.

Apidog CLI có miễn phí không?

CLI là một gói npm miễn phí, apidog-cli. Nó chạy các kịch bản thử nghiệm từ dự án Apidog của bạn, vì vậy những gì bạn có thể chạy phụ thuộc vào gói Apidog của bạn, nhưng trình chạy dòng lệnh không phải là một sản phẩm trả phí riêng biệt.

Tôi có phải viết thử nghiệm dưới dạng mã cho một trong hai trình chạy này không?

Đối với Bruno, các thử nghiệm của bạn là các tệp .bru mà bạn có thể chỉnh sửa thủ công hoặc tạo trong ứng dụng Bruno, vì vậy có một định dạng văn bản mà bạn sẽ tương tác trực tiếp. Đối với Apidog, bạn xây dựng các kịch bản trực quan trong ứng dụng và CLI chạy chúng bằng ID, vì vậy bạn không cần duy trì mã thử nghiệm bằng tay. Đó là sự khác biệt cốt lõi trong việc tạo thử nghiệm giữa hai công cụ này.

Cả hai trình chạy có làm gián đoạn bản dựng khi một thử nghiệm thất bại không?

Có. Cả hai đều thoát với mã khác 0 khi một xác nhận thất bại, mà CI đọc để đánh dấu bước đó là thất bại và chặn việc hợp nhất hoặc triển khai. Cờ --bail của Bruno dừng ở lỗi đầu tiên; cờ --on-error end của Apidog cũng làm điều tương tự và là mặc định. Tránh bao bọc bất kỳ lần chạy nào bằng || true, điều này sẽ nuốt mã thoát và làm hỏng cổng.

Tôi nên sử dụng định dạng báo cáo nào trong CI?

Sử dụng JUnit XML cho kết quả có thể đọc được bằng máy mà bảng điều khiển CI của bạn phân tích thành một cây pass/fail, và thêm HTML nếu bạn muốn một artifact có thể duyệt được. Bruno viết chúng bằng --reporter-junit và --reporter-html; Apidog sử dụng -r html,junit. Cả hai cũng hỗ trợ JSON cho việc xử lý hậu kỳ tùy chỉnh.

Bruno CLI có cần kết nối internet hoặc tài khoản để chạy không?

Không. Bruno chạy các tệp .bru trong kho lưu trữ của bạn cục bộ, không cần đăng nhập và không tìm nạp từ xa, điều này làm cho nó phù hợp với CI ngoại tuyến hoặc air-gapped. CLI của Apidog xác thực bằng access token và tìm nạp kịch bản từ dự án của bạn, vì vậy nó cần truy cập mạng đến dịch vụ Apidog tại thời điểm chạy.

Tôi có thể chạy một trong hai CLI mà không cần cài đặt toàn cục không?

Có, đối với cả hai. Sử dụng npx @usebruno/cli run ... hoặc npx apidog-cli run ... để thực thi mà không cần cài đặt toàn cục liên tục, điều này tiện lợi trên các trình chạy CI tạm thời. Chạy bru run --help hoặc apidog run --help để xác nhận các tùy chọn chính xác có sẵn trong phiên bản đã cài đặt của bạn.